Volltext - Praktische Informatik

Transcription

Universität Siegen
Fachbereich 12 - Elektrotechnik und Informatik
Diplomarbeit
Vergleich molekularer Graphen mit Hilfe des
SiDiff-Algorithmus
Oliver Grassow
Erstprüfer: Prof. Dr. Udo Kelter, Universität Siegen
Zweitprüfer: Prof. Dr.-Ing. Madjid Fathi Torbaghan, Universität Siegen
Siegen, im November 2008
Inhaltsverzeichnis
1 Einleitung ........................................................................................................... 1
1.1
1.2
Aufgabenstellung und Motivation .............................................................. 1
Aufbau der Ausarbeitung ........................................................................... 2
2 Molekulare Graphen ......................................................................................... 4
2.1
2.2
2.3
2.4
Einordnung Wirkstoffentwurf .................................................................... 4
Aufbau und Eigenschaften molekularer Graphen ...................................... 5
Notationen und Dateiformate ..................................................................... 7
Feature Trees ............................................................................................ 10
3 Differenzberechnung mit SiDiff ..................................................................... 14
3.1
3.2
3.3
Der SiDiff-Algorithmus............................................................................ 14
Konfigurierbarkeit .................................................................................... 17
Anpassungserfordernisse .......................................................................... 19
4 Markierungsprozess funktioneller Gruppen ................................................ 23
4.1
4.2
Verwendete funktionelle Gruppen ........................................................... 23
Algorithmus zur Gruppenmarkierung ...................................................... 25
4.2.1
4.2.2
4.2.3
4.3
Verfahren zum Pattern Matching ...................................................... 25
Verfahren zur Markierung funktioneller Gruppen ............................ 28
Verwendeter Algorithmus ................................................................. 32
Dateiformat zur Speicherung .................................................................... 36
5 Integration in die Differenzberechnung ....................................................... 39
5.1
5.2
Datenmodell molekularer Graphen .......................................................... 39
Anpassung der Konfigurationsskripte ...................................................... 42
5.2.1
5.2.2
5.2.3
5.3
5.4
CandidatesConfig .............................................................................. 42
CompareConfig ................................................................................. 43
MatchingConfig ................................................................................ 49
Integration der Gruppenmarkierung ......................................................... 51
Verwendete Ähnlichkeitsmetriken ........................................................... 53
6 Ergebnisse ........................................................................................................ 56
6.1
6.2
6.3
Testumgebung .......................................................................................... 56
Testdatenbestand ...................................................................................... 56
Testläufe ................................................................................................... 58
6.3.1
6.3.2
Markierung funktioneller Gruppen ................................................... 59
Vergleich molekularer Graphen ........................................................ 61
II
6.4
Evaluierung der Ergebnisse ...................................................................... 67
7 Zusammenfassung und Ausblick ................................................................... 70
A Katalog funktioneller Gruppen...................................................................... 72
Gruppen mit Kohlenstoff.................................................................................... 72
Gruppen mit Halogen ......................................................................................... 72
Gruppen mit Sauerstoff ...................................................................................... 73
Gruppen mit Stickstoff ....................................................................................... 74
Gruppen mit Phosphor........................................................................................ 76
Gruppen mit Schwefel ........................................................................................ 76
Polyzyklische Kohlenstoffstrukturen ................................................................. 77
B Algorithmus zur Markierung funktioneller Gruppen ................................. 78
C Testergebnisse Gruppenmarkierung ............................................................. 80
Testläufe mit speziellen Teststrukturen .............................................................. 80
Testläufe mit Molekülen des Datenbestands ...................................................... 87
Laufzeiten für Gruppenmarkierung .................................................................... 88
D Testergebnisse Molekülvergleich ................................................................... 89
Getestete Konfigurationen .................................................................................. 89
Testläufe mit speziellen Teststrukturen .............................................................. 91
Testläufe mit Molekülen des Datenbestands ...................................................... 93
Laufzeiten für Molekülvergleiche .................................................................... 100
Literaturverzeichnis........................................................................................... 101
III
Abbildungsverzeichnis
2.1 Hierarchie der Repräsentationen ........................................................................ 5
2.2 Beispiele SLN und SMILES für einen aromatischen Ring................................ 8
2.3 Beispiel einer MOL-Datei .................................................................................. 9
2.4 Beispiel CML-Datei aus Testdatenbestand ...................................................... 10
2.5 Beispiel zur Erzeugung eines Feature Tree...................................................... 11
3.1 Datenmodell des SiDiff-Vergleichsalgorithmus .............................................. 15
3.2 Schematischer Ablauf der Matching-Phase ..................................................... 16
3.3 Korrespondenzbildung für zwei Moleküle ...................................................... 20
3.4 Zuordnungsproblematik bei gespiegelten Strukturen ...................................... 21
4.1 Beispielmuster für die Verbindungsklassen der Alkene und Nitrate ............... 24
4.2 Überblick über den rekursiven Pattern Matching Prozess ............................... 27
4.3 Beispiel verwendeter Datenstrukturen in [IGPM-VVS] .................................. 28
4.4 Beispielstrukturen für Algorithmus zur Markierung funktioneller Gruppen ... 29
4.5 Beispielbelegung Matching Tree bei Mustersuche .......................................... 30
4.6 Beispiel zur Ermittlung der kanonischen Nummerierung................................ 32
4.7 Klassendiagramm der Molekülstruktur ............................................................ 33
4.8 Klassendiagramm der Verwaltungsstrukturen ................................................. 33
4.9 Beispielsituation bei Markierung eines Imide-Musters ................................... 35
4.10 DTD zur Definition der markierten Moleküle ............................................... 37
4.11 DTD zur Definition der Muster funktioneller Gruppen ................................. 38
5.1 Internes Datenmodell für die Differenzberechnung......................................... 40
5.2 Molekül-Datenmodell im internen SiDiff-Graphen ......................................... 42
5.3 Auszug der CandidatesConfig zum Vergleich molekularer Graphen .............. 43
5.4 Auszug der CompareConfig............................................................................. 48
5.5 Auszug aus MatchingConfig ............................................................................ 51
5.6 Markierte Strukturen für Vergleich .................................................................. 54
6.1 Zusammensetzung des Datenbestands ............................................................. 58
6.2 Zeitaufwand zur Markierung des Datenbestands ............................................. 61
6.3 Zeitaufwand zur Markierung einzelner Moleküle ........................................... 61
6.4 Korrespondenzbildung beim Vergleich von Molekül 5 mit Molekül 457 ....... 64
6.5 Aufwand zum Vergleich mit dem Datenbestand ............................................. 66
IV
Zusammenfassung
Die Bioinformatik beschäftigt sich unter anderem mit dem medizinischen Teilbereich
des Wirkstoffentwurfs. Ein wichtiger Schritt innerhalb dieses Prozesses ist die Ermittlung von Molekülstrukturen, die zu einem Anfragemolekül eine möglichst hohe
strukturelle Ähnlichkeit aufweisen.
Der in der Fachgruppe der Praktischen Informatik der Universität Siegen entwickelte
SiDiff-Algorithmus erfüllt die Aufgabe, Differenzen zwischen unterschiedlichen Versionen eines technischen Dokuments zu ermitteln und sehr detailliert anzuzeigen. Zu
diesem Zweck werden die Dokumente intern in Graphen umgewandelt, die anschließend entsprechend des strukturellen Aufbaus sowie der Eigenschaften der Elemente
verglichen werden. Aufgrund dieses strukturellen Vergleichsablaufs, der Hochkonfigurierbarkeit des Algorithmus und der ausgesprochen detaillierten Differenzermittlung wird in der vorliegenden Arbeit untersucht, inwieweit der SiDiff-Algorithmus
geeignet ist, um molekulare Graphen effizient miteinander zu vergleichen.
Im Rahmen dieser Arbeit wird ein Verfahren vorgestellt, mit dessen Hilfe Substrukturen in Form von funktionellen Gruppen in den zu vergleichenden Molekülen markiert
werden können, um diese mit zusätzlichen Eigenschaften anzureichern. Ausgelegt auf
den Vergleich dieser markierten Moleküle erfolgt anschließend eine Anpassung und
Konfiguration des Vergleichswerkzeugs. Anhand eines Testdatenbestands wird die
Genauigkeit und Effizienz der eingesetzten Verfahren untersucht.
V
1 Einleitung
1.1
Aufgabenstellung und Motivation
Im Rahmen der Softwareentwicklung, speziell dem Bereich der Softwaremodellierung, hat sich im Laufe der letzten Jahre die UML (Unified Modeling Language) mit
ihren vielfältigen Diagrammtypen als Modellierungsstandard durchgesetzt. Der Einsatz von Diagrammen bei der Softwareentwicklung unterstützt die Kommunikation
sowohl der Anwender mit den Entwicklern als auch der Entwickler untereinander.
Ein weiterer Grund für die Verwendung von Modellen stellt das Entwicklungskonzept der MDA (Model Driven Architecture) dar, wonach ein Modell ein System auf
einer höheren Abstraktionsstufe beschreibt als Code und somit der Code nur eine
Ausgestaltung des Modells darstellen sollte (vgl. [Kel05]).
Während der gesamten Entwicklung, besonders jedoch in den frühen Entwicklungsphasen, entstehen zahlreiche Dokumente, die durch sämtliche Phasen hindurch
ständig bearbeitet und weiterentwickelt werden, was eine Versionierung dieser Dokumente erforderlich macht. Verteilte Entwicklerteams und parallele Bearbeitung
machen es häufig erforderlich, dass sich Entwickler die Differenzen zwischen zwei
Versionen eines Dokuments ermitteln und anzeigen lassen müssen. Sowohl für die
Differenzberechnung auf rein textbasierten Dokumenten, als auch für den Vergleich
von Diagrammen, die durch einen hohen Grad an Strukturiertheit gekennzeichnet
sind, haben sich mittlerweile mehrere Standards etabliert, die in gängigen Versionsmanagementsystemen zum Einsatz kommen. Im Fokus dieser Arbeit steht der SiDiffAlgorithmus, der dazu entwickelt wurde, Versionen technischer Dokumente, hauptsächlich von UML-Diagrammen, zu vergleichen und deren Differenzen zu ermitteln.
Zu diesem Zweck werden die Elemente der zu vergleichenden Dokumente zunächst
in eine Graph-Darstellung transformiert, so dass der eigentliche Vergleichsvorgang
im Folgenden auf diesen Graphen vorgenommen werden kann. Neben den rein strukturellen Merkmalen werden auch die Eigenschaften der Elemente in diesen Vergleichsprozess miteinbezogen. Wie die bisherigen Untersuchungen zeigen, erreicht
der SiDiff-Algorithmus gute Laufzeiten für den Vergleich kleiner Dokumente und
akzeptable für den Vergleich großer Modelle, bei einer sehr geringen Fehlerrate (vgl.
[Kel05]). Eine hohe Konfigurierbarkeit ermöglicht zudem die Anpassung an neue
Dokumenttypen.
Im Rahmen zahlreicher Erweiterungen wurde dieser Algorithmus konsequent weiterentwickelt und mittlerweile an die meisten gängigen Dokumenttypen der UML
angepasst. Es stellt sich nun die Frage, inwieweit diese effiziente Umsetzung eines
Algorithmus zum Vergleich graphartiger Dokumentstrukturen auch in anderen Anwendungsgebieten zum Einsatz kommen könnte. Ein mögliches Anwendungsfeld
liegt dabei im Bereich der Bioinformatik.
1
1.2 Aufbau der Ausarbeitung
Die Bioinformatik, als Anwendungsdisziplin zur computergestützten Bearbeitung
von Problemstellungen aus den Bereichen von Biologie und Chemie, beschäftigt sich
unter anderem mit dem medizinischen Teilbereich des Wirkstoffentwurfs. Eine aus
diesem Bereich stammende Aufgabenstellung ist der Vergleich eines WirkstoffMoleküls mit einer Datenbank, in der bereits bekannte Molekülstrukturen abgelegt
wurden, um möglichst ähnliche Strukturen zu ermitteln. Ein Verfahren, das neben
den rein strukturellen Vergleichen auch die Eigenschaften von Atom-Gruppierungen
miteinbezieht, ist das der Feature Trees. Dabei werden in einem molekularen Graphen aus Atomknoten und Bindungskanten zunächst die funktionellen Gruppen markiert, bevor im Anschluss der angereicherte Graph mit der Datenbank verglichen
wird.
Die vorliegende Arbeit beschäftigt sich mit der Fragestellung, inwieweit der SiDiff-Algorithmus geeignet ist, um molekulare Graphen strukturell miteinander zu
vergleichen.
In Kapitel 2 wird das Anwendungsgebiet im Bereich der Bioinformatik genauer untersucht. Darin werden zunächst Art und Beschaffenheit molekularer Graphen erläutert und gängige Dateiformate mit dem in ihnen enthaltenen Informationsgehalt diskutiert. Das Verfahren der Gruppenmarkierung mithilfe von Feature Trees wird vorgestellt und es wird gezeigt, inwieweit dieses Verfahren im Rahmen von SiDiff eingesetzt werden kann, um den Vergleichsprozess zu unterstützen.
Eine genaue Beschreibung der Funktionsweise des SiDiff-Algorithmus erfolgt in
Kapitel 3 . Die Entwicklung des Algorithmus, der Vergleichsablauf sowie die Konfigurierbarkeit werden dabei ebenso behandelt wie die sich ergebenden Anpassungserfordernisse, die vorzunehmen sind, um molekulare Graphen effizient miteinander
vergleichen zu können.
Kapitel 4 beschäftigt sich mit dem Markierungsprozess der funktionellen Gruppen
in den zu verwendenden Molekülstrukturen. Der gewählte Algorithmus zur Gruppenidentifizierung wird vorgestellt und gegen andere gängige Verfahren abgegrenzt. Die
im Rahmen dieser Arbeit zu verwendenden Muster funktioneller Gruppen werden
aufgezeigt und das neue Datenformat zur Speicherung der Moleküle, in dem die
Gruppenmarkierungen enthalten sind, wird definiert.
Auf den eigentlichen Vergleich der Moleküle wird in Kapitel 5 eingegangen. Zunächst wird die Abbildung der Molekülelemente auf die Struktur des internen SiDiffGraphen definiert, der für die Vergleiche verwendet wird. Dazu werden die anzupassenden Konfigurationsskripte ermittelt und deren Struktur und Bedeutung aufgezeigt.
Die erforderliche Integration der Komponente zur Markierung der funktionellen
Gruppen wird abschließend behandelt.
2
Kapitel 6 befasst sich mit den eigentlichen Testläufen. Zunächst werden die Testumgebung und die zu verwendenden Testdaten spezifiziert, bevor die Ergebnisse der
einzelnen Testläufe aufgezeigt und evaluiert werden.
Abschließend wird in Kapitel 7 eine kurze Zusammenfassung der ermittelten Ergebnisse geliefert und ein Ausblick auf mögliche Erweiterungen gegeben.
3
2 Molekulare Graphen
2.1 Einordnung Wirkstoffentwurf
Die Bioinformatik stellt eine Anwendungsdisziplin dar, in der es um die computergestürzte Bearbeitung von Fragestellungen aus den Bereichen Biologie und Chemie
geht. Eine genauere Definition liefert ([Hüt06], S.3):
„Bioinformatik ist die Entwicklung und das Betreiben von Datenbanken, Software
und mathematischen Werkzeugen zur Analyse, Organisation und Interpretation biologischer Daten.“
Eine klare Abgrenzung zu anderen Bereichen, wie beispielsweise der Physik oder
der Medizin, fällt aufgrund des eng miteinander verwobenen Charakters der Naturwissenschaften ausgesprochen schwer. [Kel07] platziert in seiner Einführung zum
Wirkstoffdesign die Bioinformatik zwischen der strukturellen Biologie und der Chemoinformatik, die beide neben vielen anderen Disziplinen wie der Pharmakologie,
der Pharmazie und der Wirtschaftswissenschaften ebenso am Prozess des Wirkstoffentwurfs beteiligt sind wie die Bioinformatik selbst. Im Rahmen der Analyse tritt in
der Bioinformatik häufig die Problematik auf, biologische Strukturen miteinander zu
vergleichen und eine möglichst gute Überdeckung zu erzielen. [Pol07] nennt als Anwendungsgebiete in diesem Zusammenhang das Sequenzalignment von DNA (desoxyribonucleic acid) oder RNA (ribonucleic acid), die Interaktionsuntersuchungen von
Proteinen im Rahmen der Proteomik und den Aufbau phylogenetischer Bäume entsprechend der evolutionären Ähnlichkeit von Organismen, Genen oder Proteinen.
Auch im Prozess des Wirkstoffentwurfs stellt sich die Frage nach der Ähnlichkeit von
Strukturen, in diesem Falle nach der Ähnlichkeit von Molekülstrukturen.
Beim Wirkstoffentwurf geht es darum, einen Wirkstoff zu entwickeln, der eine bestimmte Wirkung im Organismus entfaltet. [Koh07] gliedert den Prozess zu dessen
Erzeugung in die Schritte der Sammlung biologischer Daten, Ermittlung des Targets1,
Identifizierung der Leitstruktur2, Optimierung der Leitstruktur bezüglich Nebenwirkungen oder der Synthese, dem Prozess der prä-klinischen und klinischen Prüfung
und schließlich der Zulassung in den jeweiligen Ländern. Von besonderer Bedeutung
im Rahmen dieser Arbeit sind die Schritte der Identifizierung und der Optimierung
der Leitstruktur. Als Leitstruktur dienen häufig kleine Moleküle, die an das zuvor
identifizierte Target binden können. Beschrieben werden diese Moleküle durch molekulare Graphen, die, je nach Abstraktionsebene, einen unterschiedlichen Informationsgehalt aufweisen. Gerade im Bereich der Lead-Optimierung stellt sich die Frage,
1
2
Das Ziel, an dem die Wirkung entfaltet werden soll
Engl.: Lead; Substanz, die an das identifizierte Target binden kann
4
2.2 Aufbau und Eigenschaften molekularer Graphen
welche Molekülstrukturen der bereits bekannten und in Datenbanken hinterlegten
Moleküle zu einer gefundenen Leitstruktur möglichst ähnlich sind. Ziel ist es ein Molekül zu entdecken, das aufgrund seiner Struktur ebenfalls in der Lage ist, an das Target zu binden und darüber hinaus noch weitere Vorteile mit sich bringt. Beispielsweise könnte ein strukturähnliches Molekül einfacher zu synthetisieren sein oder im
Körper geringere Nebenwirkungen verursachen. Ein wichtiger Schritt in diesem Zusammenhang ist also der Vergleich einer Molekülstruktur mit bereits bekannten Molekülstrukturen, um strukturell Ähnliche zu identifizieren.
2.2
Aufbau und Eigenschaften molekularer
Graphen
Moleküle sind Verbindungen aus zwei oder mehr Atomen (vgl. [Int08]). Jedes Atom
hat einen spezifischen Elementtyp und verfügt entsprechend seiner Elektronenkonfiguration über eine bestimmte Anzahl an Bindungen, die es mit anderen Atomen eingehen kann. Dabei können manche Atome auch Mehrfachbindungen mit anderen
Atomen aufbauen, so dass man, bezogen auf die Bindung, von einer numerischen
Ordnung dieser Bindung sprechen kann. Neben den Verbindungsinformationen verfügen Atome über weitere Eigenschaften wie die Atommasse, zugehörige Energieniveaus und die Elektronegativität3.
Abbildung 2.1 Hierarchie der Repräsentationen (Quelle: [Koh07], Foliensatz „Chemoinformatik“,
S.21), Rechts: Molekülbeispiel für 2D-Strukturdarstellung
3
Elektronegativität beschreibt Fähigkeit der Atome, Bindungselektronen in kovalenten Bindungen
an sich zu ziehen und stellt somit ein Maß für die Bindungsfähigkeit (nach [Blu06])
5
2.2 Aufbau und Eigenschaften molekularer Graphen
Molekulare Graphen können auf unterschiedlichen Abstraktionsebenen betrachtet
werden, wie in Abbildung 2.1 schematisch dargestellt ist. Auf der untersten Ebene
besteht ein Molekül lediglich aus der Summenformel, die angibt, aus welchen Atomen es zusammengesetzt ist (vgl. [Lat08]). Informationen darüber, welche Atome
miteinander verbunden sind, lassen sich häufig nicht eindeutig ableiten. Die nächsthöhere Ebene beinhaltet Informationen darüber, welche Atome miteinander verbunden sind, so dass sich eine zweidimensionale Struktur ergibt. Diese Ebene wird häufig zur Modellierung und zur Verdeutlichung chemischer Reaktionen verwendet. Üblicherweise werden zur Darstellung Atomknoten mit ihrem Elementtyp beschriftet
und Bindungskanten entsprechend ihrer Ordnung durch eine oder mehrere Linien
repräsentiert (vgl. [Koh07]). Durch die Kristallographie kann die räumliche Anordnung von Atomen ermittelt werden, woraus sich Längen und Winkel der Verbindungen berechnen lassen. Als Ergebnis dieser Analyse erhält man das geometrische,
dreidimensionale Modell eines Moleküls als weitere Stufe der Abstraktionshierarchie.
Auf der letzten Stufe werden schließlich Informationen über die Oberflächenstruktur
des Moleküls hinzugefügt. Dabei handelt es sich um Charakteristika bestimmter Regionen, die entscheidend dafür sind, mit welchen Bereichen anderer Moleküle diese
reagieren können. Ähnlich dem Schlüssel-Schloss-Prinzip gibt die Oberflächenstruktur darüber Auskunft, ob und wie zwei Stoffe miteinander in Verbindung treten können, inwieweit sie zusammen „passen“.
Wie in Abbildung 2.1 deutlich wird, werden die betrachteten Strukturen von der
untersten zur obersten Ebene hin zunehmend komplexer, was sich auch im Aufwand
für erforderliche Vergleiche widerspiegelt. Während ein Summenformelvergleich
einem reinen Textvergleich entspricht, sind im dreidimensionalen Raum aufwendige
Rotationen und Translationen erforderlich, um Elemente aufeinander abbilden zu
können. Aus diesem Grund wurden für jede betrachtete Ebene diverse Verfahren
entwickelt, um einen effizienten Vergleich zu ermöglichen. Häufig erfolgt die Suche
nach einer ähnlichen Struktur daher gestaffelt, beginnend auf der untersten Ebene.
Auf jeder Ebene wird die Restmenge der Elemente, die noch als Kandidaten für eine
möglichst hohe Ähnlichkeit in Frage kommen, entsprechend des Informationsgehalts
der Stufe ausgewertet und reduziert. Auf diese Weise kann eine, auf der untersten
Ebene noch sehr große Kandidatenmenge, Stufe für Stufe reduziert werden, bis
schließlich auf der obersten Ebene nur noch wenige Moleküle mit aufwendigen Verfahren verglichen werden müssen.
Hauptgegenstand dieser Arbeit ist der Vergleich molekularer Graphen auf der
zweidimensionalen Ebene, da der SiDiff-Algorithmus für den strukturellen Vergleich
von Graphen ausgelegt ist (vgl. Abbildung 2.1 rechts). Ein Graph G=(V, E) wird
durch eine Atom-Knotenmenge V und eine Bindungs-Kantenmenge E beschrieben.
Die Bindungskanten sind ungerichtet und aufgrund der Bindungseigenschaften der
Atome kann der Graph Zyklen enthalten. Ein weiteres Merkmal molekularer Graphen
ist die Eigenschaft, dass die Atom-Knoten einen beschränkten Grad von nicht mehr
als acht Kanten haben können. Zudem sind bis auf wenige hundert polyzyklische Mo-
6
2.3 Notationen und Dateiformate
lekülstrukturen alle Graphen planar und somit kreuzungsfrei darstellbar (vgl.
[Koh07]).
Insgesamt existieren mehrere Dutzend mögliche Notationsarten und Datenformate zur
Repräsentation molekularer Informationen. Gerade im Bereich zur zwei- und dreidimensionalen Modellierung haben sich jedoch einige wenige Standards herausgebildet, auf die im Folgenden genauer eingegangen wird.
Eines der gebräuchlichsten Formate zur zweidimensionalen Repräsentation stellt
die SMILES-Notation (Simplified Molecular Input Line Specification) dar. Diese
Notation beinhaltet Informationen über die enthaltenen Elemente, die Bindungen
zwischen den Elementen, Ringsysteme, Chiralität4 und Ladungen. Es handelt sich
dabei um eine Zeilennotation, bei der Atome mit dem Großbuchstaben für ihr Element dargestellt werden. Einfachbindungen sowie Wasserstoffatome werden implizit
angenommen, Doppel- und Dreifachbindungen werden mit den Symbolen „=“ und
„#“ dargestellt. Verzweigungen innerhalb der Struktur werden anhand der Klammerung deutlich gemacht. Atome, die in einem Ring angeordnet sind (aromatisch), werden mit einem kleinen Buchstaben notiert und der Ringschluss mit Ziffern vermerkt.
Es existieren weitere Symbole für zusätzliche Informationen. Die wesentlichen Vorteile dieses Verfahrens liegen in der kompakten Notation und der wohldefinierten
Grammatik, die beide eine einfache Lesbarkeit der Ausdrücke ermöglichen. Als problematisch hervorzuheben ist, dass mehrere SMILES für dieselbe Struktur existieren
können, sowie die beschränkten Darstellungsmöglichkeiten von im Wirkstoffentwurf
sehr häufig auftretenden Aromatizität-Ringstrukturen. Erstgenannte Problematik wird
mit einer Erweiterung des SMILES-Standards, den sogenannten USMILES (Unique
SMILES), adressiert.
Als eine alternative Zeilennotation zu SMILES kommt SLN (Sybyl Line Notation)
zum Einsatz. Im Gegensatz zu SMILES werden Wasserstoffatome hier explizit angegeben. Verbindungen in Ringstrukturen erhalten einen Index in eckigen Klammern an
der Startposition und ein „@“-Symbol als Ringschlusssymbol. Zum Ausdruck der
Aromatizität wird bei dieser Notation ein Vermerk bei den Bindungen (mithilfe eines
„:“-Symbols), und nicht, wie bei SMILES, bei Atomen und Bindungen angelegt. Abbildung 2.2 zeigt exemplarisch den Einsatz beider Notationen zur Darstellung einer
aromatischen Ringstruktur.
4
Die Chiralität, oder auch Enantiomorphie (in der Kristallographie) bezeichnet die räumliche
Anordnung von Atomgruppierungen derart, dass diese durch Drehung nicht zur Deckung gebracht werden können (vgl. [Lat08, Kapitel 1 ])
7
Abbildung 2.2 Beispiele für SLN und SMILES für einen aromatischen Ring (Quelle Notation: [Koh07],
Foliensatz „Chemoinformatik“, S.48)
Beide Verfahren haben die Eigenschaft, dass mit ihnen Informationen über den topologischen Aufbau und Inhalt der Moleküle notiert werden können, ohne dabei
Koordinaten zu verwenden. Gerade bei großen Molekülen mit komplexen Ringsystemen wird die Zeilennotation aufgrund der umfangreichen Klammerung jedoch
schnell unübersichtlich. Zudem sind häufig dreidimensionale Koordinaten für eine
präzisere Beschreibung der Molekülstruktur erforderlich. Im Folgenden werden daher
drei gängige Dateiformate im Bereich der dreidimensionalen Modellierung hervorgehoben.
Als Standard zur dreidimensionalen Notation gilt das von MDL (Molecular Design
Limited) entwickelte MOL-Format (Molecule) für einzelne Strukturen. Eine MOLDatei besteht aus fünf Blöcken und verwendet ein spaltenbasiertes Speicherformat je
Block. Der erste Block entspricht einem Header mit generellen Daten zum verwendeten Programm, Erstellungsdatum, Molekülnamen und weiteren internen Informationen. Im zweiten Block wird die Anzahl der Atome und Bindungen aufgeführt, die
Anzahl zusätzlicher Eigenschaften-Zeilen am Ende der Datei sowie die NotationsVersionsnummer. Im dritten Block werden nun zunächst die Atome spezifiziert. Beginnend mit den X-, Y- und Z-Koordinaten folgen der Elementtyp sowie Informationen über die Ladung. Die eigentliche Struktur ergibt sich mithilfe der im darauffolgenden Block festgehaltenen Bindungsinformationen. In den ersten beiden Spalten
werden die Nummern der verbundenen Atome angegeben, gefolgt von der Ordnung
der Bindung. Mit Hilfe von Atom- und Bindungstabelle lässt sich die dreidimensionale Struktur eines Moleküls herleiten. Im letzten Block werden schließlich zusätzliche
Eigenschaften sowie das Ende der MOL-Datei deklariert. Neben den genannten Informationen können noch viele weitere Daten, beispielsweise aus dem Bereich der
Stereochemie, in MOL-Dateien gespeichert werden. In Abbildung 2.3 wird beispielhaft die MOL-Datei einer kleinen molekularen Struktur dargestellt.
8
Abbildung 2.3 Beispiel einer MOL-Datei (Quelle: [Koh07], Foliensatz „Chemoinformatik“, S.51)
Ein weiteres weit verbreitetes Format ist das PDB-Format (Protein Data Bank).
Die Protein Data Bank stellt eine der großen im Web frei zugänglichen Datenbanken
dar und beinhaltete nach eigenen Angaben im April 2008 bereits 50.000 Strukturen
(vgl. [Pro08]). Auch dieses Format verwendet eine Spaltennotation mit Atom- und
Bindungstabellen. Für jedes Atom werden die dreidimensionalen Koordinaten festgehalten und es kann vermerkt werden, ob ein Atom ein Heteroatom ist, was in diesem
Zusammenhang bedeutet, dass es Teil eines kleinen molekularen Kofaktors ist (vgl.
[Ato08]). Verwendung findet dieses Format im Unterschied zu MOL aber hauptsächlich bei der Codierung von Proteinen und nicht von kleinen Molekülen.
Das CML-Format (Chemical Markup Language) stellt schließlich das dritte hier
vorstellte Format dar. Dabei handelt es sich um eine auf XML (eXtensible Markup
Language) basierende Notation zur Repräsentation chemischer Informationen mithilfe von Tags. Als Wurzel des Dokuments befindet sich auf der obersten Ebene ein
molecule-Element, dem eine Identifikationsnummer sowie der Name des Moleküls
als Attribute beigefügt werden können. Weitere Eigenschaften können in Form zusätzlicher Tags innerhalb des molecule-Elements angegeben werden. Die beiden wesentlichen Elemente innerhalb des molecule-Tags sind das AtomArray-Element zur
Deklaration von Atominformationen sowie das BondArray-Element als Container für
Bindungsstrukturinformationen. Damit stimmt der Aufbau prinzipiell mit den zuvor
beschriebenen Formaten derart überein, dass alle drei Verfahren zunächst die Atome
und anschließend die Bindungen beschreiben. Atom-Elemente innerhalb des AtomArrays können über eine ganze Reihe von Attributen verfügen, darunter eine eindeutige
ID, der Elementtyp sowie die X-, Y- und Z-Koordinaten. Die Bond-Elemente im
Rahmen des BondArray verfügen über ein Attribut atomRefs2, welches als Wert die
IDs der verbundenen Atome enthält. Neben weiteren möglichen Attributen verfügen
Bindungen noch über den Grad der Bindung sowie eine dokumentweit eindeutige ID
(nach [CML03]). Abbildung 2.4 zeigt zur Verdeutlichung des strukturellen Aufbaus
die CML-Datei eines einfachen Moleküls. Hauptvorteile der CML liegen vor allem in
der klaren Struktur, die validierbar ist und für die Parser mit wenig Aufwand geschrieben werden können. Obwohl noch nicht sehr weit verbreitet, ist dieses Format
9
2.4 Feature Trees
als Standard etabliert und verfügt über eine umfangreiche Spezifikation. Negativ
macht sich der Speicherplatzbedarf bemerkbar, der aufgrund der umfangreichen TagStruktur die anderen Formate übertrifft.
Abbildung 2.4 Beispiel CML-Datei aus Testdatenbestand
Bei der Vielzahl vorhandener Notationen und Formate stellt sich die Frage, inwieweit zwischen den unterschiedlichen Repräsentationen konvertiert werden kann.
Tatsächlich existieren sehr viele mittlerweile veraltete Formate, sowie unvollständige
und zum Teil fehlerhafte Daten (vgl. [Koh07]), so dass entsprechende Filterimplementierungen sehr aufwendig sind. Häufig werden daher von kommerziellen Programmpaketen Schnittstellen angeboten, um bearbeitete Strukturen in einer Vielzahl
von Formaten zu speichern und zu exportieren. Im Open Source-Bereich existiert das
Programm „Open Babel: The Open Source Chemistry Toolbox“, das laufend weiterentwickelt wird und mittlerweile mit etwa 90 unterstützten chemischen Formaten
genutzt werden kann, um zwischen den unterschiedlichen Darstellungen zu wechseln
(siehe [Ope08]). Alle der zuvor vorgestellten Formate können mit diesem Tool ineinander überführt werden, was es ermöglicht, die im Rahmen dieser Arbeit vorzunehmenden Anpassungen am SiDiff-Algorithmus basierend auf nur einem Format durchzuführen. Aufgrund der bei der Entwicklung von SiDiff bisherigen Ausrichtung auf
XMI-Dokumente (vgl. Kapitel 3 ) sowie der aufgezeigten Vorteile der CML, eignet
sich dieses auf XML basierende Format in besonderem Maße als Grundlage zur Speicherung der zu vergleichenden molekularen Graphen.
2.4 Feature Trees
Aus dem Bereich des strukturellen Vergleichs zweier Moleküle stammt ein Verfahren, das mithilfe speziell angereicherter Molekülgraphen, sogenannter Feature Trees,
versucht, eine möglichst gute Überdeckung zu erzielen. Auch wenn die verwendeten
Algorithmen zum eigentlichen Vergleich der erzeugten Bäume grundsätzlich anders
arbeiten als der SiDiff-Algorithmus, so besitzen die Schritte zur Anreicherung der
10
2.4 Feature Trees
Graphen doch eine gewisse Relevanz im Rahmen dieser Arbeit. Aus diesem Grund
wird im folgenden Kapitel das Verfahren der Feature Trees kurz erläutert und es
werden die Bereiche aufgezeigt, die für die Anpassung des SiDiff-Algorithmus relevant sind.
Der Grundgedanke beim Feature Tree Verfahren ist der, in einem molekularen
Graphen Gruppierungen von Atomen und Bindungen mit bestimmten Eigenschaften
zu identifizieren und so auf einen neuen Knoten zu reduzieren, dass der entstehende
Graph ein Baum ist (siehe Abbildung 2.5). Jedes Atom des Graphen ist in mindestens
einem Knoten des Feature Trees enthalten. Sind zwei Atome benachbart, oder ist ein
Atom Teil zweier Knoten des Feature Trees, so werden die beiden Knoten mit einer
Kante verbunden, wodurch die Topologie des ursprünglichen Graphen erhalten bleibt.
Einfache Zyklen im molekularen Graphen werden ebenfalls auf einen Knoten abgebildet. Polyzyklische Strukturen können bis zu einem gewissen Grad auf eine sternartige Knotenstruktur reduziert werden.
Abbildung 2.5 Beispiel zur Erzeugung eines Feature Tree durch Reduktion der mit Kreisen markierten
Atomgruppierungen auf einen neuen Knoten des Feature Tree (Quelle: [Rar98], S.471)
Im Anschluss an die strukturelle Erzeugung des Baums erfolgt die Zuweisung der
Eigenschaften, unterschieden nach sterischen und chemischen Features. Sterische
Eigenschaften beschreiben das Fragment in Bezug auf seine Größe, wofür häufig die
11
2.4 Feature Trees
Anzahl der Atome und das Van-der-Waals-Volumen5 verwendet werden. Chemische
Eigenschaften definieren eine Art Wechselwirkungsprofil mit anderen Substanzen,
beispielsweise die Hydrophobizität6. Für jedes Feature werden drei Funktionen definiert. Die erste, die Generatorfunktion, berechnet den Wert der Eigenschaft für ein
gegebenes Fragment. Die Komparatorfunktion liefert für ein Paar von Eigenschaftswerten einen Ähnlichkeitswert im Bereich [0..1], mit Eins für identisch und Null für
keine Ähnlichkeit. Die Kombinationsfunktion schließlich bildet zwei Eigenschaftswerte auf einen einzelnen ab, der konsistent sein muss mit dem Wert, den die Generatorfunktion für die Vereinigung der beiden Fragmente berechnet hätte. Im Anschluss
an diese Anreicherung des Graphen findet der eigentliche Vergleichsvorgang über ein
sogenanntes Matching statt, bei dem versucht wird, Teilbäume von Feature Tree A
auf Teilbäume von B abzubilden. Ein solches Matching ist gültig, wenn die Abbildung Topologie erhaltend ist und jeder Knoten höchstens in einem Match auftritt
(vgl. [Koh07]). Über weitere Nebenbedingungen lässt sich die Qualität des Matchings
beeinflussen. Hierzu zählen das Gewichtungsverhältnis zwischen sterischen und
chemischen Eigenschaften sowie die maximale Größe der zu matchenden Teilbäume.
Zum eigentlichen Vergleich der Feature Trees werden drei Algorithmen verwendet:
Split Search, Match Search und Split Search mit 1-Shifts, die alle über eine vergleichbare Leistungsfähigkeit verfügen. Grundgedanke der Verfahren ist der, durch Schnitte
in beiden Bäumen Teilbäume zu erzeugen, die dann aufeinander abgebildet werden
können. Als abschließende Betrachtung lässt sich festhalten, dass Feature Trees im
Bereich des topologischen Vergleichs sehr effizient sind. In ihrer Leistungsfähigkeit
lassen sie sich zwischen Fingerprints7 und echten geometrischen 3DStrukturvergleichen einordnen. Kritisch zu sehen ist die Eigenschaft, dass große makrozyklische Systeme mit Feature Trees nicht bearbeitet werden können.
Wie sich im folgenden Kapitel zeigen wird, sind bisherige von SiDiff unterstützte
Dokumenttypen dadurch gekennzeichnet, dass die zu vergleichenden Elemente eine
Vielzahl von Eigenschaften besitzen, die für die Berechnung eines Ähnlichkeitswertes herangezogen werden können. Ein reiner molekularer Graph verfügt im Gegensatz
dazu über viele Elemente, die relativ wenige Eigenschaften besitzen und zudem, jeweils paarweise betrachtet, sehr ähnlich sein können. Als Beispiel können hier Kohlen- oder Wasserstoff-Atome genannt werden, die sehr häufig auftreten, sich im
Hinblick auf ihre Eigenschaften jedoch, wenn überhaupt, kaum unterscheiden. Aus
diesem Grund erscheint eine Anreicherung des molekularen Graphen mit zusätzlichen
Eigenschaften von Vorteil. Im Folgenden wird daher das Verfahren aus dem Bereich
der Feature Trees verwendet, um in einem molekularen Graphen bestimmte Atom5
Das Volumen, das ein Atom (oder eine Atomgruppierung) basierend auf seinem Van-der-WaalsRadius (Radius, in den sich kein anderes Atom annähern kann) besitzt (vgl. [Mol96])
6
Definiert, ob eine Atomgruppierung wasserlöslich (hydrophil) oder wasserunlöslich (hydrophob)
ist (vgl. [Wie04])
7
Verfahren, bei dem das Vorhandensein bestimmter Eigenschaften oder Molekülfragmente auf die
Bitpositionen eines Bitvektor abgebildet wird (vgl. [Koh07], Foliensatz „2D-Ähnlichkeit“)
12
2.4 Feature Trees
gruppierungen zu markieren. Dabei steht jedoch nicht die Eliminierung von Zyklen
im Vordergrund, die vom SiDiff-Algorithmus ohnehin bearbeitet werden können,
sondern die Markierung von sogenannten funktionellen Gruppen (siehe Abbildung
4.1). Dabei handelt es sich um in der organischen Chemie häufig vorkommende Verbindungen aus zwei oder mehr Atomen, deren chemische Eigenschaften wohlbekannt
sind. Von großer Bedeutung sind funktionelle Gruppen, wenn es darum geht, die
Wechselwirkungsmöglichkeiten zweier Moleküle zu untersuchen. Beim Einsatz des
SiDiff-Algorithmus können sie zudem verwendet werden, um die zu vergleichenden
Moleküle mit zusätzlichen Eigenschaften zu versehen und somit die Genauigkeit bei
der Ähnlichkeitsbestimmung zu erhöhen (vgl. Kapitel 3 ). Auf den Prozess der Gruppenmarkierung sowie die zu markierenden funktionellen Gruppen wird ausführlich in
Kapitel 4 eingegangen.
13
3 Differenzberechnung mit
SiDiff
Der SiDiff-Algorithmus wurde 2004 im Rahmen einer Diplomarbeit an der Fachgruppe der Praktischen Informatik mit dem Ziel entwickelt, zwei Versionen eines
UML-Dokuments miteinander zu vergleichen und die Gemeinsamkeiten und Unterschiede zu ermitteln (vgl. [Weh04]). Bis zu diesem Zeitpunkt konnte beim Vergleich
zweier Dokumente innerhalb einer Dokumenthistorie eine Zuordnung der korrespondierenden Elemente lediglich anhand ihrer IDs vorgenommen werden. Gerade im
Hinblick auf in der Praxis häufig genutztes Reverse-Engineering, bei dem die IDs der
ursprünglichen Modellelemente nicht mehr vorhanden sind, war dieses Vorgehen
nicht mehr zeitgemäß. Die ursprüngliche Version von SiDiff adressierte diese Problematik, indem für den Vergleich von Modellelementen Ähnlichkeitsmetriken zum
Einsatz kamen, die Elemente aufgrund ihrer Eigenschaften und Attribute vergleichen
und zuordnen konnten. Dazu werden die existierenden Elemente eines Dokumenttyps
mit ihren Eigenschaften zunächst spezifiziert und anschließend mit Gewichtungen
und Schwellwerten versehen.
Während in der ursprünglichen Version zunächst Klassen- und Zustandsdiagramme unterstützt wurden, erfolgte im Rahmen einer weiteren Diplomarbeit eine Anpassung an Anwendungsfall-, Aktivitäts-, Sequenz- und Kommunikationsdiagramme,
sowie eine Verfeinerung der zuvor bereits unterstützten beiden Diagrammtypen (siehe [Gad07]). Parallel dazu wurde der Algorithmus intern weiterentwickelt und optimiert, beispielsweise in der Vergleichsphase durch den Einsatz einer multidimensionalen Suchbaumstruktur zur Reduktion der Anzahl benötigter Elementvergleiche
(vgl. [Tre07]). Bei der Entwicklung standen zwei Aspekte stets im Vordergrund: der
Algorithmus sollte zum einen hoch konfigurierbar, zum anderen möglichst einfach an
neue Dokumenttypen anzupassen sein. In diesem Kapitel wird zunächst die Funktionsweise des SiDiff-Algorithmus erläutert und aufgezeigt, welche Konfigurationsschritte zur Unterstützung des neuen Dokumenttyps erforderlich sind.
3.1 Der SiDiff-Algorithmus
Der grundsätzliche Ablauf beim Vergleichsvorgang ist unabhängig vom untersuchten
Dokumenttyp und wird daher zunächst allgemein betrachtet. [Kel05] liefert eine ausführliche Beschreibung und wird, sofern nicht anders vermerkt, als Hauptquelle verwendet.
In einem ersten Schritt werden die Eingabedokumente eingelesen und die enthaltenen Elemente in das interne Datenmodell überführt. Wie die Dokumentelemente
dabei auf die Datenmodellelemente abzubilden sind, wird durch ein Mapping in einer
14
für den jeweiligen Dokumenttyp spezifischen Konfigurationsdatei definiert. Wurde
der interne SiDiff-Graph aufgebaut, erfolgen Vergleich und Auswertung in zwei Phasen.
Abbildung 3.1 Datenmodell des SiDiff-Vergleichsalgorithmus (Quelle: [Kel05], S.5)
Zunächst werden im Schritt der Korrespondenzerkennung8 Elemente in Dokument
A und B ermittelt, die einander entsprechen. Für diese Zuordnung sind keine eindeutigen Identifizierer erforderlich, sondern es werden vielmehr die Eigenschaften der
Elemente für den Vergleich herangezogen. Für je zwei Elemente wird dazu ein Ähnlichkeitswert über die Attribute der Elemente und deren Umgebung, also Referenzen
und Hierarchiebeziehungen, gebildet. Welche Ähnlichkeitsmerkmale dazu herangezogen werden sollen, wie diese zu gewichten und welche Schwellwerte zu überschreiten sind, erfolgt auf Basis einer weiteren dokumenttypspezifischen Konfigurationsdatei (vgl. [Kel071])). Liegt der ermittelte Ähnlichkeitswert über dem definierten
Schwellwert kommen die Elemente als Kandidaten in Frage. Dieser Prozess der Ähnlichkeitswertermittlung erfolgt in zwei Richtungen: Bottom-up und Top-down (vgl.
Abbildung 3.2). In der ersten Phase wird Bottom-up von den Blattknoten hin zur
Wurzel des Graphen jedes Element mit den in Frage kommenden Elementen aus dem
anderen Graphen verglichen und es werden die Ähnlichkeitswerte bestimmt. Ergibt
dieser Vergleich für zwei Elemente in beiden Richtungen einen Ähnlichkeitswert, der
höher ist als für jedes andere verglichene Elementpaar, so werden diese Elemente als
Korrespondenzen erkannt und als einander entsprechend zugeordnet. In diesem Fall
schaltet der Algorithmus in das Top-down Verfahren, indem die zuvor erkannte Korrespondenz an die Kindelemente propagiert wird, woraufhin deren Ähnlichkeitswerte
8
Als Korrespondenz bezeichnet man ein Paar von Komponenten aus zwei Dokumenten, die inhaltlich gleich sind und einander entsprechen (nach [Kel071])
15
basierend auf den neuen Erkenntnissen erneut berechnet werden. Stellt sich auch hier
zwischen zwei Elementen ein einzigartiger Ähnlichkeitswert heraus, so werden auch
diese einander zugeordnet und das Verfahren läuft Top-down weiter. Der Algorithmus stoppt, sobald alle Elemente Bottom-up verglichen wurden. Um auch in zyklischen Strukturen und in Strukturen, die durch eine hohe Anzahl von Abhängigkeitsbeziehungen gekennzeichnet sind, möglichst alle Korrespondenzen zu entdecken,
läuft der gesamte Algorithmus mehrere Male Bottom-up über den Graphen, was sich
in der Praxis als ausreichend herausgestellt hat.
Abbildung 3.2 Schematischer Ablauf der Matching-Phase (Quelle: [Weh04])
Im Anschluss an die Korrespondenzbildung folgt die Differenzermittlung und
Ausgabe. In dieser Phase werden die Elemente entsprechend ihrer Differenzen in eine
von vier Kategorien eingeteilt. Als Struktur-Differenzen werden Elemente klassifiziert, zu denen keine Korrespondenz gefunden werden konnte. Dazu zählen Elemente, die zu keinem anderen Element eine Ähnlichkeit über dem spezifizierten
Schwellwert erreicht haben, sowie Elemente, für die mehrere Kandidaten mit einem
identischen Ähnlichkeitswert existieren, so dass keine eindeutige Entscheidung getroffen werden kann, welchem es zugeordnet werden soll. Die Klasse der AttributDifferenzen beinhaltet Korrespondenzen, bei denen sich ein oder mehrere Attributwerte geändert haben. Referenz-Differenzen beziehen sich auf Veränderungen bei
referenzierten Elementen einer Korrespondenz. Die letzte Kategorie, die Klasse der
Verschiebungs-Differenzen, umfasst alle Elemente, bei denen sich das ElternElement verändert hat. Geordnet nach diesen Kategorien enthält die Ausgabe alle
Elemente aus beiden Dokumenten.
Um den Vorgang der Korrespondenzerkennung zu optimieren, existieren in der aktuellen SiDiff-Version zwei Verfahren. Das eine Verfahren berechnet in einem vorgelagerten Schritt den Hashwert der enthaltenen Elemente, welcher aus dem Hashwert
16
3.2 Konfigurierbarkeit
des Pfades zu dem jeweiligen Element, den Hashwerten der Namen der Unterelemente sowie den Hashwerten der Pfade von referenzierten Elementen gebildet wird. Über
einen Vergleich der Hashwerte lassen sich Korrespondenzen ohne oder mit nur geringen Unterschieden dann schnell erkennen. Kritisch zu diesem Verfahren ist anzumerken, dass aufgrund der Einbeziehung der Pfadangaben sowohl des Elements selbst,
als auch der referenzierten Elemente, Verschiebungen nicht erkannt werden können.
Das zweite Verfahren verwendet eine mehrdimensionale Suchstruktur, den S³VBaum, in dem ähnliche Elemente zunächst benachbart angeordnet werden. Anstatt
nun jedes Element mit jedem anderen möglichen Kandidaten zu vergleichen, wird der
Vergleich nur noch mit im Baum benachbarten Elementen vorgenommen (vgl.
[Tre07]). Kritisch bei diesem Verfahren ist, geeignete Merkmale für die Organisation
des S³V-Baums sowie eine geeignete Anzahl von zu untersuchenden Nachbarelementen zu wählen.
Als Dokumentformat für bisher unterstützte UML-Diagrammtypen kommt XMI
(XML Metadata Interchange) zum Einsatz. Es ist in besonderer Weise zur Speicherung von Diagrammen geeignet, da sich Eingabedokumente toolspezifisch mit zusätzlichen Eigenschaften anreichern lassen und Referenzen zwischen Modellelementen
über idref-Attribute umgesetzt werden können (vgl. [Kel05]). Diese Eigenschaften
sorgen dafür, dass XMI nicht nur für UML-Diagramme geeignet ist, sondern auch für
andere Arten von strukturierten, diagrammähnlichen Dokumenten. Das Datenmodell
des internen SiDiff-Graphen ist aus diesem Grunde so gestaltet, dass auch XMI Dateien verglichen werden können, die keine UML-Diagramme darstellen (vgl. Abbildung 3.1). Gerade diese Eigenschaft macht es möglich, den SiDiff-Algorithmus auch
für den Vergleich jeglicher anderer graphartiger Strukturen einzusetzen, was den
Vergleich von molekularen Graphen erst ermöglicht.
Zur Unterstützung des neuen Dokumenttyps sind mehrere Konfigurationsskripte
erforderlich, mit denen über eine Reihe von Parametern und Funktionen der Vergleichsvorgang gesteuert wird. Diese Konfigurationsdateien werden im Folgenden
kurz beschrieben, um die komplexen Möglichkeiten zur Konfigurierung des Algorithmus deutlich zu machen und die abschließenden Überlegungen zu benötigten Anpassungserfordernissen zur Unterstützung des neuen Dokumenttyps einzuleiten.
Bei der Anpassung zur Unterstützung eines neuen Dokumenttyps kann an nahezu
jeder Stelle des Vergleichsvorgangs über eine Konfigurationsdatei steuernd auf den
Ablauf Einfluss genommen werden. Sämtliche verwendeten Konfigurationsdateien
basieren auf XML, was Erzeugung, Bearbeitung sowie Validierung erheblich erleichtert. Im Folgenden werden die Schlüsselstellen im Vergleichsablauf mit den zugehörigen Konfigurationsdateien genauer betrachtet.
17
Im ersten Schritt ist zu überlegen, wie die Elemente des zu vergleichenden Dokumenttyps auf das interne SiDiff-Datenmodell abgebildet werden können. Da bisher
unterstützte Dokumenttypen im XMI-Format vorlagen und somit auf XML basierten,
konnte diese Abbildung mit Hilfe eines XSL Stylesheet (Extensible Stylesheet Language) vorgenommen werden. Auf diese Weise können eingelesene Eingabeelemente
einfach mit xsl-Befehlen in die entsprechenden Datenmodell-Elemente transformiert
werden. Dieser Schritt ist von entscheidender Bedeutung, da je nach Art der Abbildung der Vergleichsvorgang mehr oder weniger effizient arbeiten kann, im schlimmsten Falle sogar überhaupt keine brauchbaren Resultate liefert. Es ist also auf eine
Abbildung zu achten, die einfach genug strukturiert ist, um effizient durchlaufen werden zu können, aber auch komplex genug, um später aussagekräftige Ähnlichkeitsmerkmale zu entdecken.
Wurden das Datenmodell erzeugt und die Eingabedokumente eingelesen, können
anschließend die zu vergleichenden Elemente genauer spezifiziert werden. Diese
Spezifikation der sogenannten Candidates erfolgt in einer weiteren Konfigurationsdatei. Für jeden Elementtyp können darin Regeln definiert werden, die zutreffen müssen, damit ein Element des Typs aus dem einen Dokument überhaupt mit einem anderen Element des zweiten Dokuments verglichen wird. Somit lässt sich bereits vor
Beginn des eigentlichen Vergleichsvorgangs die Menge der zu vergleichenden Elemente entscheidend einschränken, was gerade bei einer großen Anzahl an Elementen
einen wesentlichen Einfluss auf die Laufzeit des Algorithmus haben kann.
Im Anschluss an die Kandidateneinschränkung startet der eigentliche Prozess der
Korrespondenzerkennung. In der sogenannten MatchingConfig-Konfigurationsdatei
wird zunächst die Implementierung des iterativen Matchers gewählt, welcher derzeit
der standardmäßige DefaultMatcher ist. Für diesen ist es erforderlich, die Reihenfolge zu spezifizieren, in der die Dokumentelementtypen zu betrachten sind. Neben dieser Beschreibung des iterativen Zuordnungs-Ablaufs müssen für jeden Elementtyp
noch weitere Parameter definiert werden, die angeben, welche Nebenbedingungen
erfüllt sein müssen, um zwei Elemente des Typs einander zuzuordnen. So kann mit
der Option parentForceMatch beispielsweise angegeben werden, ob für ein Zuordnung bereits die Elternelemente der betrachteten Elemente zugeordnet sein müssen.
Wesentlicher Kern der Ähnlichkeitswertberechnung ist die CompareConfigKonfigurationsdatei, in der für jeden Elementtyp spezifiziert wird, wie der Ähnlichkeitswert zu berechnen ist und welche Schwellwerte überschritten werden müssen.
Für jeden Knotentyp kann eine Reihe von Vergleichsfunktionen definiert werden.
Diese Funktionen können Elternknoten, Attribute, Kindknoten oder auch referenzierte Knotenmengen vergleichen. Als Resultat liefern sie einen Ähnlichkeitswert zwischen Null und Eins, wobei Null absolut keine Ähnlichkeit und Eins völlige Identität
darstellen. Für jede dieser Funktionen kann eine Gewichtung ebenfalls im Wertebereich [0..1] angegeben werden, die prozentual angibt, inwieweit das Ergebnis der
Funktionsauswertung in den Gesamtwert des Elements einfließen soll. Auf Elementtypebene wird ein Schwellwert definiert, der mindestens erreicht werden muss, damit
18
3.3 Anpassungserfordernisse
zwei Elemente als Korrespondenzen in Frage kommen (vgl. [Ben08]). Liegt nach
Auswertung der Funktionen und der Multiplikation mit den Gewichtungsfaktoren der
ermittelte Ähnlichkeitswert für ein Paar von Elementen über diesem definierten
Schwellwert, so kommen die beiden Elemente als Korrespondenz in Frage. Wird für
kein anderes Paar von Elementen, in denen eines der beiden Elemente enthalten ist,
ein gleicher oder höherer Ähnlichkeitswert ermittelt, so werden die beiden Elemente
als Korrespondenz markiert.
Neben den hier vorgestellten Konfigurationsdateien besteht noch die Möglichkeit,
den internen SiDiff-Graphen vor Beginn des Vergleichsvorgangs mit zusätzlichen
Informationen anzureichern. Diese Anreicherung konnte zum Zeitpunkt dieser Arbeit
jedoch noch nicht über eine externe Datei konfiguriert werden, weshalb diese zukünftig vorhandene Funktionalität hier nicht genauer betrachtet werden kann.
Nachdem nun sowohl die Grundlagen über den Aufbau und die Eigenschaften molekularer Graphen als auch über die Funktionsweise und Konfigurationsmöglichkeiten
des SiDiff-Algorithmus herausgearbeitet wurden, können im Folgenden die erforderlichen Anpassungen untersucht und spezifiziert werden.
Zu den standardmäßigen Anpassungen gehört die Erstellung der erforderlichen
Konfigurationsskripte. Zunächst muss eine Abbildung der Elemente aus molekularen
Graphen auf entsprechende Strukturen des internen SiDiff-Datenmodells erarbeitet
werden. Wurde diese Abbildung festgelegt, kann ein Skript erstellt werden, welches
die molekularen Eingabedokumente in den internen SiDiff-Graphen transformiert. Da
mit der CML ein Datenformat zur Speicherung molekularer Graphen auf Basis von
XML vorliegt, kann diese Transformation analog zu bisherigen Dokumenttypen mit
Hilfe von XSL-Stylesheets erfolgen. Zur Einschränkung der Kandidatenvergleichsmenge können bestimmte Attribute der Elemente in molekularen Graphen ausgenutzt
werden, wie beispielsweise der Elementtyp der Atome, was eine Erstellung der CandidatesConfig-Konfigurationsdatei sinnvoll erscheinen lässt. Für den Ablauf des Vergleichsvorgangs und die Ähnlichkeitswertberechnung sind die MatchingConfig- und
CompareConfig-Dateien, basierend auf den gewählten Strukturen des Datenmodells,
anzulegen. Im Hinblick auf die Eigenschaft molekularer Graphen, viele Elemente mit
relativ wenigen einzigartigen Merkmalen zu besitzen, wird im Rahmen der CompareConfig die Ermittlung der Ähnlichkeitswerte stark von der Betrachtung der Elementumgebungen beeinflusst werden.
Gerade die Eigenschaft von Molekülen, viele gleichartige Elemente zu enthalten,
die sich einzig durch ihre strukturelle Platzierung im Graphen unterscheiden, ist in
keinem der bisher unterstützten Dokumenttypen vorhanden. Betrachtet man daher die
Elemente ohne Berücksichtigung der Umgebung, so ergibt sich für viele Elementpaare ein identischer Ähnlichkeitswert, der dazu führt, dass keine Entscheidung getroffen
19
werden kann, welche einander zuzuordnen sind. Aufgrund des strukturellen Aufbaus
von Molekülen mit zyklischen Strukturen und einer nicht selten vorkommenden
Symmetrie kann jedoch auch unter Einbeziehung der Umgebung häufig keine eindeutige Entscheidung getroffen werden, wie in Abbildung 3.3 beispielhaft dargestellt
wird. Das Sauerstoffatom aus Molekül A sowie das über eine Doppelbindung damit
verbundene Kohlenstoffatom können aufgrund der Umgebung eindeutig den entsprechenden Strukturen aus Molekül B zugeordnet werden. Die beiden daran anschließenden Teilbäume sind jedoch vollkommen identisch, so dass eine eindeutige Zuordnung nicht möglich ist. Eng verbunden mit dieser Problematik besteht die Schwierigkeit, bei einem ersten Vergleichsdurchlauf mindestens eine Korrespondenz zu finden,
die dann als Fixpunkt genutzt werden kann, um Elemente in deren Umgebung nach
und nach ebenfalls einander zuordnen zu können. Abbildung 3.4 zeigt zur Verdeutlichung zwei identische Moleküle, bei deren Vergleich keine Atome oder Bindungen
eindeutig einander zugeordnet werden können, so dass die benötigten Fixpunkte vollständig fehlen. Es scheint daher erforderlich, den molekularen Graphen mit zusätzlichen Eigenschaften zu versehen, so dass bestimmte Strukturen möglichst schon in
einem ersten Durchlauf als Korrespondenzen erkannt werden können.
?
Abbildung 3.3 Korrespondenzbildung für zwei Moleküle, bei denen die Abbildung der Teilbäume nicht
eindeutig ist (grün: eindeutige Zuordnung; rot: keine eindeutige Zuordnung)
Eine mögliche Lösung für diese Problematik stammt aus dem zuvor beschriebenen
Bereich der Feature Trees, bei dem Atomgruppierungen mit bestimmten Eigenschaften markiert werden. Während bei Feature Trees zyklische Strukturen und funktio-
20
nelle Gruppen markiert werden, sind für den Vergleich mit SiDiff funktionelle Gruppen ausreichend, da Zyklen durch mehrfache Iterationen des Algorithmus bearbeitet
werden können. Werden in einem molekularen Graphen die funktionellen Gruppen
markiert, so ergeben sich bei einem Vergleich mit einem zweiten markierten Graphen, im Falle von gemeinsamen funktionellen Gruppen, weitere Fixpunkte. Zudem
können durch die Korrespondenzbildung zweier Gruppen bereits mehrere Atome und
Bindungen als Korrespondenzen vermerkt werden.
Die Markierung der funktionellen Gruppen lässt sich aufgrund der beschränkten
Anzahl und des strukturellen Aufbaus der Muster sehr effizient durchführen. Da der
zu vergleichende Datenbestand nur ein einziges Mal markiert und gespeichert werden
muss, ergibt sich für die Laufzeit des eigentlichen Vergleichsvorgangs lediglich ein
zusätzlicher Aufwand für die einmalige Markierung der Gruppen in der Anfragestruktur. Der gewählte Algorithmus sowie das Format zur Speicherung der markierten Moleküle werden ausführlich im folgenden Kapitel behandelt.
?
Abbildung 3.4 Zuordnungsproblematik bei gespiegelten Strukturen trotz funktioneller Gruppen (orange:
Carbonyl-Gruppe)
Selbst mit der Verwendung funktioneller Gruppen sind einige wenige Fälle symmetrischer Strukturen denkbar, bei denen aufgrund mehrerer Kandidaten keine Entscheidung über eine eindeutige Korrespondenzbildung getroffen werden kann (vgl.
Abbildung 3.4). Dies resultiert in einem geringeren Ähnlichkeitswert aufgrund einer
geringeren Anzahl an korrespondierenden Elementen, obwohl die verglichenen Moleküle unter Umständen sogar identisch sein können. Um auch diese Strukturen zu
unterstützen, wäre ein mengenbasierter Ansatz denkbar, der aufgrund der Ähnlichkeitswerte der nicht-korrespondierenden Restelemente und einiger einfacher Ausschlusskriterien eine Menge noch möglicher Korrespondenzen berechnen könnte.
Basierend auf den tatsächlich zugeordneten Elementen und der Menge der möglichen
Korrespondenzen ließe sich dann ein weiterer Ähnlichkeitswert berechnen, der die
maximal mögliche Ähnlichkeit darstellt. Für das Gesamtergebnis einer Anfrage könn-
21
te über einen Gewichtungsparameter definiert werden, inwieweit der rein strukturelle
SiDiff-Ähnlichkeitswert und der mengenmäßige Ähnlichkeitswert der Restelemente
die Ergebnismenge beeinflussen. Diese Überlegungen werden in Kapitel 5.4 vertieft.
Ein weiterer Anpassungsbedarf besteht in der Umstellung auf den Vergleich eines
Dokuments mit mehreren anderen. Bisher stand der Vergleich zweier Dokumente im
Mittelpunkt, bei dem detailliert Gemeinsamkeiten und Unterschiede ermittelt und
angezeigt wurden. Um ein Anfragemolekül mit einem Datenbestand zu vergleichen,
ist es dagegen erforderlich, die einzelnen Strukturvergleiche anzustoßen, die ermittelten Ähnlichkeitswerte zu speichern und dann schließlich nur für die ähnlichsten
Strukturen die detaillierte Ausgabe zu erzeugen. Für die effiziente Umsetzung unterstützt SiDiff ein sogenanntes Graph-Repository, in das mehrere Graphen zu Beginn
geladen werden können und auf dem dann die einzelnen Vergleiche ausgeführt werden. Die Menge der Graphen, die in diesem Respository abgelegt werden können, ist
hauptspeicherabhängig, so dass zur Verwendung großer Datenbestände eine partielle
Bearbeitung mit anschließender Zusammenfügung der Ergebnisse erforderlich wird.
22
4 Markierungsprozess
funktioneller Gruppen
Wie in Kapitel 2.4 bereits erläutert, handelt es sich bei funktionellen Gruppen um
wohlbekannte und häufig auftretende Atom- und Bindungsgruppierungen mit bestimmten Eigenschaften. Häufig stellen sie Charakteristika eines Molekülbereichs
dar, die dafür entscheidend sind, mit welchen Bereichen anderer Substanzen diese in
Verbindung treten können. Als Unterstützung im Vergleichsprozess können sie zudem als mögliche Fixpunkte für den Algorithmus in der Matching-Phase dienen.
Die Problematik, ein Muster in einem Graphen zu finden, lässt sich auf das Problem der Subgraph-Isomorphie zurückführen, welches zur Klasse der NPvollständigen Probleme zählt (vgl. [Var061]). Es handelt sich also um ein Entscheidungsproblem, für das kein Algorithmus bekannt ist, der in polynomieller Zeit eine
Lösung berechnen kann. In der Praxis sorgen einige problemspezifische Nebenbedingungen jedoch häufig dafür, dass viele Probleme dennoch effizient lösbar sind, beispielsweise Charakteristika der Graphstruktur oder der zu verwendenden Muster. Aus
diesem Grund ist zunächst eine Eingrenzung und Untersuchung der zu markierenden
Muster notwendig, um anschließend einen geeigneten Algorithmus wählen zu können.
4.1 Verwendete funktionelle Gruppen
Als Merkmal für die Einteilung in funktionelle Gruppen dient der Elementtyp der
jeweiligen Gruppe. Jede funktionelle Gruppe besteht aus mindestens einem Grundatom, das seinerseits Bindungen zu anderen Atomen besitzt. Je nach Elementtyp dieses Grundatoms erfolgt eine erste Klassifizierung in Gruppen mit Schwefel (S),
Phosphor (P), Stickstoff (N), Sauerstoff (O) und Kohlenstoff (C). Innerhalb dieser
Gruppen existieren mehrere Muster, die genau die Atomtypen und Bindungsgrade
spezifizieren, die mit diesem Startatom verbunden sein müssen, damit es sich um die
jeweilige funktionelle Gruppe handelt. Jede Gruppe besitzt mindestens eine Bindung
zum Rest des Moleküls, der durch ein Wildcard-Element9 (R) dargestellt wird. Abbildung 4.1 zeigt anhand zweier funktioneller Gruppen den Aufbau der Muster.
9
Symbol für beliebiges anderes Zeichen (nach [Def08])
23
4.1 Verwendete funktionelle Gruppen
Abbildung 4.1 Beispielmuster für die Verbindungsklassen der Alkene und Nitrate (Quelle der Strukturen:
[Str96])
Untersucht man die Muster auf strukturelle Überdeckung, also darauf, inwieweit
ein Muster Teil eines anderen Musters ist, so lässt sich bei manchen Mustern eine
derartige Abhängigkeit ausmachen. Gerade innerhalb der Gruppierungen um einen
bestimmten Startatomtyp existieren derartige Abhängigkeitsbeziehungen, jedoch auch
in wenigen Fällen über diese Gruppengrenzen hinaus. Untersucht man diese Abhängigkeitsbeziehungen genauer, ergibt sich eine Hierarchie von Mustern, welche die
Reihenfolge definiert, in der diese in einem molekularen Graphen zu markieren sind.
Auf der obersten Ebene liegen die Muster, die Schwefel enthalten, gefolgt von Phosphor, Stickstoff, Sauerstoff und schließlich Kohlenstoff. Die verwendeten Muster,
eingeteilt in die beschriebene Hierarchie, werden in Kapitel A des Anhangs aufgezeigt. Da die Atomtypen Schwefel bis Sauerstoff deutlich seltener auftreten als Kohlenstoff, besitzt eine markierte Gruppe aus dieser Kategorie eine deutlich höhere Aussagekraft als eine markierte Kohlenstoffverbindung in dem Sinne, dass sie eine höhere Wahrscheinlichkeit hat, bei ähnlichen Strukturen als Fixpunkt für den Vergleich zu
dienen. Ein wesentlicher Vorteil dieser Gruppeneinteilung entsprechend dem Startatomtyp des Musters liegt darin, dass für einen Algorithmus nicht alle Muster durchprobiert werden müssen, sondern nur die, bezogen auf einen Startknoten, passenden
Muster, was die Menge bereits erheblich einschränkt. Darüber hinaus sind die meisten Muster nicht sonderlich komplex mit einer Atomanzahl von vier bis acht Atomen
zusammen mit einer entsprechenden Bindungsanzahl. Eine Ausnahme zu dieser Regel stellen polyzyklische Kohlenstoffverbindungen dar, die aufgrund ihrer Ringstrukturen eine höhere Zahl von Atomen und Bindungen erreichen können. Es stellt sich
jedoch die Frage, bis zu welchem Grad eine Markierung polyzyklischer Kohlenstoffverbindungen im Hinblick auf die Erzeugung vergleichbarer Charakteristika überhaupt sinnvoll ist. [Lip08] analysiert die strukturelle Vielfalt der in der CAS registry
(Chemical Abstracts Service) erfassten organischen Substanzen. Im Rahmen ihrer
Untersuchungen stellen sie eine Übersicht der häufig enthaltenen heterozyklischen
Strukturen dar, woraus ersichtlich wird, das gerade einfache Strukturen mit wenigen
Zyklen sehr häufig vorkommen, komplexe Ringsysteme dagegen seltener. Natürlich
würde bei einem Match zweier markierter, hochkomplexer Ringsysteme direkt eine
hohe Ähnlichkeit erkannt werden. Andere Strukturen jedoch, die nur leichte Abweichungen zu diesem Ringsystem aufweisen, würden in diesem Fall keinen weiteren
24
4.2 Algorithmus zur Gruppenmarkierung
Fixpunkt enthalten und eine Überlagerung würde erschwert. Aus diesem Grund werden für die Gruppenmarkierung im Rahmen dieser Arbeit funktionelle Gruppen mit
bis zu drei zusammenhängenden Ringstrukturen verwendet, da diese nach [Lip08]
relativ häufig auftreten und somit zur Ermittlung von Fixpunkten geeignet sind. Eine
genaue Spezifizierung der polyzyklischen Verbindungen findet sich in [Hel74].
Insgesamt ergibt sich damit ein Katalog von etwa 60 Mustern funktioneller Gruppen, die im Folgenden in molekularen Graphen zu identifizieren und zu markieren
sind. Diese werden im Anhang mit Namen, Struktur und Ranking-Position für die
Reihenfolge der Musterüberprüfung aufgelistet.
Aus den im vorherigen Abschnitt angestellten Überlegungen zu Art und Struktur der
Muster ergeben sich die Merkmale und Nebenbedingungen, die für eine effiziente
Gestaltung des Algorithmus von Bedeutung sind. Zu nennen sind die geringe Gesamtanzahl und die einfache Struktur der zu markierenden Muster, die hierarchische
Ordnung sowie die Eigenschaft, bei der Mustersuche mit einem Startatom eines bestimmten Typs beginnen zu können. Bevor auf einen Algorithmus eingegangen wird,
der diese Nebenbedingungen berücksichtigt, soll zunächst eine kurze Übersicht über
andere mögliche Verfahren gegeben werden.
4.2.1 Verfahren zum Pattern Matching
Es existieren mehrere Verfahren, die darauf abzielen, alle möglichen Isomorphismen
zwischen zwei Graphen G und G‘ zu berechnen. [Ull76] verwendet dazu einen einfachen Suchbaum-Algorithmus, in dem alle möglichen Relations-Matrizen so angelegt
sind, dass an den Blättern Kandidaten für gültige Isomorphismen zu finden sind. Für
jeden dieser Kandidaten muss getestet werden, ob die durch die untersuchte Matrix
erzeugte Abbildung die Isomorphie-Bedingungen erfüllt. Durch eine Verfeinerung,
die einige Schritte bei der Kandidatenermittlung einspart und zudem den Suchbaum
reduziert, lässt sich die Menge der zu testenden Matrizen einschränken. [Val97] entwickelte basierend darauf einen Algorithmus, der bei nicht-zusammenhängenden
Mustern jede Komponente des Musters auf den Zielgraph abbilden kann. Erwähnung
findet hier, dass bei einem attributierten Graph nicht nur die Struktur, sondern auch
die Attribute der Knoten und Kanten entscheidend für die Ermittlung einer Isomorphie sind. Da gerade die Attribute der Atome und Bindungen für eine Zuordnung entscheidend und die Muster alle zusammenhängende Komponenten sind, würde ein
solcher Ansatz zu viele Vergleiche erfordern.
Einen anderen Ansatz wählt [Che081], bei dem eine Mustererkennung in einem
gerichteten Graph durch eine Reihe von R-join-Operationen (reachability join) auf
einer Graph-Datenbank vorgenommen wird, die Graphen in Tabellen speichert. Dazu
25
werden zunächst Cluster-basierte Indizes angelegt, die angeben, welche Tupel über
Tabellen verknüpft sind, um im Folgenden mit einem Zwei-Schritt R-joinAlgorithmus die Erreichbarkeit zu überprüfen. Eine Musterermittlung erfolgt dann
über einen Vergleich der Erreichbarkeit der Knoten sowie deren Labels. Während
dieses Verfahren sehr effizient auf großen, gerichteten Graphen arbeitet, erscheint
eine Anpassung an ungerichtete und Zyklen enthaltende Graphen nur schwer möglich. Abgesehen davon würde eine Umstellung auf eine relationale Datenbank erforderlich, was auch auf Seiten des Vergleichstools zu umfangreichen Anpassungserfordernissen führen würde.
[Var07] nutzen bei der Mustersuche einen rekursiven Ansatz, der berücksichtigt,
dass ein Muster seinerseits aus anderen Mustern bestehen kann. Aus diesem Grund
wird zum Zeitpunkt des Kompilierens zunächst für jedes Muster die Aufrufstruktur
der Elemente in einem sogenannten Call Plan definiert. Dieser wird anschließend so
umgeformt, dass er auf Basis einer globalen Suchstrategie möglichst effizient genutzt
werden kann (Flattened Pattern). In einem letzten Schritt vor der Ausführung wird
schließlich ein sogenannter Search Graph gebildet, der entsprechend möglicher Parametereingaben für jedes Flattened Pattern eine Suchstrategie definiert. Zur Laufzeit
wird zu dem Search Graph der zugehörige Search Plan aufgrund der nun bekannten
Parameter erstellt. Mithilfe einer sogenannten Magic Set Transformation wird der
Search Plan entsprechend der rekursiven Aufrufe so zerschnitten und mit Zusatzinformationen angereichert, dass in einem bottom-up Prozess der Matcher nichtrelevante Zuordnungen ignorieren kann. Der daraus resultierende Rule Goal Graph
liefert damit schließlich die Regeln, die iterativ bottom-up abgearbeitet werden können (vgl. Abbildung 4.2). Dieses Verfahren findet hauptsächlich Anwendung im Bereich der Graph-Transformationen und wurde bei [Var07] in VIATRA210 realisiert.
Interessant im Rahmen dieser Arbeit ist die Betrachtungsweise eines Musters als
Menge von Sub-Mustern, die einen rekursiven Ablauf nahelegt. Des Weiteren liefert
die Eigenschaft funktioneller Gruppen, mit einem bestimmten Startatom zu beginnen,
einen Ansatzpunkt für eine Suchstrategie ähnlich des beschriebenen Search Graph
Verfahrens.
10
VIATRA2 (Visual Automated Model Transformations) stellt zur Ergänzung existierender Modell-Transformations-Frameworks seinerseits ein Framework zur Unterstützung von Spezifikation, Design, Ausführung, Validierung und Wartung von Transformationen zur Verfügung (vgl.
[VIA08])
26
Abbildung 4.2 Überblick über den rekursiven Pattern Matching Prozess nach [RGPM-VHV]
[RGPM
(Quelle:
[Var07], S.5)
[Var06] beschreiben in ihrer Arbeit grundsätzliche Datenstrukturen und einen AlA
gorithmus für eine inkrementelle Mustersuche, die ebenfalls im Bereich der GraphGraph
Transformationen
onen zum Einsatz kommt. Unabhängig von gängigen GraphTransformations-Tools (Graph
(
Transformation Tools) wird ein Verfahren erläutert,
mit dem alle kompletten und nicht-erweiterbaren Zuordnungen,, die nach einem beb
stimmten Search Plan ermittelt wurden, in einem Matching Tree gespeichert werden.
Der Matching Tree wird inkrementell mit jedem gefundenen Element-Match
Element
zwischen Muster und Modell erweitert. Besonders ist, dass mithilfe der vorgestellten
Strukturen und einem Benachrichtigungsmechanismus
Benachrichtigungsmechanismus zeitgleich auch negative MusMu
ter überprüft werden können, die einen möglichen positiven Match ungültig machen
würden. Da die Muster der funktionellen Gruppen hierarchisch geordnet
geordnet und somit in
einer bestimmten Reihenfolge zu markieren sind, ist eine
ein solche Funktionalität hier
nicht erforderlich. Der vorgestellte Ablauf
Ablauf bei der Mustersuche dagegen erscheint für
die Markierung funktioneller Gruppen in vielen Bereichen geeignet und wird daher
im Folgenden kurz beschrieben.
Während der Mustersuche werden Knoten des Musters entsprechenden Elementen
aus dem Modell so zugeordnet,
zugeor
dass die Korrespondenzbildung (Matching
Matching) konsistent
mit Kantenbeschriftungen
beschriftungen, Start- und Zielknoten ist. Ein Submuster
uster wird definiert als
Subgraph des Mustergraphen, so dass mit einem kompletten Matching eines Submusters ein Teil des gesamten Musters zugeordnet wurde. Entsprechend eines Search
Plan, der angibt, in welcher Reihenfolge Musterelemente Modellelementen zugewiezugewi
sen werden sollen, wird in jedem Schritt eine weitere Komponente (Variable)
(
des
Musters einem Element des Modells zugeordnet. Betrachtet
htet als Submuster bedeutet
dies,, dass in jedem Schritt das k-te Submuster erweitert wird, indem das k+1-te Submuster durch die neue Bindung zugeordnet wird. Für jedes Muster Pn wird ein Matching Tree angelegt, in dem Zuordnungen für Elemente des Musters organisiert werwe
den. Eine Zuordnung auf der Stufe k des Baums repräsentiert ein Matching des k-ten
Submusters. Wie diese Submuster den Stufen des Baumes zuzuordnen sind,
sind wird
durch den Search Plan definiert. Die Blätter des Baumes stellen somit maximale parpa
27
tielle Zuordnungen des Musters dar. Bei einem Muster Pn mit n zuzuordnenden Elementen bedeutet ein Matching auf der maximalen Stufe n somit einen kompletten
Match des Musters. Zur Speicherung, welche Musterknoten auf welche Modellknoten
abgebildet wurden, wird ein Binding Array verwendet, in dem die gebildeten Paare
abgelegt werden. Um Zuordnungen bei Modelländerungen zu benachrichtigen, werden für Einfüge- sowie Löschoperationen Notification Arrays vorgehalten, in denen
die zu benachrichtigenden Matchings vermerkt werden. Die verwendeten Datenstrukturen zusammen mit einer Beispielbelegung werden in Abbildung 4.3 dargestellt. Der
Matching Tree mit dem Namen LHS in Abbildung 4.3(b) stellt darin den Baum für
das zu erkennende Muster dar, während NAC den Baum eines negativen Musters repräsentiert.
Abbildung 4.3 Beispiel verwendeter Datenstrukturen in [IGPM-VVS] (Quelle: [Var06], S.6)
Während der inkrementellen Ausführungsphase erfolgt die Steuerung über vier
grundlegende Operationen. Werden Elemente hinzugefügt, so erweitert die insert()Operation das jeweilige Submuster, validate() steuert rekursiv die Erweiterung mit
insert() über alle Submuster. Werden Matchings entfernt, so kann mit delete() ein
gesamter Baumzweig ab dem benannten Matching gelöscht werden. Invalidate() ist
dann für die rekursive Entfernung aller Zuordnungen von Kindelementen des aktuellen Matchings zuständig.
4.2.2 Verfahren zur Markierung funktioneller Gruppen
In Anlehnung an das zuvor beschriebene Verfahren lässt sich auch für die Muster
funktioneller Gruppen eine Art Search Plan erstellen. Abbildung 4.4 zeigt als Beispiel die Molekülstruktur (a), in der der die funktionelle Gruppe (b) zu markieren ist.
Aus der Gruppendefinition lässt sich der Search Plan (c) ableiten. Entsprechend der
Musterdefinition können die Atome in einer bestimmten Reihenfolge auf die Knoten
28
des Moleküls abgebildet werden. Da die zu markierenden Gruppen ausgehend von
einem bestimmten Startknoten häufig in mehrere Richtungen zu entwickeln sind, ergibt sich eine baumartige, rekursive Aufrufstruktur. Bildet die Zuordnung des Startatoms die Wurzel des Musters, so stellen die Zweige Submuster dar, die ihrerseits als
Wurzel das jeweilige Matching der direkt benachbarten Atome besitzen. Entsprechend rekursiver Aufrufe wird jedes Submuster erweitert, indem seine Submuster
zugeordnet werden. Ein Submuster ist komplett zugeordnet, sobald alle Zweige des
Submusters zugeordnet wurden. Für Muster, die Zyklen enthalten, würde bei Erreichen eines bereits zugeordneten Knotens rekursiv zurückgesprungen, so dass sich
auch für diese eine Baumstruktur ergibt.
N
DB
EB
EB
O
EB
(a) Molekülstruktur (b) Graph funktioneller Gruppe
(c) Search Plan
Abbildung 4.4 Beispielstrukturen für den Algorithmus zur Markierung funktioneller Gruppen
(DB=Doppelbindung; EB=Einzelbindung) (Quelle Abb.(b): [Str96], S.9)
Die Zuordnungsspeicherung der Muster-Molekül-Knotenpaare könnte ähnlich der
in [Var06] vorgestellten Binding Arrays vorgenommen werden, wie in Abbildung 4.5
dargestellt. Die Abbildung zeigt die Molekülstruktur, den Matching Tree und das
Binding Array zu einem Zeitpunkt, zu dem bereits das Stickstoffatom sowie zwei der
drei Sauerstoffatome zugeordnet wurden. Zwei der drei Submuster, die unterhalb des
Muster-Startatoms angeordnet sind, wurden bereits vollständig abgearbeitet. Zum
dargestellten Zeitpunkt wurde gerade das Sauerstoffatom Oc des Musters dem Sauerstoffatom O2 des Moleküls zugeordnet, wodurch das zweite Submuster vervollständigt
wurde. Als nächstes wird das dritte Submuster auf den Molekülgraph abgebildet, indem im Molekül eine Entsprechung für Od gesucht wird.
Da keine zwei Muster zeitgleich verarbeitet werden müssen, ist ein NotificationMechanismus nicht erforderlich. Für die Bearbeitung wird ein sehr ähnlicher Funktionsumfang benötigt. Analog zu insert() ist eine Erweiterung des jeweiligen Submusters durch Hinzufügen des nächsten Matchings vorzunehmen. Kann ein unvollständiges Submuster nicht erweitert werden, so muss sein Wurzel-Matching entfernt und
29
zurückgesprungen werden. Dafür wird eine Funktionalität ähnlich der delete()Operation erforderlich. Wurden zu diesem Zeitpunkt bereits andere Submuster unter
der betroffenen Wurzel zugeordnet, so müssen diese Matchings mit den entsprechenden Verwaltungsstrukturen ebenfalls zurückgesetzt werden, was der invalidate()Operation entspricht. Aufgrund der Eigenschaft molekularer Graphen, viele sehr ähnliche Elemente zu enthalten, ist die Entscheidung, welches benachbarte Atom mit
dem nächsten Musterknoten zuzuordnen ist, häufig nicht eindeutig. An diesen Stellen
ist eine probeweise Bildung aller möglichen Kombinationen bis zur Ermittlung einer,
auch für darunterliegende Submuster, gültigen Zuordnung erforderlich. Weitere
Merkmale funktioneller Gruppen sowie der Moleküle sorgen für eine starke Einschränkung der zu testenden Muster.
Matching Tree
Na
DB
Molekülstruktur
Ob
EB
EB
Oc
Od
EB
Re
Na Ob Oc Od Re
N1 O3 O2
Binding Array
Abbildung 4.5 Beispielbelegung Matching Tree und zugehöriger Binding Array bei Mustersuche
Wird die Suche nach einem Muster mit einem bestimmten Startatomtyp begonnen,
so schränkt alleine diese Bedingung die Menge der zu testenden Muster erheblich ein.
Organische Moleküle sind dadurch gekennzeichnet, dass sie hauptsächlich aus Kohlen- und Wasserstoffatomen bestehen und andere Atomtypen wie Schwefel, Phosphor, Stickstoff und Sauerstoff deutlich seltener vorkommen. Beginnt man bei der
Gruppenmarkierung bei den selteneren Atomen, was die hierarchische Strukturierung
der funktionellen Gruppen möglich macht, so lassen sich die Muster mit der höchsten
30
Priorität gleich zu Beginn abarbeiten. Da diese nicht sonderlich zahlreich sind und
zudem eine geringe Komplexität besitzen, lässt sich mit wenigen Knotenvergleichen
entscheiden, ob ein Muster passt oder nicht, was ein Abarbeiten der Muster ermöglicht. Viele dieser Muster enthalten zudem auch Kohlen- und Wasserstoffatome, so
dass beim Match eines Musters zugleich die Restmenge der noch zu überprüfenden
und häufig zahlreichen Kohlenstoffatome reduziert wird.
Wurden alle funktionellen Gruppen um die selten vorkommenden Elementtypen
markiert, folgen schließlich die Kohlenstoffgruppen. Aufgrund der polyzyklischen
Strukturen mit bis zu 23 Atomen sind die Muster, die zu Beginn getestet werden müssen, deutlich komplexer. Darüber hinaus stellt sich bei Mustern, die komplett aus
Kohlenstoffatomen bestehen, die Frage, mit welchem Atom die Musterdefinition beginnen soll. Beide Problematiken lassen sich mit einer Abwandlung des Algorithmus
von Morgan adressieren (vgl. [Koh07]). Morgans Algorithmus bestimmt die kanonische11 Nummerierung der Atome eines molekularen Graphen, die als Grundlage für
eine kanonische Darstellung des Graphen genutzt werden kann. Dazu wird zunächst
jeder Knoten mit seiner Konnektivität bewertet. Anschließend wird die erweiterte
Konnektivität ermittelt, indem die Grade der benachbarten Knoten miteinbezogen
werden. Der Algorithmus iteriert über den Graphen, bis sich die Anzahl der unterschiedlichen Grad-Klassen nicht mehr verändert. Anschließend erfolgt eine eindeutige Nummerierung, indem beim Knoten mit dem höchsten Gewicht begonnen wird
und anschließend die Nachbarn in absteigender Reihenfolge mit Breitensuche markiert werden. Bei Mehrdeutigkeit werden Atomtyp und Bindungsordnung miteinbezogen. Abbildung 4.6 verdeutlicht den Prozess zur Ermittlung der kanonischen
Nummerierung anhand eines Beispiels. Verändert man den Algorithmus derart, dass
für die Grundgewichtung der Atome der Atomtyp bereits miteinbezogen wird, sowie
für die erweiterte Konnektivität die Bindungsordnung, so ergibt sich für die heterozyklischen Strukturen sowohl im Muster als auch im molekularen Graphen ein eindeutiges Startatom. Mit Morgans Algorithmus lässt sich zudem eine Rangordnung der
Kohlenstoffatome im molekularen Graphen berechnen, die sicherstellt, dass die zuerst
besuchten Atome mögliche Startatome heterozyklischer Strukturen sind, womit auch
die Rangordnung innerhalb der Kohlenstoff-Muster umgesetzt werden kann.
11
Kanonisch = eindeutig
31
Abbildung 4.6 Beispiel zur Ermittlung der kanonischen Nummerierung mit dem Algorithmus von Morgan
(nach [Koh07], Foliensatz „2D Ähnlichkeit“, S.18ff)
4.2.3 Verwendeter Algorithmus
Zur Markierung der funktionellen Gruppen mit dem zuvor beschriebenen Verfahren,
sind sowohl das Molekül als auch die Muster zunächst in eine geeignete Objektstruktur zu importieren. Da der molekulare Graph im CML-Format vorliegt und die Musterdefinitionen ebenfalls in einem CML-ähnlichen Format vorgenommen werden
können, wird dazu ein SAX-Parser (Simple API for XML) verwendet. Dieser erzeugt
bei der Initialisierung einen Musterverwaltungs-Container und lädt jedes Muster als
Compound12 in dessen Verwaltungsstrukturen. Anschließend wird für das Molekül
ein zweiter Parser verwendet, der dieses in die Objektstruktur unter Verwaltung der
Klasse lädt, die im Folgenden den Markierungsprozess steuert. Abbildung 4.7 zeigt
das UML-Klassendiagramm zur Modellierung der Molekülstrukturen. Ein Molekül
besteht aus Atomen und Bindungen und kann darüber hinaus Compounds enthalten.
Jeder Compound umfasst ein oder mehrere dieser Atome und Bindungen. Ein Atom
kann mit mehreren Bindungen verknüpft sein, jede Bindung verbindet genau zwei
Atome. Die auf diesen Strukturen arbeitenden Verwaltungsklassen werden in Abbildung 4.8 dargestellt. Der MoleculeAnnotator lädt zu Beginn das zu markierende Molekül und initialisiert den PatternManager, der seinerseits die Musterdefinitionen in
Form von Compound-Elementen unter seine Verwaltung stellt.
12
Der Begriff Compound wird im Folgenden stellvertretend für eine Gruppierung von Atomen und
Bindungen verwendet
32
Abbildung 4.7 Klassendiagramm der Molekülstruktur
Abbildung 4.8 Klassendiagramm der Verwaltungsstrukturen
In einem ersten Schritt wird der molekulare Graph mit der angepassten Variante
von Morgans Algorithmus markiert, wodurch die Reihenfolge, in der die Atome als
Startatome zu besuchen sind, festgelegt wird. Die Atomtypen werden in der Reihenfolge Schwefel, Phosphor, Stickstoff, Sauerstoff und schließlich Kohlenstoff besucht.
Innerhalb jeder dieser Startatom-Gruppen ermittelt sich die Reihenfolge aufgrund der
33
berechneten Werte von Morgan. Initial wird jedes Atom entsprechend seines Atomtyps mit einem Zahlenwert belegt: Wasserstoff mit eins (1), Kohlenstoff mit zwei (2)
und alle anderen Typen mit drei (3). Anschließend wird diese Gewichtung an die
Nachbarn weitergegeben und mit dem Grad der Bindung multipliziert, mit der die
Atome verbunden sind. Gerade bei polyzyklischen Strukturen, die vollständig aus
Kohlenstoff bestehen, sorgt dieser Algorithmus dafür, dass die zentral gelegenen
Atome aufgrund von vier Bindungen zu ebenfalls Kohlenstoffatomen den höchsten
Wert erhalten und somit bei der folgenden Mustererkennung zuerst besucht werden.
Wurde die Reihenfolge der Startatome ermittelt, werden diese anschließend der
Reihe nach besucht. Zu jedem Atom werden entsprechend des Atomtyps kompatible
Muster getestet, wobei auch diese entsprechend ihrer hierarchischen Anordnung in
einer festgelegten Reihenfolge abgearbeitet werden. Diese Reihenfolge findet sich
zusammen mit der detaillierten Definition der verwendeten Muster im Anhang. Der
Mappingvorgang, bei dem versucht wird, ein Muster auf die Strukturen im molekularen Graphen abzubilden, erfolgt rekursiv durch den Vergleich von Atomknoten. Zur
Beschreibung des Algorithmus wird im Folgenden zwischen dem molekularen Graphen auf der linken Seite und dem Muster auf der rechten Seite unterschieden.
Beim Vergleich zweier Atome wird zunächst der Elementtyp verglichen. Stimmt
dieser überein oder handelt es sich im Muster um das Wildcard-Element „R“, das als
Platzhalter für einen beliebigen Typ steht, so kommen die beiden Atome als Kandidaten in Frage und werden einander zugeordnet. Für den weiteren Vergleich wird die
direkte Nachbarschaft der Atome herangezogen, wobei als Ausgangspunkt immer das
Muster auf der rechten Seite genutzt wird, um anschließend eine Entsprechung des
jeweiligen Elements auf der linken Seite zu finden. Ausgehend vom Muster-Atom
werden zunächst die Bindungskanten ermittelt, die zu angrenzenden Atomen führen.
Für jede noch nicht besuchte Kante werden anschließend Kandidaten auf der linken
Seite gesucht, die denselben Bindungsgrad aufweisen. Zusätzlich wird durch Überprüfung der Elementtypen der verbundenen Atome die Kandidatenmenge weiter eingeschränkt. Wird dabei trotzdem mehr als ein möglicher Kandidat gefunden, so sind
alle möglichen Zuordnungen von Bindungen so lange zu testen, bis eine für das Muster passende gefunden wurde oder keine Kombinationen für das jeweilige Muster
mehr möglich sind. Bei jeder Bindungszuordnung werden die entsprechenden Bindungen als besucht markiert und es erfolgt ein rekursiver Aufruf mit den Zielatomen
an deren Enden, die dann auf die gleiche Art verglichen werden. Stimmen zwei Atome in ihrem Elementtyp überein und können davon ausgehend im Muster keine weiteren Kanten ermittelt werden, die noch nicht besucht wurden, so wird durch eine
entsprechende Rückgabe signalisiert, dass der jeweilige Teilbaum komplett zugeordnet wurde. Existieren dagegen noch nicht-besuchte Kanten an dem Muster-Atom, zu
denen keine entsprechenden Kanten am Molekül-Atom ermittelt werden können, so
wird auch dies mit einer entsprechenden Rückgabe kenntlich gemacht. Dadurch kann
im rekursiv vorgelagerten Atomvergleich eine andere Bindungszuordnung getestet
werden. Diese Abbruchbedingungen stellen den Rekursionsanker dar. Eine Darstel-
34
lung des beschriebenen Algorithmus in Pseudocode findet sich im Teil A des Anhangs.
Na
Cb
Ce
Rd
Oc
Rh
Of
Rg
Imide-Muster
Zuordnungs-Tabelle
Na
N1
Cb
C2
Oc
O3
Rd
C4
Ce
C5
Of
Rg
Rh
N1
C2
O3
Molekülstruktur
C4
H9
C8
C5
O6
H10
...
C7
H11
...
Abbildung 4.9 Beispielsituation bei Markierung eines Imide-Musters
Durch den gewählten rekursiven Vergleichsablauf der Knoten, mit dem versucht
wird, ein Muster über einen bestimmten Pfad abzubilden, ergibt sich eine baumartige
Aufrufstruktur. Die Abarbeitung dieses Muster-Baumes erfolgt mit Tiefensuche, indem von links nach rechts alle Teilbäume nacheinander komplett zugeordnet werden.
Konnte der letzte Teilbaum vollständig abgebildet werden, ist das Muster komplett
und es kann im Original-Molekül markiert werden. Abbildung 4.9 verdeutlicht diesen
Matching-Prozess anhand baumartiger Strukturen, die sich durch die Abbildung der
Musterknoten auf die Molekülelemente ergeben. Im oberen Bereich wird die Verbindungsklasse der Imide mit dem zugehörigen Matching Tree dargestellt, im unteren
Bereich die Molekülstruktur zusammen mit der baumartigen Aufrufstruktur, die sich
bei der Atomzuordnung ergibt. Zum abgebildeten Zeitpunkt wird im Muster ausgehend vom zuvor zugeordneten Knoten Ce der nächste nicht-besuchte Knoten Of ausgewählt. Anhand des Atomtyps und des Bindungsgrades zwischen Ce und Of wird
anschließend versucht, eine entsprechende Struktur im Molekülgraph zu ermitteln,
35
4.3 Dateiformat zur Speicherung
analog dort ausgehend von dem zuvor zugeordneten Atom C5. Da Elementtyp und
Bindungsgrad mit O6 übereinstimmen und O6 noch nicht besucht wurde, wird dieser
als nächstes Of zugeordnet. Zur Erhöhung der Übersichtlichkeit wurde in der Abbildung auf die Beschriftung der Pfeile mit den Bindungsgraden innerhalb der Baumstrukturen verzichtet. Diese Informationen sind jedoch in den links aufgeführten
Strukturen enthalten und können daraus abgeleitet werden.
Während der Mustersuche werden sowohl besuchte Atome als auch Bindungen
markiert, so dass diese anschließend als Unterelemente der funktionellen Gruppe eingetragen werden können. Eine genaue Erfassung der Bindungen ist erforderlich, da
ansonsten unter Umständen nicht ersichtlich wird, welche Verbindung von der funktionellen Gruppe zum Rest des Moleküls führt. Atome, die als Bestandteil eines Musters markiert wurden, müssen für die Suche weiterer Muster nicht als Startatome betrachtet werden, da jedes Atom höchstens in einer funktionellen Gruppe vorkommen
kann. Somit reduziert ein gefundenes Muster häufig die Menge der noch zu untersuchenden Restatome.
Wurden alle Startatome mit dem zuvor beschriebenen Algorithmus abgearbeitet,
ist die Markierung der funktionellen Gruppen komplett. In der Objektstruktur wurden
an den entsprechenden Stellen Compound-Elemente erzeugt und die zugehörigen
Atome und Bindungen eingetragen. Abschließend erfolgt eine Speicherung des markierten Moleküls in einem CML-ähnlichen Format, das im Folgenden kurz beschrieben wird. Die durchgeführten Testspezifikationen und Testergebnisse der Gruppenmarkierung werden in Kapitel 6 aufgeführt.
Da die um Gruppeninformationen angereicherten molekularen Graphen im Folgenden
vom SiDiff-Algorithmus zu vergleichen sind, erscheint auch zu deren Speicherung
ein auf XML basierendes Dateiformat sinnvoll. Durch eine Ergänzung der CML um
Tags für die markierten funktionellen Gruppen kann deren Standard nahezu unverändert übernommen werden.
Analog zu den eingesetzten atomArray- und bondArray-Containern wird ein neues
Element compoundArray erzeugt, das als Container für die markierten Gruppen dient.
Innerhalb dieses Containers wird für jede markierte Gruppe ein compound-Element
mit der ID und dem Namen der Gruppe angelegt. Jedes dieser compound-Elemente
beinhaltet dann, wie in der ursprünglichen CML innerhalb des molecule-Tags, einen
atomArray- sowie einen bondArray-Container für die in der Gruppe enthaltenen
Atome und Bindungen. Elemente, die zu keiner der markierten Gruppen gehören,
bleiben unverändert in den Top-Level Containern. Somit existiert eine eindeutige
Zuordnung von Atomen und Bindungen zu den jeweiligen Gruppen, ohne die ursprünglichen Elemente mit zusätzlichen Attributen versehen zu müssen. Die zugehörige DTD (Document Typ Definition) wird in Abbildung 4.10 darstellt.
36
<!DOCTYPE molecule [
<!ELEMENT molecule (compoundArray,atomArray, bondArray)>
<!ATTLIST molecule
id
ID
#REQUIRED>
<!ELEMENT compoundArray (compound)*>
<!ELEMENT compound (atomArray,bondArray)>
<!ATTLIST compound
id
ID
#REQUIRED
name
CDATA
#REQUIRED>
<!ELEMENT atomArray (atom+)>
<!ELEMENT atom EMPTY>
<!ATTLIST atom
id
ID
#REQUIRED
elementType
CDATA
#REQUIRED
x3
CDATA
#IMPLIED
y3
CDATA
#IMPLIED
z3
CDATA
#IMPLIED>
<!ELEMENT bondArray (bond*)>
<!ELEMENT bond EMPTY>
<!ATTLIST bond
atomRefs2
IDREFS
#REQUIRED
order
CDATA
#REQUIRED>
]>
Abbildung 4.10 DTD zur Definition der markierten Moleküle
Die Speicherung der Musterdefinitionen erfolgt nach dem gleichen Prinzip. Innerhalb eines functionalGroups-Containers wird für jede Musterdefinition ein functionalGroup-Element mit ID und Name der Gruppe angelegt. Darunter werden, wie
beim CML-Standard für Moleküle, atomArray und bondArray-Container mit den
enthaltenen Atomen und Bindungen erzeugt. Die DTD zur Definition gültiger Muster
ist in Abbildung 4.11 dargestellt. Entscheidend für das zuvor beschriebene System
aus Muster-Hierarchieebenen, Startatomen und Ablauf bei der Muster-Abbildung auf
den Molekülgraphen ist jedoch die Reihenfolge, in der die Muster in dieser Datei
aufgeführt werden.
37
<!DOCTYPE functionalGroups [
<!ELEMENT functionalGroups (functionalGroup+)>
<!ELEMENT functionalGroup (atomArray,bondArray)>
<!ATTLIST functionalGroup
id
ID
#REQUIRED
name
CDATA
#REQUIRED>
<!ELEMENT atomArray (atom+)>
<!ELEMENT atom EMPTY>
<!ATTLIST atom
id
ID
#REQUIRED
elementType CDATA #REQUIRED
x3
CDATA
#IMPLIED
y3
CDATA
#IMPLIED
z3
CDATA
#IMPLIED>
<!ELEMENT bondArray (bond*)>
<!ELEMENT bond EMPTY>
<!ATTLIST bond
atomRefs2
IDREFS
#REQUIRED
order
CDATA
#REQUIRED>
]>
Abbildung 4.11 DTD zur Definition der Muster funktioneller Gruppen
Die Definition der Muster erfolgt von oben nach unten mit absteigender Priorität,
so dass diejenigen Muster, die weiter oben stehen, vor Mustern, die weiter unten aufgeführt sind, getestet werden. Innerhalb eines Musters gibt das erste Atom des atomArray-Containers das Startatom an, unter dem das Muster einsortiert wird, wodurch
es auf jeden Fall bei der Mustersuche als Erstes besucht wird. Die Reihenfolge, in der
die übrigen Atome besucht werden, hängt von der Reihenfolge der definierten Bindungen ab. Da diese beim Parsen der Muster der Reihe nach verarbeitet, erzeugt und
mit den Atomen verlinkt werden, ergibt sich auch für die Reihenfolge der besuchten
Bindungen eine absteigende Priorität. Diese Eigenschaften können bei der Musterdefinition ausgenutzt werden, um bei ähnlichen Mustern möglichst frühzeitig das unterscheidende Merkmal zu erreichen und somit unnötige Knotenvergleiche zu vermeiden.
38
5 Integration in die
Differenzberechnung
Nachdem Rahmenbedingungen und Ablauf der Markierung funktioneller Gruppen
erörtert wurden, lassen sich im Folgenden die Anforderungen für die Integration der
beteiligten Komponenten spezifizieren. Für die mit Gruppeninformationen angereicherten molekularen Graphen ist zunächst das Datenmodell des internen SiDiffGraphen zu entwickeln, auf dem der eigentliche Molekül-Vergleich durchgeführt
wird. Für die darin definierten Knotentypen sind anschließend die erforderlichen
Konfigurationsskripte zu erstellen, mit deren Hilfe sich Kandidatenmengen, Vergleichskriterien und –schwellenwerte sowie der generelle Ablauf beim Matching
steuern lassen. Wurden alle für SiDiff benötigten Konfigurationen vorgenommen,
muss die Komponente zur Gruppenmarkierung in den Gesamtablauf integriert werden, damit für den Vergleichsvorgang eines Moleküls mit dem Datenbestand die
Markierung der funktionellen Gruppen im Anfragemolekül automatisch erfolgen
kann. Im Hinblick auf die Schwierigkeit, manche Elemente aufgrund mehrerer Kandidaten mit identischem Ähnlichkeitswert nicht eindeutig zuordnen zu können, wird
abschließend ein ergänzendes Verfahren vorgestellt, das basierend auf den mit SiDiff
ermittelten Differenzen einen angepassten Ähnlichkeitswert berechnet. Die mit den
hier vorgestellten Konfigurationen durchgeführten Tests werden in Kapitel 6 beschrieben und ausgewertet.
5.1 Datenmodell molekularer Graphen
Für den Vergleich zweier Moleküle sind diese zunächst auf das interne SiDiffDatenmodell abzubilden. Dazu müssen die Elementtypen, die in molekularen Graphen vorkommen, in geeigneter Form auf die intern vorhandenen Elementtypen projiziert werden. Aus diesem Grund werden zunächst die wesentlichen Merkmale des
markierten molekularen Graphen noch einmal verdeutlicht, um anschließend die Abbildung zu erläutern.
Unter Berücksichtigung der neuen Elemente, die durch die Markierung funktioneller Gruppen hinzugefügt wurden, lassen sich in Molekülen die Knotentypen Molecule, Compound, Atom und Bond identifizieren. Auf der obersten Ebene steht das Molekül, das neben einer eindeutigen ID je nach Datenbestand auch einen Namen haben
kann. Innerhalb des Moleküls können Atome und Bindungen, wie zuvor beschrieben,
in einer funktionellen Gruppe auftreten. Das Compound-Element, die funktionelle
Gruppe, verfügt ebenfalls über eine ID sowie den Namen der Gruppe. Gehören Atome und Bindungen zu einer dieser Gruppen, so sind sie unterhalb des jeweiligen
39
Compound-Elements angeordnet, andernfalls direkt unterhalb des Moleküls. Eine
Bindung ist jeweils mit den beiden durch sie verknüpften Atomen verbunden.
Für den internen SiDiff-Graphen stehen nach [Gad07] die Elementtypen Document, Graph, Node, Attribute und Edge zur Verfügung. Das Top-Level Element Document stellt die Wurzel dar, in der der XML-Namespace und der Dokumenttyp definiert werden und in die ein Graph-Element eingebettet wird. Der Graph verweist auf
den für den Vergleichsvorgang entscheidenden Node-Startknoten. Die eigentliche
Darstellung der molekularen Graphen erfolgt somit durch Knoten (Node), Attribute
(Attribute) und Kanten (Edge). Knoten verfügen neben einem eindeutigen Identifizierer immer über einen Typ, mit dessen Hilfe im Folgenden erkannt werden kann, wie
der Knoten bei der Abarbeitung zu behandeln ist, da Regeln in den Konfigurationsskripten elementtypbezogen sind. Darüber hinaus kann ein Knoten beliebig viele Attribute haben, die ebenfalls getypt sind (type) und einen Wert (value) haben, der im
Vergleichsvorgang für die Ähnlichkeitsberechnung ausgewertet wird. Die Verknüpfung der Knoten erfolgt durch gerichtete Kanten, die neben Start- (src) und Zielknoten-IDs (tar) ebenfalls über einen Typ verfügen. Abbildung 5.1 zeigt das interne SiDiff-Datenmodell mit den beschriebenen Strukturen, auf das im Folgenden die Molekülstrukturen abzubilden sind.
Abbildung 5.1 Internes Datenmodell für die Differenzberechnung (Quelle: [Tre07], S.41)
Für eine Abbildung des molekularen Graphen werden zunächst Document und
Graph erzeugt, in denen der Dokumenttyp „MoleculeModel“ und, sofern vorhanden,
auch der Name des Moleküls eingetragen werden. Die eigentliche Molekülwurzel,
also der erste Knoten, auf den Graph verweist, erhält als Typ immer „model“, was
SiDiff den Startpunkt der zu vergleichenden Struktur signalisiert. Davon abgesehen
wird der Knoten jedoch behandelt wie jeder andere auch und ein Vergleich dieses
Elements kann somit auch mit den Konfigurationsdateien gesteuert werden. Unterhalb dieses Wurzelknotens wird für jede Gruppe ein Knoten mit dem Typ „com-
40
pound“ und dem Namen der Gruppe angelegt, welche über die Kante „compounds“
von der Wurzel aus erreichbar ist. Wurden diese Strukturen aufgebaut, werden als
nächstes die Atome und Bindungen erzeugt. Für Atome wird ein Knoten mit deren ID
angelegt und es wird ein Name kreiert, der neben der ID auch den Elementtyp enthält.
Dieser Name ist für den folgenden Vergleichsvorgang irrelevant, erleichtert jedoch
die Lesbarkeit der Ausgabe und die Analyse der gebildeten Korrespondenzen erheblich. Name sowie Elementtyp (elementType) werden als Attribute des Knotens hinzugefügt und er wird über die Kante „atoms“ von der entsprechenden Gruppe hin zum
Knoten in den Graph eingeordnet. Eine Bindung zwischen zwei Atomen wird ebenfalls durch einen Knoten repräsentiert, der als Attribute neben der Bindungsordnung
(order) einen Namen erhält, aus dem die durch ihn verbundenen Atome zu Analysezwecken leserlich hervorgehen. Die Zuordnung zu den verbundenen Atomen erfolgt
über zwei „target“-Kanten, die von der Bindung zu den entsprechenden Atomen verlaufen. Wie Atome werden auch Bindungen unter der jeweiligen Gruppe eingeordnet,
zu der sie gehören, erreichbar über eine „bonds“-Kante. Wurden alle funktionellen
Gruppen mit deren zugehörigen Elementen erzeugt, folgen schließlich die übrigen
Atome und Bindungen. Auch wenn diese Elemente nicht direkt einer funktionellen
Gruppe zugeordnet werden können, ergeben sich für ihre Behandlung dieselben
Rahmenbedingungen, wodurch sie ebenfalls unterhalb eines Standard-Compound
angeordnet werden können. Dieser erhält eine eindeutige ID „def-comp“ (DefaultCompound) und einen Namen, der die ID des Moleküls beinhaltet. Abgesehen davon
werden Atome und Bindungen mit den zugehörigen Knoten-Kanten-Strukturen jedoch genau wie oben beschrieben angelegt und mit zugehörigen „atoms“- und
„bonds“-Kanten unterhalb des Containers angeordnet. Dabei kann eine Bindung auch
zwischen Atomen bestehen, die in unterschiedlichen Compounds platziert sind. Die
Struktur des internen SiDiff-Graphen zur Darstellung der Moleküle wird in Abbildung 5.2 dargestellt.
Die Umwandlung in die Strukturen des internen SiDiff-Graphen erfolgt mit Hilfe
eines XSL-Stylesheet, mit dem die Elemente des molekularen Graphen in der oben
beschriebenen Reihenfolge abgearbeitet werden. Wurde der interne Graph erzeugt, so
startet der Vergleichsvorgang, gesteuert durch die im Folgenden beschriebenen Konfigurationsskripte.
41
5.2 Anpassung der Konfigurationsskripte
Abbildung 5.2 Molekül-Datenmodell im internen SiDiff-Graphen
Für den Vergleich molekularer Graphen wurden drei Konfigurationsdateien angepasst. Die CandidatesConfig steuert als erste Instanz die Grundvoraussetzungen, die
erfüllt sein müssen, damit Elemente überhaupt für einen Vergleich in Betracht gezogen werden. Über die CompareConfig werden die Vergleichskriterien der Elemente
spezifiziert sowie deren Gewichtungen bei der Ermittlung des Ähnlichkeitswerts bestimmt. Mit der MatchingConfig wird die Reihenfolge, in der die Elementtypen des
Graphen verglichen werden sollen, definiert. Die vorgenommenen Anpassungen werden im Folgenden detailliert beschrieben.
5.2.1 CandidatesConfig
Um die Menge der zu vergleichenden Elemente einzuschränken, besteht die Möglichkeit, in einem ersten Schritt Mindestbedingungen anzugeben, die erfüllt sein müssen, damit für zwei Elemente überhaupt ein Ähnlichkeitswert ermittelt wird. Diese
Constraints werden für den entsprechenden Knotentyp definiert und erhalten einen
Ausdruck (Expression), der erfüllt sein muss, damit zwei Elemente des Typs überhaupt als Kandidaten in Frage kommen. Dieser Ausdruck spezifiziert neben einer
Vergleichsfunktion auch den Namen des zu vergleichenden Knotenattributs. Zusammen mit der Eigenschaft, dass die zu vergleichenden Elemente den gleichen Typ haben müssen, lässt sich damit die Menge der möglichen Kandidaten erheblich reduzieren.
42
Bei molekularen Graphen kommen relativ wenige unterschiedliche Knotentypen
vor, Instanzen dieser Typen sind häufig jedoch recht zahlreich. Bezogen auf den Knotentyp ergibt sich somit eine große Menge möglicher Kandidaten, besonders für
Atome und Bindungen. Durch Ausnutzung der Attribute dieser Knotentypen lässt
sich diese Menge allerdings erheblich reduzieren. Für Atome macht es keinen Sinn,
diese mit anderen Atomen zu vergleichen, wenn schon der Elementtyp verschieden
ist. Daher kann mit einem Ausdruck angegeben werden, dass das Attribut elementType denselben Wert haben muss. Bindungen verfügen über eine nummerische Bindungsordnung order, die ebenfalls mithilfe eines Ausdrucks auf Gleichheit überprüft
werden kann. Somit werden für die folgenden Vergleiche nur Atome miteinander
verglichen, die denselben Elementtyp aufweisen, sowie Bindungen, die dieselbe Ordnung haben.
Diese sehr restriktive Einschränkung der Kandidatenmenge führt dazu, dass auch
Elemente, die innerhalb des Graphen aufgrund ihrer Positionierung eine hohe Ähnlichkeit aufweisen, nicht als Korrespondenzen markiert werden, sofern die oben genannten Kriterien nicht übereinstimmen. Im Hinblick auf die enorme chemische Bedeutung unterschiedlicher Elementtypen und Bindungsordnungen sowie das Ziel des
Vergleichs, möglichst ähnliche Strukturen zu einem Anfragemolekül zu ermitteln,
erscheint diese Einschränkung jedoch angemessen. Abbildung 5.3 zeigt die Regeln
zur Einschränkung der Kandidatenmenge anhand eines Auszugs aus der Konfigurationsdatei.
<Constraints graphType="MoleculeModel">
<Constraint nodeTypeName="atom">
<Expression name="EqualAttributeValue"
param="elementType"/>
</Constraint>
<Constraint nodeTypeName="bond">
<Expression name="EqualAttributeValue"
param="order"/>
</Constraint>
</Constraints>
Abbildung 5.3 Auszug der CandidatesConfig zum Vergleich molekularer Graphen
5.2.2 CompareConfig
In der CompareConfig werden für jeden im internen SiDiff-Graphen vorkommenden
Knotentypen (NodeType) die zu verwendenden Vergleichskriterien sowie deren Gewichtungen bei der Ermittlung des Ähnlichkeitswerts spezifiziert. Es existieren mehrere Vergleichsfunktionen, die neben den Attributen des Knotens sowie seinen einund ausgehenden Kanten auch Mengen anderer Knoten vergleichen können, die über
einen Kantenzug erreichbar sind. Somit kann für die Ermittlung des Ähnlichkeitswerts zweier Knoten nicht nur der direkte Vergleich der Knotenattribute verwendet
43
werden, sondern auch die Umgebung des Knotens. Die Errechnung des Ähnlichkeitswerts gestaltet sich derart, dass auf den zu vergleichenden Knoten zunächst die
Vergleichsfunktionen der Reihe nach abgearbeitet werden, wodurch jede der Funktionen einen Ähnlichkeitswert liefert. Wie stark der ermittelte Ähnlichkeitswert in die
Gesamtähnlichkeit des Knotenvergleichs einfließt, bestimmt der Gewichtungsparameter der Funktion (weight). Wurden alle anteiligen Funktions-Ähnlichkeitswerte auf
dem Knoten aufsummiert und normalisiert, so wird anschließend überprüft, ob der
ermittelte Ähnlichkeitswert über dem Schwellwert für Elemente dieses Knotentyps
liegt (threshold). Ist das der Fall, so kommen die beiden untersuchten Knoten als Korrespondenz in Frage und werden einander zugeordnet, sofern nicht für einen der beiden Knoten ein höherer Ähnlichkeitswert mit einem anderen Knoten ermittelt wird.
Entsprechend der Bottom-up-Funktionsweise beim Vergleichsablauf werden die Kriterien zur Ermittlung der Knotenähnlichkeitswerte im Folgenden von den Blattknoten
hin zur Wurzel erklärt.
Für die Korrespondenzbildung bei Bindungsknoten ist neben dem Bindungsgrad
entscheidend, mit welchen Atomknoten diese verbunden sind. Durch die Einschränkung der Kandidaten mithilfe der CandidatesConfig ist bereits sichergestellt, dass
lediglich Bindungen miteinander verglichen werden, die über dieselbe Ordnung verfügen. Für die Ermittlung des Ähnlichkeitswerts ist der Bindungsgrad jedoch ebenfalls sinnvoll, da jede Bindung damit bereits zu Beginn eine gewisse Grundähnlichkeit zu anderen Bindungen besitzt, die bei der Betrachtung der Umgebung propagiert
werden kann. Für den Vergleich der verbundenen Atome kann die Funktion RemoteNodesMatchedOrSimilarIO() verwendet werden, die als Parameter den Kantenzug
erhält, der zu den zu vergleichenden Knoten führt. Die beiden Kriterien gehen mit
einem Anteil von jeweils 0,5 in die Ermittlung des Ähnlichkeitswerts ein. Setzt man
den Schwellwert für die Korrespondenzbildung bei Bindungen auf über 0,75, so müssen für einen Match der Bindung sowohl die Bindungsgrade vollständig übereinstimmen, als auch beide durch sie verbundenen Atome bereits sehr hohe Ähnlichkeitswerte aufweisen. Der Grundgedanke ist, sich ausgehend von anfangs wenigen
zugeordneten Atomen Schritt für Schritt strukturell durch den Graphen zu arbeiten.
Daher erscheint dieser Schwellwert zunächst zu restriktiv. Anhand eines Beispiels
lässt sich jedoch erläutern, warum eine Festlegung auf über 0,75 geeignet ist, um die
Wahrscheinlichkeit von ungünstigen Korrespondenzbildungen zu reduzieren. Denkbar wäre eine Situation, in der ein Atom aufgrund eines einzigartigen Elementtyps
direkt zugeordnet werden kann. Für alle Bindungen, außer der Bindung, über die dieses Atom mit einem anderen verbunden ist, würden die ermittelten Ähnlichkeitswerte
aufgrund der nicht-zugeordneten Zielknoten nicht über dem Schwellwert liegen. Diese eine Bindung erreicht beim Vergleich mit einer Bindung des anderen Graphen aufgrund des zugeordneten Atoms auf der einen Seite sowie eines Atoms auf der anderen
Seite, dessen Elementtyp ebenfalls für eine gewisse Grundähnlichkeit sorgt, einen
Ähnlichkeitswert oberhalb des Schwellwerts, wodurch diese Bindungen als Korrespondenz markiert werden können. Für das zweite Atom, das über diese Bindung mit
44
dem ursprünglich zugeordneten Element verbunden ist, ergibt sich jetzt die Situation,
dass es mit einer zugeordneten Kante in Verbindung steht. Wie diese Eigenschaft zur
iterativen Korrespondenzbildung des gesamten Graphen genutzt werden kann, wird
im Anschluss an die Erläuterung der Atom-Konfiguration deutlich.
Atomknoten müssen neben einem identischen Elementtyp auch mit den gleichen
anderen Atomen verbunden sein, um als Korrespondenz markiert zu werden. Häufig
tritt der Fall ein, dass aufgrund des Elementtyps allein keine eindeutige Entscheidung
getroffen werden kann, welchem Atom aus dem anderen Graphen ein Knoten zuzuordnen ist, weshalb die Umgebung des Atoms eine entscheidende Rolle spielt.
Atome können über eine unterschiedliche Anzahl an Bindungen verfügen, was die
Bestimmung einer idealen Gewichtung bezüglich der Überschreitung des Schwellwerts schwierig macht. Wäre die Umgebung das einzige Kriterium zur Ermittlung des
Ähnlichkeitswerts, so würde beispielsweise ein Schwellwert von 0.4 dafür sorgen,
dass ein Sauerstoffatom mit maximal zwei Bindungen schon zugeordnet werden
könnte, sobald auch nur eine Bindung zugeordnet wurde. Für Kohlenstoff mit maximal vier Bindungen wären dagegen schon zwei zugeordnete Bindungen erforderlich,
was mitunter nicht erreicht werden kann. Aus diesem Grund wird eine Mischung aus
Elementtyp- und Verbindungskantenübereinstimmung gewählt, durch die gewährleistet wird, dass ein Atom schon bei einer zugeordneten Verbindung, sofern nicht ein
anderes Atom einen höheren Ähnlichkeitswert erzielt, als Korrespondenz markiert
werden kann. In Anlehnung an das im Rahmen der Bindungsbeschreibung begonnene
Beispiel lässt sich die weitere Korrespondenzbildung nun fortführen. Für das mit der
zugeordneten Bindung verbundene Atom des ersten Graphen findet sich höchstens
ein Kandidat in dem anderen Graph, der den gleichen Elementtyp besitzt und ebenfalls mit einer bereits zugeordneten Bindung verbunden ist, wodurch der Schwellwert
für die Korrespondenzbildung überschritten wird und die Atome somit als Korrespondenz markiert werden können. Für die an diese Atome angrenzenden Bindungen
ergibt sich nun erneut die ursprüngliche Situation, mit einem zugeordneten Atom
verbunden zu sein, wodurch der Schwellwert auch für sie überschritten wird. Es können unter Umständen im nächsten Durchgang erneut Kanten und Atome einander
zugeordnet werden, die an bereits korrespondierende Elemente grenzen, wodurch
iterativ Schritt für Schritt ausgehend von dem ursprünglichen Match des ersten Atoms
der gesamte Graph zugeordnet werden kann.
Die den funktionellen Gruppen entsprechenden compound-Knoten liegen derart
auf der vorgelagerten Ebene des SiDiff-Graphen, dass die zugehörigen Atome und
Bindungen unter ihnen angeordnet sind. Einer der Hauptgründe für die Einführung
funktioneller Gruppen war die Überlegung, durch einen Match zweier Gruppen eine
Menge von Atomen und Bindungen automatisch zuordnen zu können, wodurch sich
ein Fixpunkt im Graph für den weiteren Vergleich ergeben würde. Jede funktionelle
Gruppe verfügt über einen eindeutigen Namen, so dass für den Vergleich dieser als
einziges Kriterium bereits ausreichend sein muss, damit zwei Gruppen als Korrespondenz markiert werden können. Der Namensvergleich erfolgt mithilfe der Funktion
45
StringAttributeUsingEqualsCS(). In Verbindung mit einer Option, die im Rahmen der
nachfolgend beschriebenen MatchingConfig dafür sorgt, dass bei einem Match zweier
Knoten deren Kindelemente exklusiv erneut verglichen werden, lässt sich über diese
Konfiguration durch eine Zuordnung der compound-Knoten die Menge der darunterliegenden Atome und Bindungen ebenfalls gegenseitig zuordnen. Beispielhaft für den
Einsatz der Gruppen-Zuordnung ist eine Situation denkbar, bei der in einem ersten
Vergleichsdurchlauf keine Atome und Bindungen eindeutig als Korrespondenz markiert werden können. In jedem der beiden verglichenen Moleküle existiert jedoch eine
funktionelle Gruppe mit demselben Namen, so dass diese einander zugeordnet werden können. Durch die Zuordnung der Gruppen-Knoten werden anschließend die
Atome und Bindungen innerhalb dieser Gruppen erneut miteinander verglichen, wobei jedoch lediglich die Elemente für den Vergleich in Frage kommen, die in dem
jeweils anderen Graphen ebenfalls unterhalb der zugeordneten Gruppe angeordnet
sind. Durch diese Reduktion der Kandidatenmenge können die Atome und Bindungen
der Gruppe zugeordnet und ausgehend von diesen Elementen die Graphen schrittweise iterativ weiter verglichen werden.
Selbst wenn die Gruppen mit identischem Namen einander zugeordnet werden
können und der Name ausreichend für eine Korrespondenzbildung ist, kann es dennoch vorkommen, dass keine eindeutige Zuordnung möglich ist. Dies ist beispielsweise dann der Fall, wenn eine Gruppe mehrfach in den zu vergleichenden Graphen
auftritt und somit, analog zu der Problematik bei der Atomzuordnung, denselben
Ähnlichkeitswert zu mehreren anderen Gruppen aufweist. Aus diesem Grund werden
neben dem Gruppennamen noch weitere Kriterien zur Ermittlung des Ähnlichkeitswerts herangezogen, wobei dieser nach wie vor zur Korrespondenzbildung ausreichend ist. Durch die Auswertung der unter der Gruppe angeordneten Atome und Bindungen kann diese auch dann einer anderen Gruppe zugeordnet werden, wenn aufgrund des Namens mehrere Kandidaten in Frage kämen. Dies soll im Folgenden anhand eines Beispiels erläutert werden. In dem einen Molekül ist eine Gruppe enthalten, die in dem anderen doppelt vorkommt, so dass aufgrund des Namens alleine keine eindeutige Zuordnung erfolgen kann. Aufgrund einiger einzigartiger Atomtypen
können manche Molekülatome einander zugeordnet werden, woraufhin iterativ ausgehend von diesen Korrespondenzen weitere Atome und Bindungen einander zugeordnet werden können. Sobald ein Atom oder eine Bindung unterhalb der Gruppe
durch diesen Prozess einem korrespondierenden Element zugeordnet wird, verändert
sich der Ähnlichkeitswert, den die Gruppe zu einer der beiden anderen hat, woraufhin
die Gruppen-Korrespondenzbildung vorgenommen werden kann. Für die Ermittlung
des Ähnlichkeitswerts für compound-Elemente ergibt sich nach diesen Überlegungen
eine Mischung aus der Ähnlichkeit des Namens der Gruppe, der Atom- sowie der
Bindungsmengen. Der Schwellwert ist so zu wählen, dass der Name für eine Korrespondenzbildung ausreichend ist und die Knotenmengen der darunter angeordneten
Elemente lediglich zu einem Unterschied der Ähnlichkeitswerte bei mehreren identischen Kandidaten führt.
46
Auf der obersten Ebene des SiDiff-Molekülgraphen liegt der Wurzelknoten vom
Typ model, unter dem alle funktionellen Gruppen liegen sowie die Gruppe derjenigen
Knoten, die in keiner funktionellen Gruppe enthalten sind. Der hier definierte
Schwellwert gibt somit an, wie hoch die Übereinstimmung der anderen Knoten sein
muss, damit zwei Moleküle als einander entsprechend angesehen werden. Diese Abhängigkeit von den darunterliegenden Knotenvergleichen wird im Konfigurationsskript dadurch ausgedrückt, dass für den Vergleich der model-Elemente die Ähnlichkeiten der Knotenmengen der funktionellen Gruppen (compounds) ermittelt werden
müssen und dann exklusiv zur Ermittlung des Ähnlichkeitswerts des Modells verwendet werden. Identische Moleküle erfordern eine vollständige Übereinstimmung
aller Atome, Bindungen und Gruppen, wodurch der Schwellwert für eine ModellÜbereinstimmung auch auf 1.0 gesetzt werden muss. Unterscheiden sich zwei Moleküle auch nur in einem dieser Elemente, so wird der model-Knoten nicht zugeordnet
und die Gesamtähnlichkeit von 1.0 kann nicht erreicht werden.
Die vorgenommenen Konfigurationen werden in Abbildung 5.4 anhand eines Auszugs der CompareConfig-Konfigurationsdatei dargestellt.
47
<Configurations>
<NodeType name="model">
<Configuration threshold="1.0"/>
<CompareFunctions>
<CompareFunction
class="OutgoingReferencesMatchedOrSimilarIO"
weight="1.0" parameter="compounds"/>
</CompareFunctions>
</NodeType>
<NodeType name="compound">
<CompareFunctions>
<CompareFunction
class="StringAttributeUsingEqualsCS"
weight="0.5" parameter="name"/>
<CompareFunction
weight="0.25" parameter="atoms"/>
<CompareFunction
weight="0.25" parameter="bonds"/>
</CompareFunctions>
</NodeType>
<NodeType name="atom">
<CompareFunctions>
<CompareFunction
weight="0.6" parameter="elementType"/>
<CompareFunction
class="RemoteNodesMatchedOrSimilarIO"
weight="0.4" parameter="I:target"/>
</CompareFunctions>
</NodeType>
<NodeType name="bond">
<CompareFunctions>
<CompareFunction
class="RemoteNodesMatchedOrSimilarIO"
weight="0.5" parameter="O:target"/>
<CompareFunction
weight="0.5" parameter="order"/>
</CompareFunctions>
</NodeType>
</Configurations>
Abbildung 5.4 Auszug der CompareConfig für den Vergleich molekularer Graphen
48
5.2.3 MatchingConfig
Die MatchingConfig steuert sowohl die Reihenfolge, in der die Elementtypen miteinander zu vergleichen sind, als auch Parameter, die für jeden Elementtyp angeben,
wie dieser im Kontext zu anderen Knoten zu bewerten ist. Darüber hinaus werden die
zu verwendenden Matching-Strategien spezifiziert. Entsprechend gliedert sich die
Datei in die drei Abschnitte Settings, MatchingConfigurations und CompareSequence, die im Folgenden anhand der vorgenommenen Anpassungen genauer beschrieben
werden.
Unter Settings lassen sich der Name des Dokumenttyps sowie die zu verwendenden Matching-Implementierungen spezifizieren. Dafür kann neben dem standardmäßigen iterativen Matcher auch ein zweiter Matcher angeben werden, der lediglich für
den ersten Durchlauf eingesetzt wird. Diese Trennung ist erforderlich, um in einem
ersten Durchlauf die sich durch direkte Knotenvergleiche eindeutig ergebenden Korrespondenzen zu markieren, während mit Hilfe des iterativen Matchers die Umgebungen der Knoten miteinbezogen werden. Für den Matching-Prozess molekularer
Graphen wird im ersten Durchlauf der UniqueSimilarityMatcher verwendet, der Knoten nur dann einander zuordnet, wenn ein Vergleich über ihre Attribute zu einer eindeutigen Zuordnung führt. Dies ist bei allen Knoten der Fall, die über ein einmalig
vorkommendes Attribut verfügen, beispielsweise beim Namen einer funktionellen
Gruppe, die nur ein einziges Mal im Graph vorkommt, oder einem Atom mit einem
Elementtyp, der kein weiteres Mal auftritt. Der iterative Standard-Matcher (DefaultMatcher) ermittelt im Anschluss die Ähnlichkeitswerte der Knoten unter Berücksichtigung der Knotenumgebung. Wie diese Umgebung auszuwerten ist und welche
Merkmale für die Ähnlichkeitswertermittlung herangezogen werden sollen, wird
durch die Konfigurationen der CompareConfig vorgegeben (vgl. Kapitel 5.2.2 ).
Innerhalb der MatchingConfigurations wird für jeden Knotentyp ein Eintrag erzeugt, der definiert, wie Instanzen des jeweiligen Typs in Relation zu anderen Knoten
zu behandeln sind. Über die Attribute der Knotentyp-Konfigurationen kann angegeben werden, ob die Reihenfolge der Elemente von Bedeutung ist, ob VerschiebeOperationen erlaubt sind und ob Knoten mit einem veränderten Matcher erneut verglichen werden sollen, sobald ihr Elternelement zugeordnet wurde. Da Gruppen,
Atome und Bindungen in einer beliebigen Reihenfolge definiert werden können,
spielt diese für die Ähnlichkeit keine Rolle und kann für alle vorkommenden Elemente mit „false“ deaktiviert werden. Mit moveAllowed lässt sich konfigurieren, ob Knoten des angegebenen Typs, die an einer bestimmten Stelle im ersten Graphen stehen,
im zweiten Graphen an einer anderen Stelle vorkommen und dennoch als Korrespondenz erkannt werden können. Diese Option ist besonders im Rahmen von Klassendiagrammen, in denen beispielsweise Klassen durch Vererbungshierarchien innerhalb
eines Graphs verschoben werden können, von Bedeutung. Da molekulare Graphen
dagegen eine vergleichsweise flache Struktur mit wenigen Ebenen aufweisen, in denen Atome und Bindungen lediglich unter Gruppen-Knoten liegen können, ist auch
49
diese Zusatzoption hier nicht erforderlich. Von besonderer Bedeutung für Molekülvergleiche ist die dritte Option parentForceMatch, mit deren Hilfe es ermöglicht
wird, durch einen Match einer funktionellen Gruppe alle zugehörigen Atome und
Bindungen ebenfalls zuzuordnen. Mit der Option wird vermerkt, dass Elemente dieses Typs erneut zu vergleichen sind, sobald der Elternknoten einem korrespondierenden Knoten zugeordnet wurde. Für den erneuten Vergleich wird jedoch die Kandidatenmenge dahingehend eingeschränkt, dass nur noch Knoten miteinander verglichen
werden, die in beiden Graphen unterhalb der zuvor gebildeten Korrespondenz liegen.
Durch diese verkleinerte Kandidatenmenge lassen sich die Atome und Bindungen der
einen Gruppe denen der anderen Gruppe zuordnen und es entsteht eine Menge von
Korrespondenzen, die genutzt werden kann, um weitere Elemente außerhalb der
Gruppe iterativ zuzuordnen. Der Eintrag parentForceMatch ist sowohl bei Atomen
als auch bei Bindungen auf „true“ zu setzen.
Innerhalb der CompareSequence wird schließlich die Reihenfolge definiert, in der
die Elementtypen zu vergleichen sind. Diese Reihenfolge sollte entsprechend des
Bottom-Up-Prinzips des Matchers von den Blättern hin zur Wurzel organisiert sein.
Da es sich hierbei um die Definition des iterativen Prozesses handelt, die also zeitlich
nach dem ersten Matcher genutzt wird, startet der Matchingvorgang mit den Bindungen, gefolgt von Atomen. Auf diese Weise werden in einem Durchlauf zunächst ausgehend von allen bereits zugeordneten Atomen weitere Bindungen zugeordnet, gefolgt von weiteren Atomen. Da funktionelle Gruppen derzeit lediglich in einem ersten
Durchlauf von Bedeutung sind, um die in ihnen enthaltenen Atome und Bindungen
zuzuordnen, ist ein erneuter Vergleich dieser Knoten lediglich erforderlich, um aufgrund von möglicherweise zuvor vorgenommenen Korrespondenzbildungen bei
Atomen oder Bindungen der Gruppe einen veränderten Ähnlichkeitswert zu ermitteln. Hat sich dieser verändert, so kann die Gruppe unter mehreren Kandidaten jetzt
eindeutig zugeordnet werden. Als Letztes wird schließlich der „model“-Knoten verglichen, unter dem alle anderen Knoten angeordnet sind. Wie bereits in Kapitel 3.1
beschrieben, läuft dieser iterative Prozess mehrere Male komplett über den Graphen,
bis keine zusätzlichen Korrespondenzen mehr entdeckt werden. Abbildung 5.5 zeigt
anhand eines Auszugs aus der MatchingConfig die vorgenommenen Konfigurationen.
50
5.3 Integration der Gruppenmarkierung
<IterativeMatching>
<Settings documentType="MoleculeModel"
firstPassMatcher="UniqueSimilarityMatcher"
iterativeMatcher="DefaultMatcher" />
<MatchingConfigurations>
<NodeType name="model">
<Configuration ordered="false" moveAllowed="false"
parentForceMatch="false"/>
</NodeType>
<NodeType name="compound">
parentForceMatch="false"/>
</NodeType>
<NodeType name="atom">
parentForceMatch="true"/>
</NodeType>
<NodeType name="bond">
parentForceMatch="true"/>
</NodeType>
</MatchingConfigurations>
<CompareSequence>
<Item name="bond"/>
<Item name="atom"/>
<Item name="compound"/>
<Item name="model"/>
</CompareSequence>
</IterativeMatching>
Abbildung 5.5 Auszug aus MatchingConfig für den Vergleich molekularer Graphen
Die mithilfe der hier vorgestellten Konfigurationen durchgeführten Tests werden
im folgenden Kapitel beschrieben und ausgewertet. Dabei werden auch alternative
Konfigurationen bezüglich Gewichtungen, Schwellwerten und Matching-Parametern
berücksichtigt.
Um zwei molekulare Graphen in der zuvor beschriebenen Art und Weise zu vergleichen ist es erforderlich, zunächst die Komponente zur Markierung funktioneller
Gruppen zu integrieren. Dazu werden hauptsächlich zwei Funktionen benötigt: zum
einen die Markierung des gesamten Datenbestands, mit dem anschließend das Anfragemolekül zu vergleichen ist, zum anderen die Markierung des Anfragemoleküls
selbst.
Die Markierung des Datenbestands ist dadurch gekennzeichnet, dass sie nur ein
einziges Mal durchgeführt werden muss. Da sich der Katalog mit verwendeten funk-
51
tionellen Gruppen nicht ständig verändert und somit auch keine häufige Anpassung
der gesamten Datenbasis zu erfolgen hat, spielt die Laufzeit nur eine untergeordnete
Rolle. Die Problematik, den gesamten Datenbestand zu markieren, lässt sich zurückführen auf die wiederholte Markierung eines einzelnen Moleküls, die im nächsten
Abschnitt beschrieben wird. Daher erfordert die Integration der Datenbankmarkierung lediglich eine Schnittstellenfunktion, die iterative Markierungsaufrufe kapselt.
Neben einem entsprechenden Konstruktor, über den Quell- und Zielverzeichnis der
Datenbasis sowie das Verzeichnis der Musterdefinitionsdatei spezifiziert werden,
können mithilfe der Funktion markMolecules() die in den Verzeichnissen liegenden
CML-Dateien eingelesen, markiert und gespeichert werden. Da diese Markierung
gesondert vom eigentlichen Vergleichsvorgang durchgeführt werden kann, ist eine
Integration in den Vergleichsprozess nicht erforderlich.
Für die Markierung des Anfragemoleküls, also eines einzelnen Dokuments, werden ähnliche Schnittstellen angeboten, wie bereits zuvor beschrieben. Auch hier werden Quell- und Zielverzeichnis sowie die Musterdefinitionsdatei angegeben, um anschließend durch die Funktion markMolecule() die Markierung vorzunehmen. Im
Unterschied zur Datenbankmarkierung ist dieser Schritt jedoch zu Beginn des Vergleichsvorgangs auszuführen und somit laufzeitkritisch. Zu Beginn des Vergleichsablaufs wird das unmarkierte Molekül eingelesen, markiert und zurückgespeichert. Damit steht es mit markierten funktionellen Gruppen für den anschließenden Vergleichsprozess zur Verfügung und wird vom SiDiff-Algorithmus entsprechend der
erstellten Konfigurationsdateien mit jeweils einem anderen Molekül verglichen.
Anstatt jedesmal das Anfrage- sowie das nächste zu vergleichende Molekül laden
zu müssen, erlaubt es der SiDiff-Algorithmus mithilfe eines Graph-Repositories
gleich mehrere Graphen zu laden und anschließend beliebig untereinander zu vergleichen. Dadurch wird es möglich, das Anfragemolekül an der ersten Position des Repositories zu speichern und anschließend das Repository mit Datenbank-Molekülen aufzufüllen. Die maximale Größe dieses Repositories ist von der Hauptspeichergröße
abhängig, so dass ab einer bestimmten Anzahl an Graphen eine Neuinitialisierung
erforderlich wird. Dies erfordert eine Speicherung der Vergleichsergebnisse zwischen
den Bearbeitungsgängen der einzelnen Repository-Füllungen und eine anschließende
Zusammenführung.
Für den vollständig integrierten Programmablauf ergibt sich somit zunächst eine
Markierung des Anfragemoleküls. Anschließend werden die erforderlichen SiDiffKomponenten mit den zugehörigen Konfigurationsdateien initialisiert und das Anfragemolekül sowie die zuvor markierten Datenbankmoleküle in das Graph-Repository
geladen. Für jeden Vergleich des Anfragemoleküls mit einem Datenbankmolekül
wird das SiDiff-Ergebnis absteigend so gespeichert, dass sich bereits ein Ranking
entsprechend der Ähnlichkeiten ergibt. Umfasst die Datenbank mehr Moleküle, als
das Repository speichern kann, so wird dieses bei Erreichen der Grenzwerte neu initialisiert und mit den nächsten Molekülen gefüllt. Wurde mit allen Datenbankmolekülen verglichen, werden die Ähnlichsten mit dem zugehörigen Ähnlichkeitswert in der
52
5.4 Verwendete Ähnlichkeitsmetriken
Konsole sowie in einer Textdatei ausgegeben. Aus Laufzeitgründen werden während
des Vergleichsablaufs die genauen Knotenzuordnungen nicht in die Konsole geschrieben. Wird neben dem ermittelten Ähnlichkeitswert auch die genau Knotenzuordnung benötigt, so ist es erforderlich, im Anschluss an den Vergleich eine erneute
Anfrage mit dem Anfragemolekül und dem jeweiligen Datenbankmolekül zu starten,
die dann sämtliche ermittelten Informationen auf der Konsole sowie in einer Textdatei ausgibt.
Als Grundlage für sämtliche Ähnlichkeitsbetrachtungen dienen die mithilfe des SiDiff-Algorithmus ermittelten Korrespondenzen sowie Differenzen mit den zugehörigen Knoten-Ähnlichkeitswerten. Wie bereits in Kapitel 3.1 beschrieben, unterscheidet
der SiDiff-Algorithmus zwischen strukturellen Unterschieden (Structural) und Unterschieden, die sich daraus ergeben, dass sich die Attribute eines Knotens geändert haben (Update) oder daraus, dass der Knoten an einer anderen Stelle im Diagramm auftritt (Move). Während die letzten beiden Unterschiede eine KnotenKorrespondenzbildung möglich machen, sorgen strukturelle Unterschiede dafür, dass
Knoten in beiden Graphen keine Entsprechung in dem jeweils anderen Graphen haben. Für die Ermittlung von Molekül-Ähnlichkeitswerten können neben der Anzahl
der zugeordneten und nicht-zugeordneten Knoten auch die Ähnlichkeitswerte verwendet werden, die durch den Algorithmus für ein Paar von Knoten ermittelt wurden,
auch wenn diese nicht als korrespondierend erkannt wurden. Zunächst soll das von
SiDiff verwendete Verfahren zur Bestimmung des Ähnlichkeitswerts für zwei molekulare Graphen kurz beschrieben werden, bevor ein alternativer, auf den SiDiffMetriken basierender Ansatz vorgestellt wird.
Der von SiDiff ermittelte Ähnlichkeitswert für zwei vollständige Graphen berechnet sich aus dem Verhältnis zwischen zugeordneten und nicht-zugeordneten Knoten.
Somit verringert sich der Ähnlichkeitswert mit jedem Knoten, zu dem im anderen
Graphen keine Korrespondenz gefunden werden kann. Korrespondenz-Knoten gehen
anteilig mit dem für sie ermittelten Ähnlichkeitswert in die Gesamtähnlichkeit ein.
Auf diese Art fließt nicht nur die strukturelle Ähnlichkeit zweier Graphen in den
Ähnlichkeitswert ein, sondern auch die genaue Ähnlichkeit der Korrespondenzen,
was sehr differenzierte Aussagen über den Anteil neuer oder veränderter Knoten ermöglicht.
Molekulare Graphen sind dadurch gekennzeichnet, dass mit den Knoten für funktionelle Gruppen und dem Knoten für Nicht-Gruppenelemente mehrere zur Unterstützung der Korrespondenzbildung künstlich angelegte Knoten im Graphen enthalten
sind. Etwas problematisch wird diese Eigenschaft, wenn zwei Moleküle miteinander
verglichen werden, die sich strukturell zwar sehr ähnlich sind, jedoch insoweit unterscheiden, dass sie über unterschiedliche funktionelle Gruppen verfügen. Beide Gra-
53
phen umfassen damit eine Reihe von Gruppen-Knoten, zu denen keine Korrespondenzen ermittelt werden können, was den Gesamtähnlichkeitswert verringert, selbst
wenn die meisten Atome und Bindungen einander aufgrund der sehr ähnlichen Struktur zugeordnet werden können (vgl. Abbildung 5.6B). In diesem Fall könnte ohne die
Gruppenmarkierung ein höherer Ähnlichkeitswert erzielt werden, was die strukturelle
Ähnlichkeit der beiden Graphen stärker zum Ausdruck bringen würde. Betrachtet
man diese Problematik jedoch unter chemischen Gesichtspunkten und unter Berücksichtigung der Tatsache, dass gerade die funktionellen Gruppen für Reaktionsprofile
von besonderer Bedeutung sind, so kann eine verringerte Ähnlichkeit aufgrund unterschiedlicher Gruppen durchaus wünschenswert sein.
Abbildung 5.6 Markierte Strukturen für Vergleich
Von besonderer Bedeutung ist die Problematik der Korrespondenzbildung bei
Strukturen, die ausgehend vom letzten zugeordneten Knoten in zwei oder mehr vollkommen identische Teilgraphen verzweigen. Da mithilfe des SiDiff-Algorithmus für
jeden der angrenzenden Knoten jeweils zwei oder mehr Kandidaten mit einem identischen Ähnlichkeitswert ermittelt werden, kann keine eindeutige Korrespondenzbildung erfolgen und somit bleiben diese Knoten nicht-zugeordnet, was den Ähnlichkeitswert reduziert. Dies führt dazu, dass vor allem der Vergleich völlig identischer
symmetrischer Strukturen zu einem geringeren Ähnlichkeitswert führen kann, obwohl
die Identität festgestellt werden müsste (vgl. Abbildung 5.6A). In diesem Fall wäre
eine beliebige Korrespondenzbildung eine mögliche Problemlösung, die jedoch von
der derzeitigen SiDiff-Version nicht unterstützt wird.
Um dieser Problematik entgegen zu wirken, wurde ein Verfahren entwickelt, mit
dem ein alternativer Ähnlichkeitswert ermittelt werden kann. Ausgehend von dem mit
SiDiff berechneten Ähnlichkeitswert für zwei molekulare Graphen wird die Restmenge der Knoten, zu denen keine Korrespondenzen ermittelt werden konnten, weiter
ausgewertet. Für jedes nicht-zugeordnete Atom wird zunächst überprüft, ob mindestens zwei Kandidaten mit einem identischen Ähnlichkeitswert existieren. Ist das der
Fall, so wird es dem ersten Kandidaten zugeordnet und die beiden Atome, nun als
Korrespondenz markiert, werden aus der Restmenge entfernt. Anders als mithilfe des
SiDiff-Algorithmus werden hierbei als einzige Kriterien die Ähnlichkeitswerte sowie
die Elementtypen der Atome betrachtet. Wurden alle Atome abgearbeitet, werden
54
anschließend die Bindungen analog betrachtet, wobei neben den Ähnlichkeitswerten
die Bindungsgrade in die Betrachtungen miteinbezogen werden. Nicht-zugeordnete
Gruppenknoten werden aufgrund der oben beschriebenen und in Abbildung 5.6B dargestellten Problematik aus der Berechnung des Ähnlichkeitswerts herausgenommen.
Nach Abschluss dieser Korrespondenzbildung aus der Restmenge korrespondenzloser
Knoten wird der neue Ähnlichkeitswert berechnet, diesmal lediglich aus dem Verhältnis zugeordneter und nicht-zugeordneter Knoten. Durch den Bezug zur KnotenRestmenge wird dieses Ähnlichkeitsmaß im Folgenden Set-Ähnlichkeit genannt.
Durch Einsatz dieses Verfahrens lässt sich besonders für symmetrische Strukturen
Identität mit einem Ähnlichkeitswert von 1,0 kennzeichnen, wie für die in Abbildung
5.6A dargestellte Vergleichssituation. Auch für unterschiedliche Graphen, die über
identische Teilbäume verfügen, lässt sich mit dem beschriebenen Verfahren der ermittelte Ähnlichkeitswert nach oben korrigieren. Dabei sind jedoch zwei Dinge zu
beachten: zum Einen handelt es sich bei dem vorgestellten Verfahren um einen rein
mengenmäßigen Ansatz, der den strukturellen Aufbau des Graphen nicht berücksichtigt und somit auch keine Topologie-erhaltende Korrespondenzbildung vornehmen
kann. Der alternative Ähnlichkeitswert stellt damit einen Indikator dar, der auf eine
mögliche Identität und symmetrische Strukturen hinweisen kann, diese jedoch auf
keinen Fall garantiert. Zum Anderen erhöht sich die Fehlerrate bei der Ermittlung
ähnlicher Strukturen, da bei einer rein mengenmäßigen Betrachtung der Knotenrestmenge deutlich mehr Moleküle eine ähnliche Menge aufweisen, als unter zusätzlicher
Berücksichtigung der Topologie. Somit werden auch Moleküle mit einer hohen Ähnlichkeit eingestuft, die zufällig die gleiche Menge an Atomen und Bindungen haben,
sich strukturell jedoch unterscheiden. Aus diesen Gründen ist der alternative Ähnlichkeitswert lediglich als eine Ergänzung zu der mit SiDiff ermittelten Ähnlichkeit
zu verwenden. Verfügt das Anfragemolekül über symmetrische Teilstrukturen, so
kann der Alternativwert im Anschluss an die mit SiDiff ermittelte Ähnlichkeit berechnet werden. Für die Sortierung der Ergebnisse ist dann eine Kombination aus
SiDiff- und mengenmäßiger Ähnlichkeit denkbar, wobei das Verhältnis über einen
Parameter gesteuert werden kann.
Die mithilfe der hier beschriebenen Verfahren durchgeführten Tests werden im
nächsten Kapitel beschrieben und analysiert. Dabei werden unterschiedliche Konfigurationen und Kombinationen aus SiDiff-Ähnlichkeitswert und dem alternativ ermittelten Ähnlichkeitswert getestet.
55
6 Ergebnisse
Die vorgenommenen Anpassungen für den Vergleich molekularer Graphen erfordern
hauptsächlich in den Bereichen der Markierung funktioneller Gruppen sowie des eigentlichen Vergleichs der Graphen umfangreiche Tests. Dazu sind zunächst die Testumgebung und der zu verwendende Testdatenbestand zu spezifizieren, bevor die vorzunehmenden Testläufe beschrieben, durchgeführt und ausgewertet werden.
Zur Markierung funktioneller Gruppen ist die Korrektheit der Gruppenmarkierung
in einem ersten Schritt an einzelnen Molekülen zu überprüfen, gefolgt von Laufzeitbetrachtungen für die Markierung des gesamten Datenbestands. Für den Vergleich
der markierten Graphen wird analog zunächst anhand verschiedener Tests die Vergleichsgenauigkeit für zwei Graphen untersucht, wobei verschiedene Schwellwerte
und Gewichtungen ebenso überprüft werden wie die Aussagekraft der verwendeten
Ähnlichkeitsmetriken. Anschließend erfolgt der Vergleichstest eines Moleküls mit
dem gesamten Datenbestand, wobei nicht nur die Laufzeit, sondern auch das ermittelte Ranking für die Vergleichsergebnisse ausgewertet wird.
Die ermittelten Ergebnisse werden anschließend evaluiert und es wird überprüft,
inwieweit mit Hilfe des SiDiff-Algorithmus molekulare Graphen mit einer akzeptablen Präzision und Korrektheit verglichen werden können. Darüber hinaus ist festzustellen, ob auch große Datenbestände mit vertretbarem Aufwand durchsucht und verglichen werden können.
6.1 Testumgebung
Die im Folgenden vorgenommenen Tests werden zunächst auf einem Intel Pentium
M Prozessor mit 1,87 GHz und 1GB Arbeitsspeicher durchgeführt. Der auf 1GB beschränkte Arbeitsspeicher führt dazu, dass gerade die Neuinitialisierung des GraphRepository häufig durchgeführt werden muss. Zum Vergleich der Laufzeit werden
daher alle vorgestellten Tests abschließend auf einem Testsystem mit 2GB Arbeitsspeicher durchgeführt.
6.2 Testdatenbestand
Es existieren eine ganze Reihe kommerzieller sowie frei zugänglicher Datenbanken
im Internet, die biochemische Informationen aus den verschiedensten Anwendungsbereichen beinhalten. [Pol07] ordnet die Datenbanken entsprechend der in ihnen gespeicherten Datenbestände in die Hauptbereiche Genetik, Proteomik und Medizin und
56
6.2 Testdatenbestand
nennt darüber hinaus Datenbanken, die spezielle Gen-Ausdrücke13, Ontologien14 sowie genetische und proteomische Pfade15 enthalten.
Für den im Rahmen dieser Diplomarbeit durchzuführenden Molekülvergleich sind
Datenbestände erforderlich, die strukturelle Molekülinformationen enthalten, wie sie
häufig in proteomischen und medizinischen Datenbanken vorkommen (vgl.
[Mod08]). Die meisten aufgeführten Internetportale verfügen über eine zum Teil sehr
umfangreiche Schnittstelle, mit deren Hilfe detailliert Struktursuchen auf den angebundenen Datenbanken möglich sind. Besonders die Suche über PubChem, die
NCBI-Schnittstelle (National Center for Biotechnology Information) (vgl. [Pub08]),
ermöglicht umfangreiche Konfigurationen sowie die Möglichkeit, molekulare Strukturen über einen eingebauten Editor direkt zu zeichnen und anschließend als Anfrage
an die angebundenen Datenbanken zu senden. Problematisch zu sehen ist die Größe
der Datenbanken, die mit einem Gesamtdatenbestand von mehreren Millionen Molekülen für einfache Testreihen zu umfangreich sind, sowie die häufig fehlende Möglichkeit, die Datenbankinhalte direkt herunterladen zu können.
Das NCI (National Cancer Institute), speziell die Unterabteilung CADD-Group
(Computer Aided Drug Design), die Datenbestände sowie Software und Tools zu
deren Bearbeitung frei zur Verfügung stellt, bietet ebenfalls eine Schnittstelle, über
die molekulare Struktursuchen durchgeführt werden können. Über diese Schnittstelle
lassen sich derzeit Anfragestrukturen mit etwa 40 Millionen einzigartigen Einträgen
aus über 100 Datenbanken vergleichen (vgl. [Che082]). Neben dieser Struktursuche
kann über deren Webseite eine Datenbank im MOL-Format heruntergeladen werden,
die mit einem Datenbestand von 260.071 Molekülen auf dem Stand von September
2003 eine recht große Anzahl an Teststrukturen bietet (vgl. [Dow08]). Die eingetragenen Molekülstrukturen enthalten alle benötigten Informationen über Elementtypen
und Bindungen sowie einige zusätzliche Daten über die Molekülzusammensetzung
und weitere Identifizierer. Durch die Möglichkeit, MOL-Dateien mit OpenBabel in
CML-Dateien konvertieren zu können, ist dieser Datenbestand für die folgenden
Testläufe gut geeignet. Um Aussagen über die Einsatzfähigkeit, Genauigkeit sowie
die Laufzeit des SiDiff-Algorithmus zu treffen, ist eine Untersuchung des gesamten
Datenbestands jedoch nicht erforderlich, so dass lediglich ein Ausschnitt von maximal 10.000 Molekülen pro Vergleich zum Einsatz kommt. Abbildung 6.1 zeigt eine
strukturelle Analyse des zu untersuchenden Datenbestands. Es zeigt sich, dass die
meisten Moleküle eine Größe im Bereich von 15 bis 35 Atomen aufweisen (60,82%).
Im Bereich von 36 bis 55 Atomen (20,97%) liegt ebenfalls ein relativ großer Datenbestand, während kleine Moleküle mit 1 bis 14 Atomen (8,45%) und sehr große mit
56 bis 230 Atomen (9,76%) verhältnismäßig selten auftreten. Für die folgenden Un13
Gene expression: Informationen über den Zusammenhang zwischen DNA-Abschnitten und den
ausgeprägten Merkmalen, wie beispielsweise gebildeten Proteinen (vgl. [Pol07])
14
Ontology: Spezifikation eines relationalen Vokabulars mit hierarchisch geordneten Fachbegriffen, hier biochemischen (vgl. [Gen081])
15
Molekulare Interaktions- und Reaktionsnetzwerke (vgl. [KEG08])
57
6.3 Testläufe
tersuchungen werden die Moleküle daher in die Kategorien sehr klein (1-14 Atome),
klein (15-25 Atome), mittel (26-35 Atome), groß (36-55 Atome) und sehr groß (56230 Atome) eingeteilt.
400
350
300
250
200
150
100
50
0
1
6
11
16
21
26
31
36
41
46
51
56
61
66
71
76
81
86
91
96
101
106
111
116
121
126
Anzahl Moleküle im Datenbestand
Molekülverteilung im Datenbestand
Anzahl Atome in Molekül
Abbildung 6.1 Zusammensetzung des Datenbestands bezüglich Größe und Anzahl der Moleküle
6.3 Testläufe
Die beiden zu testenden Bereiche umfassen zum einen die Markierung der funktionellen Gruppen, zum anderen den mit SiDiff durchgeführten Vergleich der markierten
molekularen Graphen.
Für die Gruppenmarkierung werden zunächst Tests zur Sicherstellung der Korrektheit der Markierung anhand von selbstdefinierten Beispielstrukturen vorgenommen,
die ausgewählte potenzielle Problemstrukturen darstellen. In einem zweiten Schritt
werden anschließend zufällige Moleküle des Datenbestands markiert und auf Korrektheit überprüft. Im Rahmen des abschließenden Tests zur Markierung des gesamten
Datenbestands rückt die Laufzeit in den Fokus, während die Korrektheit nur noch
anhand einzelner Stichproben untersucht wird.
Zum Vergleich der markierten molekularen Graphen werden analog zunächst einfache selbsterstellte Beispielgraphen verwendet, um die Korrektheit der Knotenzuordnungen für mögliche Problemstrukturen zu testen. Anschließend werden auch hier
reale, im Datenbestand vorkommende, Beispielmoleküle miteinander verglichen. Der
Fokus der Untersuchungen liegt dabei auf gebildeten Knotenzuordnungen und der
Aussagekraft der ermittelten Ähnlichkeitswerte. Für den Vergleich des Anfragemoleküls mit Molekülen des Datenbestands werden Laufzeit und Genauigkeit des Ver-
58
6.3 Testläufe
gleichs untersucht, wobei Letztere anhand der ermittelten ähnlichsten Moleküle überprüft wird. Im Rahmen dieser Untersuchungen werden auch die Auswirkungen der
verschiedenen Ähnlichkeitsmetriken auf das Ranking der ähnlichsten Moleküle getestet, um die vorteilhafteste Konfiguration zu ermitteln.
6.3.1 Markierung funktioneller Gruppen
Zur Sicherstellung der Korrektheit der Markierung funktioneller Gruppen werden die
Tests zunächst an einfachen Strukturen sowohl der Musterdefinitionen, als auch der
Moleküle selbst, durchgeführt. Als Musterdefinitionen werden kleine, azyklische
Atomgruppierungen von nicht mehr als vier Atomen verwendet. Die Moleküle umfassen maximal zehn Atome und sind ebenfalls zyklenfrei. In dieser ersten Phase wird
auf Wildcard-Elemente in den Musterdefinitionen verzichtet. Die verwendeten Musterdefinitionen und Moleküle zusammen mit den resultierenden Gruppenmarkierungen werden im Anhang aufgeführt und entsprechen vollständig den Erwartungen.
In der zweiten Phase werden zunächst selbstdefinierte Moleküle in die Testmenge
aufgenommen, die über Zyklen verfügen, gefolgt von zyklischen Mustern. Auch auf
diesen Strukturen erfolgt die Gruppenmarkierung entsprechend der Erwartungen. Es
wird deutlich, dass mit zunehmender Anzahl und Komplexität der Strukturen die
Reihenfolge, in der die Muster in der Konfigurationsdatei angeordnet werden, von
großer Bedeutung für den Markierungsprozess ist. Innerhalb der Gruppen der Startatome sind die komplexen Muster, die über die höchste Aussagekraft verfügen, als
erstes zu definieren, damit diese auch als erstes auf dem Molekül getestet und, falls
vorhanden, markiert werden. Werden die Muster entsprechend ihrer Komplexität angeordnet, so ergibt sich in Verbindung mit Morgans Algorithmus ein korrekter Ablauf sowohl für die Reihenfolge, in der die Startatome im Molekül besucht werden,
als auch für die Reihenfolge, in der die Muster getestet werden. Als abschließende
Betrachtung dieser Phase werden Muster hinzugefügt, die über Wildcard-Elemente
verfügen.
Nachdem die Korrektheit der Gruppenmarkierung für selbstdefinierte Beispielstrukturen verifiziert wurde, werden anschließend Moleküle des tatsächlichen Datenbestands ausgewählt und mit dem geplanten Musterkatalog funktioneller Gruppen
bearbeitet. Aufgrund der großen Anzahl an Molekülen im Datenbestand erfolgt diese
Auswahl zufällig. Die Ergebnismarkierungen der betrachteten Moleküle werden im
Anhang aufgeführt. Bei deren Auswertung fällt auf, dass gerade um die seltener auftretenden Atomtypen Schwefel, Phosphor, Stickstoff und Sauerstoff häufig Gruppen
markiert werden können, da diese mit höherer Priorität zu Beginn besucht werden. Zu
diesen Gruppen zählen häufig auch Kohlenstoffatome, die als Teil der Gruppe markiert werden und somit für den weiteren Gruppenfindungsprozess keine weitere Relevanz besitzen. Diese Kohlenstoffatome sind häufig jedoch Teil eines Kohlenstoffrings, der durch die Markierung des Atoms zu einer anderen Gruppe im Folgenden
nicht mehr erkannt werden kann. Diese Markierung ist unter der Annahme, dass
59
6.3 Testläufe
Gruppen mit Schwefel, Phosphor, Stickstoff und Sauerstoff unter chemischen Reaktionsgesichtspunkten von besonderer Bedeutung sind, vollkommen korrekt. Unter dem
Aspekt, mithilfe der Gruppenmarkierung möglichst aussagekräftige Substrukturen für
den anschließenden Vergleichsvorgang zu markieren, erscheint die Hervorhebung
eines Kohlenstoffrings ebenfalls lohnenswert. Wie sich im Rahmen der Tests zum
Vergleich der markierten Moleküle zeigen wird, ist die derzeitige Rangfolge der Prioritäten durchaus geeignet, um die für den Vergleichsvorgang benötigten Fixpunkte zu
ermitteln. Es sei an dieser Stelle nur darauf hingewiesen, dass durch eine Umgestaltung des Algorithmus und durch die Möglichkeit, polyzyklische Kohlenstoffmuster
über Mustern mit den selteneren Atomtypen einzuordnen, einige weitere sehr aussagekräftige Strukturen markiert werden könnten.
Als abschließende Testphase erfolgt die Markierung des Datenbestands, wobei in
dieser Phase Laufzeitbetrachtungen in den Mittelpunkt rücken und die Korrektheit
der Markierung nur noch anhand von Stichproben überprüft wird. Die Menge der
markierten Moleküle wird in jeder Serie von Testläufen um 1.000 Moleküle erweitert,
bis zu einer im Rahmen dieser Diplomarbeit bearbeiteten Menge von 10.000 Strukturen. Wie anhand der Testergebnisse deutlich wird, nimmt der zeitliche Aufwand für
die Markierung linear zu, für jeweils 1.000 weitere Moleküle um etwa 11 Sekunden
(vgl. Abbildung 6.2). Damit wäre eine Markierung des gesamten Datenbestands von
ca. 260.000 Molekülen in etwa 50 Minuten möglich. Da diese Markierung für die
gesamte Datenbank nur ein einziges Mal zu erfolgen hat und anschließend lediglich
dann erneut durchzuführen ist, wenn die eingesetzten Gruppenmuster geändert werden, ist dieser Aufwand durchaus akzeptabel. Für die Markierung des Anfragemoleküls ergibt sich eine Laufzeit abhängig von der Größe des zu markierenden Moleküls,
also der enthaltenen Atome und Kanten, sowie der enthaltenen Gruppen. Abbildung
6.3 zeigt die gemessenen Mittelwerte der Laufzeiten für die Markierung der Moleküle, geordnet nach den in Kapitel 6.2 definierten Größenordnungen. Es lässt sich feststellen, dass mittlere bis große Moleküle, die den Großteil des Datenbestands ausmachen, mit einem Zeitaufwand zwischen 16 ms und 29 ms ausgesprochen schnell markiert werden können. Selbst eine Markierung sehr großer Strukturen kann im Mittel
in weniger als 50ms vorgenommen werden. Da die Markierung des Anfragemoleküls
zu Beginn des Vergleichsablaufs zu erfolgen hat, fließt dieser zeitliche Aufwand in
die Gesamtlaufzeit des Vergleichsalgorithmus ein. In Relation zu der Laufzeit des
Vergleichsvorgangs mit dem gesamten Datenbestand stellt der Markierungsaufwand
für die Anfragestruktur jedoch einen verschwindend geringen Anteil dar und liegt
somit in einem akzeptablen Bereich.
60
6.3 Testläufe
Aufwand zur Markierung des
Datenbestands
120
Zeit (in s)
100
80
60
40
Mittlere Laufzeit
20
0
Anzahl markierter Moleküle
Abbildung 6.2 Zeitaufwand zur Markierung des Datenbestands
Aufwand zur Molekülmarkierung
60
Laufzeit (in ms)
50
40
30
Mittlere Laufzeit
20
10
0
sehr klein
klein
mittel
groß
sehr groß
Molekülgröße
Abbildung 6.3 Zeitaufwand zur Markierung einzelner Moleküle in Abhängigkeit von Molekülgröße
6.3.2 Vergleich molekularer Graphen
Die Testläufe zum Vergleich der markierten Moleküle werden ebenfalls in mehreren
Phasen organisiert. Zunächst wird anhand einfacher, zyklenfreier Beispielmoleküle
ohne funktionelle Gruppen der reine Atom- und Bindungsvergleich überprüft. Die
verwendeten Beispielmoleküle umfassen maximal zehn Atome, wobei die vorkommenden Elementtypen teilweise mehrfach in jedem Molekül enthalten sind, um die
61
6.3 Testläufe
Matching-Problematik bei Mehrdeutigkeit hervorzurufen. Bei den Tests fällt auf, dass
zyklenfreie Strukturen, bei denen mindestens ein Atom gleich zu Beginn eindeutig als
Korrespondenz markiert werden kann, bis auf die tatsächlichen Unterschiede eindeutig zugeordnet werden können. Liegen hinter den verschiedenen Atomen noch weitere Verkettungen, so können diese aufgrund der Umgebungsbetrachtung bei der Ähnlichkeitswertermittlung ebenfalls einander zugeordnet werden. Problematisch sind
lediglich spiegelbildliche Strukturen, bei denen keine eindeutige Entscheidung getroffen werden kann, welcher Teilgraph des einen Moleküls auf welchen Teilgraph des
anderen abzubilden ist (vgl. Abbildung 3.3). In einem zweiten Schritt wird die Molekülmenge um selbstdefinierte Moleküle erweitert, die Zyklen enthalten. Bei den Tests
lässt sich feststellen, dass eindeutige Merkmale innerhalb des Zyklus, oder Verbindungen nach außen innerhalb von Zyklen mit einem geraden Grad an Knoten dazu
führen, dass der gesamte Zyklus zugeordnet werden kann. Enthält der Zyklus dagegen eine spiegelbildliche Anordnung mit einer Spiegelachse durch die ermittelten
Fixpunkte, so können keine eindeutigen Korrespondenzen gebildet werden.
In der zweiten Phase werden die Moleküle mit einfachen funktionellen Gruppen
angereichert. Der Test umfasst die beiden Konfigurationen mit und ohne die Option
parentForceMatch. Werden die Gruppen ohne parentForceMatch verglichen, so erfolgt keine zusätzliche Überprüfung der Atome und Bindungen, die unter ihnen angeordnet sind, was dazu führt, dass keine zusätzlichen Elemente als Korrespondenzen
markiert werden können. Es werden ausschließlich die eindeutig entscheidbaren
Atome markiert sowie die eindeutig abbildbaren Gruppen-Oberknoten, jedoch nicht
deren Kindelemente, die Atom- und Bindungsknoten. Somit wird durch diese Konfiguration keine Verbesserung erzielt. Die Konfiguration mit parentForceMatch führt
dagegen dazu, dass bei einem Match der funktionellen Gruppen die Kindelemente
erneut verglichen werden, diesmal jedoch mit eingeschränkter Kandidatenmenge, da
nur die Kindelemente der Gruppenknoten verglichen werden müssen. Dies führt dazu, dass die Atome und Bindungen innerhalb der Gruppen zugeordnet werden können. Ausgehend von diesen Korrespondenzen kann der Rest des Graphen nach und
nach durch die Umgebungsbetrachtung, bis auf die sich unterscheidenden Knoten,
zugeordnet werden. Aufgrund dieser Ergebnisse wird für die folgenden Betrachtungen ausschließlich die Konfiguration mit der Option parentForceMatch verwendet.
Ein weiterer Vorteil dieser Option ist, dass bei markierten funktionellen Gruppen, die
einen eigentlich nicht entscheidbaren Zyklus beinhalten, dieser durch die Korrespondenzbildung der Gruppenknoten komplett zugeordnet werden kann. Grund dafür ist
ein veränderter Matching-Algorithmus, der bei mehreren Kandidaten mit einem identischen Ähnlichkeitswert den ersten der Liste auswählt und die Korrespondenz markiert, was in diesem Kontext einen wesentlichen Vorteil darstellt. Die Ergebnisse der
betrachteten Molekülvergleiche werden im Anhang aufgeführt.
Durch die in den ersten beiden Phasen verifizierte, zufriedenstellende Überdeckung für einfache Molekülstrukturen werden in der dritten Phase Moleküle des Datenbestands miteinander verglichen, in denen zuvor funktionelle Gruppen markiert
62
6.3 Testläufe
wurden. Zunächst werden unterschiedliche Konfigurationen bezüglich der festgelegten Gewichtungen und Schwellwerte daraufhin untersucht, ob die Korrespondenzbildung der Atom- und Bindungsknoten sinnvoll ist. Als Ergebnis dieser Untersuchungen konnte festgestellt werden, dass besonders Konfigurationen, bei denen für die
Ähnlichkeitswertberechnung der Bindungen sowohl die direkt angrenzenden Atome,
als auch der Bindungsgrad ausgewertet werden, zu ausgesprochen guten Überdeckungen führen. Für Atome werden der Elementtyp sowie die angrenzenden Bindungen ausgewertet, wobei der Schwellwert jeweils so eingestellt sein muss, dass ein
Atom auch dann zugeordnet werden kann, wenn lediglich der Elementtyp übereinstimmt. Für die Gruppen-Korrespondenzbildung wird eine ähnliche Konfiguration
verwendet, bei der sich der Ähnlichkeitswert aus dem Namen der Gruppe sowie des
Anteils der zugeordneten Atome und Bindungen errechnet, der Schwellwert jedoch so
gewählt ist, dass bereits ein identischer Name für eine Korrespondenzbildung ausreichend ist. Durch die zusätzliche Auswertung der enthaltenen Atome und Bindungen
lässt sich ein Gruppenknoten auch dann noch zuordnen, wenn aufgrund mehrerer
Kandidaten in dem jeweils anderen Dokument zunächst keine Zuordnung erfolgen
kann. Sobald ein oder mehrere Elemente der Gruppe als Korrespondenzen markiert
werden können, ändert sich der Ähnlichkeitswert für die Gruppe und es kann eine
eindeutige Zuordnung erfolgen (vgl. Kapitel 5.2.2 ).
Für die in Phase drei ermittelten Konfigurationen mit der besten Überdeckung
wird in der vierten Phase der Vergleich des Anfragemoleküls mit Teilen des Datenbestands durchgeführt. Im Fokus der Betrachtungen stehen in dieser Phase die ermittelten Ähnlichkeitswerte, die Laufzeit sowie, anhand von Stichproben, die korrekten
Korrespondenzbildungen von Teilen der Moleküle.
In einer ersten Testreihe wird eine zufällige Struktur des Datenbestands ausgewählt und mit den ersten 1.000 Datenelementen verglichen. Die ermittelten Ähnlichkeitswerte, also die SiDiff-Ähnlichkeit sowie die Set-Ähnlichkeit der Restelemente,
werden für jeden Vergleich gespeichert und abschließend ausgegeben. Für die ähnlichsten Moleküle wird anschließend eine genauere Analyse über die genaue Korrespondenzbildung durchgeführt. Für alle durchgeführten Molekülvergleiche kann zunächst festgestellt werden, dass die Anfragestruktur, sofern sie in der durchsuchten
Datenmenge enthalten ist, mit einer Gesamtähnlichkeit von 1,0 ermittelt werden
kann. Für die weiteren, sehr ähnlichen Strukturen, kann häufig bereits rein optisch
eine große Ähnlichkeit festgestellt werden. Die detaillierte Analyse zeigt überwiegend eine sinnvolle Überdeckung der Atome und Bindungen, wobei einige der überlagerten Strukturen anders abgebildet wurden, als diese durch einen Menschen rein
optisch abgebildet worden wären. Abbildung 6.4 zeigt beispielhaft die beiden Datenbankmoleküle 5 und 457 im Vergleichsprozess. Eine Analyse der zugeordneten
Strukturen ergibt, dass zwei Hauptkomponenten korrekt aufeinander abgebildet wurden. Die Übergangsstellen zwischen den beiden Teilstücken stimmen dagegen nicht
überein, wurden jedoch ebenfalls als korrespondierend markiert. Beim Vergleich
bleibt in beiden Molekülen ein Wasserstoffatom ohne Zuordnung.
63
6.3 Testläufe
Abbildung 6.4 Korrespondenzbildung beim Vergleich von Molekül 5 mit Molekül 457 des Datenbestands
Bei der Ermittlung der Ähnlichkeitswerte fallen zwei Eigenschaften des Vergleichsprozesses auf. Zum einen sind die berechneten Werte für den Vergleich zweier
Moleküle nicht konstant, sondern können sich zwischen einzelnen Testläufen geringfügig ändern. Zum anderen unterscheiden sich die Ähnlichkeitswerte für zwei Dokumente abhängig davon, in welcher Reihenfolge diese miteinander verglichen werden
(Kommutativität), das heißt der Ähnlichkeitswert für den Vergleich A zu B entspricht
nicht dem Wert für den Vergleich B zu A. Beide Merkmale lassen sich darauf zurückführen, dass die zu vergleichenden Elemente in Multimengen organisiert sind, wodurch die Reihenfolge der Einzelelement-Vergleiche für die in Multimengen erlaubten Dubletten keiner festgelegten Ordnung unterliegt (vgl. [Kel071]). Für die Korrespondenzbildung ist die Abfolge der Elementvergleiche jedoch von Bedeutung, so
dass es zu unterschiedlichen Resultaten kommt. Es konnte festgestellt werden, dass
unterschiedliche Konfigurationen der CompareConfig und MatchingConfig zu verschiedenstarken Schwankungen der Ergebnismenge führen. Als weiteres Kriterium
bei der Ermittlung einer „guten“ Konfiguration lässt sich somit die Eigenschaft hinzufügen, eine geringe Schwankung der Ergebnisse zwischen den einzelnen Testläufen
hervorzurufen.
Im Rahmen der ersten Testreihe weisen Konfigurationen, die neben der direkten
Umgebung der Knoten auch die eine Ebene weiter entfernten Knoten mit in die Berechnung der Ähnlichkeitswerte miteinbeziehen, eine deutlich höhere Laufzeit auf.
64
6.3 Testläufe
Die berechneten Ähnlichkeitswerte führen zu einem anderen Ranking als Konfigurationen, die nur die direkte Umgebung betrachten. Dieses Ranking ist in den meisten
Fällen strukturell nicht zutreffender, jedoch häufig sehr instabil zwischen den einzelnen Testläufen. Aus diesem Grund werden für die weiteren Testreihen mit größeren
Molekülmengen ausschließlich Konfigurationen betrachtet, die die direkte Umgebung
der Atome und Bindungen in die Kalkulation miteinbeziehen, da deren Ergebnisse
strukturell nachvollziehbar und relativ stabil sind sowie die geringsten Laufzeiten
aufweisen.
Die zweite Testreihe umfasst einen Datenbestand von 2.000 Molekülen. Im Vergleich zur ersten Testreihe lässt sich bei allen Konfigurationen eine Verdopplung der
Laufzeit feststellen. Für die untersuchten Anfragemoleküle werden die Kandidaten
mit den höchsten Ähnlichkeitswerten im Anhang aufgeführt. Wie dort ersichtlich
wird, ist bei allen untersuchten Strukturen bereits optisch eine hohe Ähnlichkeit mit
den bestpassenden Kandidaten auszumachen. Eine detaillierte Analyse über die Korrespondenzbildung der jeweils ähnlichsten Struktur findet sich ebenfalls im Anhang.
Bei der Auswertung zeigt sich, dass Konfiguration acht eine besonders zutreffende
Überlagerung erreicht und sich mit einer Laufzeit knapp unter der schnellsten Konfiguration auch für die Durchsuchung des gesamten Datenbestands eignet. Darüber
hinaus weist sie eine geringe Streuung bezüglich der Veränderung der Resultatmenge
zwischen den einzelnen Testläufen auf.
Die letzte Testreihe umfasst den gesamten Ausschnitt der Datenbank von 10.000
Molekülen, die mit Konfiguration acht getestet werden. Leider reichte die Hauptspeicherkapazität des Testsystems nicht aus, um alle Moleküle zeitgleich in den Speicher
zu laden. Eine blockweise Bearbeitung des Datenbestands scheitert daran, dass mit
der verwendeten Version des SiDiff-Algorithmus eine Re-Initialisierung zur Laufzeit
die Speicherressourcen nicht vollständig freigibt, wodurch die Bearbeitungsgeschwindigkeit nach etwa 2.500 Molekülen drastisch fällt. Die gesamten 10.000 Moleküle werden daher durch fünf Aufrufe mit jeweils 2.000 Molekülen verglichen und
anschließend zusammengefügt. Für den Vergleich eines Anfragemoleküls mit 2.000
Molekülen des Datenbestands werden im Mittel etwa drei Minuten benötigt (vgl. Abbildung 6.5), was in einer theoretischen Laufzeit für den Vergleich mit dem gesamten
Datenbestand von 260.000 Molekülen von etwa sieben Stunden resultiert.
65
6.3 Testläufe
Aufwand zum Molekülvergleich
300
Laufzeit (in s)
250
200
150
100
Mittelwert
50
0
500
1000
1500
2000
2500
Anzahl verglichene Moleküle
Abbildung 6.5 Aufwand zum Vergleich mit dem Datenbestand
Wird in die Berechnung des Ähnlichkeitswerts die Set-Ähnlichkeit miteinbezogen,
so zeigt sich, dass bei einer geringfügigen Gewichtung die Ergebnismenge über die
Testläufe geringere Schwankungen aufweist. Ursache für die Schwankungen der
Ähnlichkeitswerte ist eine veränderte Korrespondenzbildung während des Vergleichsvorgangs, die dazu führt, dass sich die Position eines Moleküls im Gesamtranking um einige Positionen verschieben kann. Die Set-Ähnlichkeit wird hierdurch jedoch kaum beeinflusst, da die Restmenge an Atomen und Bindungen bezüglich der
Atomtypen und Bindungsgrade in der Regel vollkommen gleich bleibt. Wird dieser
Ähnlichkeitswert für die Bildung des Rankings zu einem gewissen Anteil herangezogen, so kann er die Schwankung zum Teil ausgleichen, unter der Voraussetzung, dass
die Set-Ähnlichkeit ausreichend hoch ist. Als Beispiel wäre ein Molekül A denkbar,
das in einem ersten Durchlauf einen SiDiff-Ähnlichkeitswert im Vergleich mit einem
anderen Molekül B von 0,85 aufweist, in einem zweiten Durchlauf jedoch nur 0,84.
Die Set-Ähnlichkeit der Restmenge liegt in beiden Fällen so, dass maximal eine Ähnlichkeit von 0,95 möglich wäre. Werden für das Gesamtranking 50% der SetÄhnlichkeit angerechnet, so wird im ersten Vergleich ein Ähnlichkeitswert von 0,9
erreicht, im zweiten Vergleich von 0,895, was die Wahrscheinlichkeit, dass sich die
Position im Ranking verändert, reduziert. Neben dieser stabilisierenden Eigenschaft
führt die Set-Ähnlichkeit jedoch auch zu einer leicht veränderten Ergebnismenge, da
auch Moleküle, die über einen geringeren strukturellen Ähnlichkeitswert verfügen,
jedoch zufällig eine ähnliche Menge an Restelementen aufweisen, auf die vorderen
Positionen gelangen können.
66
6.4 Evaluierung der Ergebnisse
Wie die durchgeführten Tests der beiden Bereiche zur Markierung funktioneller
Gruppen und dem Vergleich der markierten Moleküle gezeigt haben, sind beide
Komponenten zusammen dazu geeignet, Moleküle erfolgreich miteinander zu vergleichen.
Die Markierung der funktionellen Gruppen erfolgte bei den untersuchten Strukturen korrekt und mit einer akzeptablen Laufzeit. Es stellte sich heraus, dass nicht nur
die Markierung der Anfragestruktur für den Vergleichsvorgang mit wenigen Millisekunden effizient durchführbar ist, sondern auch die Markierung des gesamten Datenbestands, die lediglich bei Änderungen an den Musterdefinitionen zu erfolgen hat.
Bezüglich der Markierungsrangfolge der Muster bleibt festzuhalten, dass durch eine
Umgestaltung des Algorithmus polyzyklische Kohlenstoffstrukturen vermehrt markiert werden könnten. Dazu wäre die Abfolge der besuchten Startatome so zu verändern, dass Kohlenstoffmuster nicht zwangsläufig hinter Schwefel-, Phosphor-, Stickstoff- und Sauerstoff-Mustern getestet werden, sondern auch mit einer höheren Priorität davor eingeordnet werden können (vgl. Kapitel 6.3.1 ). Diese Veränderung ist mit
dem derzeit verwendeten Musterkatalog und der erzielten Vergleichsergebnisse jedoch weder erforderlich noch erwünscht.
Der Vergleich der markierten molekularen Strukturen kann mit einer hohen Präzision durchgeführt werden. Wie die Testresultate belegen, erfolgt die Korrespondenzbildung von funktionellen Gruppen, Atomen und Bindungen nachvollziehbar und,
unter strukturellen Gesichtspunkten, durchaus sinnvoll. Bei der Auswertung bestätigte sich die Vermutung, dass bei Mehrdeutigkeit bezüglich der Zuordnung der Elemente keine Korrespondenzbildung erfolgt, auch wenn die Ähnlichkeitswerte oberhalb des definierten Schwellwerts liegen. Durch die Verwendung der funktionellen
Gruppen kann diese Mehrdeutigkeit jedoch auf ein Minimum reduziert werden, da
mit deren Hilfe aussagekräftige Substrukturen geschaffen werden, die diese Aussagekraft auf die Atome und Bindungen der Gruppen übertragen. Der Grundgedanke,
durch den Einsatz funktioneller Gruppen in Verbindung mit den weniger häufig vorkommenden Atomtypen genügend Fixpunkte für den Vergleichsalgorithmus zu
schaffen, konnte durch die Vergleichsergebnisse bestätigt werden. Beim Vergleich
von Molekülen, bei denen mehrere Fixpunkte als Ausgangspunkt für die Korrespondenzbildung genutzt werden können, fällt auf, dass häufig Teilstücke des einen Graphen korrekt auf Substrukturen des anderen Graphen abgebildet werden. Diese Teilgraphen werden in jeder Iteration weiterentwickelt und treffen schließlich aufeinander, wobei sie allerdings häufig nicht korrekt zusammenpassen, was in einigen nichtzugeordneten Knoten an den Schnittstellen resultiert. Durch diesen Sachverhalt kann
es vorkommen, dass beispielsweise die Ringstruktur eines Moleküls mit einem hohen
Ähnlichkeitswert auf eine linear verkettete Struktur eines anderen Moleküls abgebildet wird, da lediglich die Verbundstelle des Ringsystems nicht abgebildet werden
kann. In den durchgeführten Tests erwies sich diese Problematik jedoch angesichts
67
der höheren Ähnlichkeitswerte für Strukturen, die tatsächlich Ringsysteme enthielten,
als nicht gravierend.
Beim Vergleich einer Anfragestruktur mit allen Molekülen des Datenbestands
zeigt sich grundsätzlich, dass in jedem Testlauf die identische Anfragestruktur mit
einem Ähnlichkeitswert von 1,0 entdeckt und an der Spitze des Ähnlichkeitsranking
angeordnet wird. Für die weitere Ergebnismenge konnte festgestellt werden, dass die
Moleküle mit den höchsten Ähnlichkeitswerten sowohl optisch „auf den ersten
Blick“, als auch in der detaillierten Betrachtung, eine hohe Ähnlichkeit zu der Anfragestruktur aufwiesen. Die festgestellten Schwankungen innerhalb des Rankings zwischen den einzelnen Testläufen können jedoch ein Problem darstellen, sofern lediglich eine einzige Anfrage auf den Datenbestand als repräsentativ ausgewertet wird.
Hierbei könnten sehr ähnliche Moleküle aufgrund einer ungünstigen Korrespondenzbildung mit einem geringeren Ähnlichkeitswert aus den Top-Platzierungen verschwinden. Werden mehrere Durchläufe der Anfrage bearbeitet, so steigt die Wahrscheinlichkeit, dass eine geeignete Überlagerung der Strukturen wenigstens einmalig
zu einem hohen Ähnlichkeitswert führt und die Struktur somit weiter oben angeordnet wird. Durch die Einbeziehung der Set-Ähnlichkeit kann die Stabilität des Rankings ebenfalls erhöht werden, da sich dieser Ähnlichkeitswert aufgrund der reinen
Mengen-Ähnlichkeit der Restelemente unabhängig von der genauen Korrespondenzbildung meist nicht verändert. Es zeigte sich aber auch, dass Strukturen, die zufällig
eine ähnliche Restmenge aufweisen, selbst bei einer geringen strukturellen Ähnlichkeit eine hohe Platzierung erreichen können, so dass sich eine zu hohe Gewichtung
der Set-Ähnlichkeit als kontraproduktiv erweisen kann. Wie die Testergebnisse der
unterschiedlichen Konfigurationen gezeigt haben, kann durch diese entscheidend auf
die ermittelten Ähnlichkeitswerte Einfluss genommen werden. Der derzeitige Fokus
liegt auf einer strukturellen Überlagerung. Es ist jedoch auch denkbar, durch eine
höhere Gewichtung der funktionellen Gruppen und eine primäre Auswertung der
Gruppenüberlagerung eine Übereinstimmung der Gruppen in den Mittelpunkt zu stellen, was je nach Aufgabenstellung unter biochemischen Aspekten von Vorteil sein
kann.
Die Laufzeit für den Vergleich der Anfragestruktur mit dem gesamten Datenbestand ist mit etwa anderthalb Minuten für 1.000 Moleküle auf dem Testsystem recht
hoch und somit nicht gut geeignet, um den gesamten Inhalt der Datenbank effizient
zu vergleichen. Problematisch stellt sich in Bezug auf die Bearbeitung des gesamten
Datenbestands auch die Speicherkapazität dar. Bei der verwendeten SiDiff-Version
können selbst durch eine Reinitialisierung der internen Strukturen und explizite Garbage Collection einige Speicherbereiche nicht freigegeben werden, wodurch der belegte Speicher mit zunehmender Vergleichszahl immer weiter zunimmt und schließlich bei etwa 3.000 Molekülen auf dem Testsystem sein Maximum erreicht. Für eine
Abarbeitung der gesamten Datenbank wäre somit ein wiederholtes externes Aufrufen
erforderlich. In Bezug auf den detaillierten Vergleich zweier Moleküle lässt sich jedoch feststellen, dass hierfür nur wenige hundert Millisekunden erforderlich sind, so
68
dass der SiDiff-Algorithmus effizient genutzt werden kann, um eine schnelle strukturelle Überlagerung zu berechnen.
69
7 Zusammenfassung und
Ausblick
In dieser Arbeit wurde ein Verfahren vorgestellt, mit dem molekulare Graphen in
zweidimensionaler Darstellung strukturell miteinander verglichen werden können.
Die hierzu erforderlichen Komponenten des Vergleichswerkzeugs sowie die relevanten Grundlagen der chemischen Strukturen wurden zunächst identifiziert und detailliert beschrieben, woraus anschließend die vorzunehmenden Anpassungen hergeleitet
werden konnten.
Bedingt durch die Eigenschaften molekularer Graphen wurde eine Anreicherung
der reinen Strukturinformationen mit funktionellen Gruppen vorgenommen. Für die
Wahl eines geeigneten Algorithmus wurden Charakteristika der Molekülstrukturen
sowie der zu ermittelnden funktionellen Gruppen herausgearbeitet und evaluiert. Der
resultierende Algorithmus zur Mustersuche basiert auf einem rekursiven Ansatz zur
paarweisen Abbildung der Musterelemente auf Elemente des Graphen. Die Speicherung der mit Gruppeninformationen angereicherten Graphen erfolgte mithilfe eines
auf der CML basierenden Dateiformats.
Für den strukturellen Vergleich der Moleküle wurde der SiDiff-Algorithmus verwendet. Zur Unterstützung der Molekülstrukturen wurden die erforderlichen Konfigurationsdateien ermittelt, beschrieben und angepasst. Um der Schwierigkeit bei der
Korrespondenzbildung zu begegnen, wurde eine auf der SiDiff-Ähnlichkeit basierende alternative Ähnlichkeitsmetrik entwickelt. Eine weitere Anpassung umfasste die
Anwendung des Algorithmus auf einen Datenbestand von Dokumenten, da das
Werkzeug in der vorliegenden Version ausschließlich für den direkten Vergleich
zweier Dokumente ausgelegt war.
Die abschließenden Tests bestätigten, dass die Markierung funktioneller Gruppen
auf den verwendeten molekularen Graphen effizient durchgeführt werden kann.
Durch die Anreicherung der Graphen mit Gruppen konnte für den Vergleichsalgorithmus eine ausreichende Anzahl an Einstiegsstellen geschaffen werden, so dass die
verglichenen Moleküle strukturell sinnvoll aufeinander abgebildet werden. Für den
Vergleich eines Anfragemoleküls mit einem Datenbestand von Molekülen mit dem
Ziel, die ähnlichsten Strukturen zu ermitteln, ergab sich eine zufriedenstellende Reihenfolge der Ergebnismoleküle. Die im Rahmen dieser untersuchten Anfrageart festgestellten Problematiken bezüglich Speicherfreigabe und einer hohen Laufzeit zeigten
jedoch, dass der Algorithmus für den Vergleich mit Datenbeständen derzeit noch
nicht effizient eingesetzt werden kann.
Basierend auf den gewonnenen Erkenntnissen erscheint ein Einsatz des Werkzeugs
zum Vergleich molekularer Strukturen prinzipiell möglich. Besonders für die Ermittlung von, zu einer Anfragestruktur ähnlichen, Molekülen, die über möglichst identische funktionelle Gruppen sowie eine hohe strukturelle Ähnlichkeit verfügen, kann
70
7 Zusammenfassung und Ausblick
der SiDiff-Algorithmus verwendet werden. In Bezug auf die Ermittlung von Strukturen, bei denen bestimmte Schlüsselstellen unbedingt erforderlich sind, wäre auch ein
modifizierter Einsatz von Gruppenmarkierung und Molekülvergleich denkbar. Da der
Algorithmus zur Markierung funktioneller Gruppen beliebige Muster markieren kann,
könnten in einem ersten Schritt die erforderlichen Schlüsselstellen exklusiv als neue
Muster im Datenbestand markiert werden. Alle Strukturen, in denen diese Schlüsselstellen ermittelt werden können, könnten anschließend strukturell mit SiDiff überlagert werden. Die Ergebnismenge würde alle Strukturen umfassen, die identische
Schlüsselstellen sowie eine hohe strukturelle Ähnlichkeit aufweisen.
Eine zukünftige Weiterentwicklung erscheint besonders im Bereich der Laufzeitoptimierung bei der Anfrage auf einen Datenbestand sinnvoll. Einen möglichen Ansatzpunkt bietet die im Rahmen dieser Arbeit bereits erwähnte Datenstruktur des S3VBaums (vgl. [Tre07]). Durch die Organisation der Datenbestandsmoleküle in einem
multidimensionalen Baum, der entsprechend der Art und Anzahl der markierten funktionellen Gruppen aufgebaut wird, ließe sich bereits vor Beginn des Vergleichsprozesses die Menge der zu vergleichenden Moleküle stark einschränken. Da mithilfe
dieser Datenstruktur über Bereichsanfragen der zu bearbeitende Suchraum stark verkleinert werden könnte, würden weniger Einzelvergleiche erforderlich und somit die
Gesamtlaufzeit sehr wahrscheinlich reduziert. Voraussetzung für diesen Ansatz ist,
dass die markierten funktionellen Gruppen alleine einen sinnvollen Indikator für die
Ähnlichkeit der Strukturen darstellen, was zuvor entsprechend zu prüfen ist.
Zur Erhöhung der Vergleichspräzision könnten an zwei Stellen Weiterentwicklungen vorgenommen werden. Durch eine Umgestaltung des Algorithmus zur Markierung funktioneller Gruppen könnten weitere Muster markiert werden, die eine hohe
Aussagekraft beim Vergleichsprozess besitzen (vgl. Kapitel 6.4 ). Dazu wäre es erforderlich für Muster eine Priorität definieren zu können, die unabhängig von ihren
jeweiligen Startatomen zu einer alternativen Reihenfolge der Musterüberprüfung
führt. Somit könnten gerade die ausdrucksstarken polyzyklischen Kohlenstoffringe
getestet und markiert werden, bevor durch die Markierung von Mustern mit anderen
Startatomen deren Bestandteile „belegt“ werden.
Die Anreicherung der molekularen Graphen mit zusätzlichen chemischen Eigenschaften erscheint im Hinblick auf eine sinnvollere Überlagerung, gerade unter chemischen Gesichtspunkten, ebenfalls aussichtsreich. Basierend auf den markierten
Gruppen könnten an diese zusätzliche Attribute, wie beispielsweise die Elektronegativität oder das Atomvolumen, gehängt werden, ähnlich den eingesetzten Eigenschaften bei Feature Trees. Für den Gruppenvergleich würden somit neben dem Namen
weitere Eigenschaften ausgewertet, was eine mögliche Nutzung dieser Gruppen als
Fixpunkte weiter unterstützt. Zudem wird die Überlagerung der Gruppen unter chemischen Aspekten deutlich präziser und aussagekräftiger.
71
A Katalog funktioneller Gruppen
Gruppen mit Kohlenstoff
ID
Verbindungsklasse
Gruppenname
Struktur
Enthalten in
1
Alkane
Alkane
54
2
Alkene
Alkene
53
3
Alkine
Alkine
52
4
Benzen
Benzen
5
Toluol
Toluol
5
Rang
51
50
Gruppen mit Halogen
ID
Verbindungsklasse
Gruppenname
Struktur
Enthalten in
Rang
7
Fluoroalkane
Fluoro
45
8
Chloroalkane
Chloro
44
9
Bromoalkane
Bromo
43
10
Iodoalkane
Iodo
42
72
Gruppen mit Sauerstoff
ID
Verbindungsklasse
Gruppenname
12
Alkohole
13
Struktur
Enthalten in
Rang
Alkohole
17, 20, 46,
47, 50
40
Ketone
Ketone
14, 15, 16,
17, 19, 22,
31
39
14
Aldehyde
Aldehyde
35
15
Carbonate
Carbonate
34
16
Carboxylate
Carboxylate
17
Carboxylsäure
Carboxylsäure
18
Ether
Ether
12, 15, 17,
19, 20, 21,
34, 38, 40
41
19
Ester
Ester
17, 15
37
20
Hydroperoxide
Hydroperoxide
21
36
21
Peroxide
Peroxide
Defined as
RC(=O)O
17, 15, 19
38
33
32
73
Gruppen mit Stickstoff
ID
Verbindungsklasse
Gruppenname
22
Amide
Amide
23
23
Primaere Amine
22
24
Sekundaere
Amine
23
28
Tertiaere Amine
22, 23, 24,
31
31
25
Amine
26
Quarternäre
Amine
27
Imine
Struktur
Enthalten in
Rang
21
30,43
30
Imine
30
Aldimine
27
31
Imide
Imide
20
32
Azide
Azide
19
33
Azoverbindungen
Azo
34
Cyanate
Cyanate
32
26
18
74
ID
Verbindungsklasse
Gruppenname
35
Isonitrile
Isonitrile
17
Isocyanate
16
Isothiocyanate
15
14
36
Struktur
Enthalten in
Rang
Isocyanate
37
38
Nitrate
Nitrate
39
Nitrile
Nitrile
40
Nitrite
Nitrite
41
Nitroverbindung
Nitro
38
25
42
Nitrosoverbindung
Nitroso
40, 41, 38
29
43
Pyridin
Pyridyl
Defined as
Pyridyl I/II/III
12
53
24
13
75
Gruppen mit Phosphor
ID
Verbindungsklasse
Gruppenname
44
Phosphine
45
Struktur
Enthalten in
Rang
Phosphino
45, 46, 47
11
Phosphate
Phosphate
46, 47
10
46
Phosphonsäure
Phosphonsaeure
47
9
47
Phosphate
Phosphate II
8
Gruppen mit Schwefel
ID
Verbindungsklasse
Gruppenname
48
Sulfide
49
Struktur
Enthalten in
Rang
Sulfide
49, 50, 51,
52, 53, 54
7
Sulfone
Sulfone
50
5
50
Sulfonsäure
Sulfonsaeure
51
Sulfoxide
Sulfoxide
50, 49
6
52
Thiol
Thiol
53, 54
4
53
Thiocyanate
Thiocyanate
2
54
Disulfide
Disulfide
1
3
76
Polyzyklische Kohlenstoffstrukturen
ID
Verbindungsklasse
Gruppenname
60
Naphtalin
61
62
63
Charakteristik
Rang
Naphtalin
I-VI
entsprechend
R-Bindung
49
Anthracen
Anthracen
I-X
entsprechend
R-Bindung
48
Phenanthren
Phenanthren
I-XX
entsprechend
R-Bindung
47
Phenalen
I-IX
entsprechend
R-Bindung
46
Phenalen
Struktur
Quellen zur Erstellung des Musterkatalogs: [Str96], [Lip08] und [Hel74]
77
B Algorithmus zur Markierung
funktioneller Gruppen
private boolean compareAtoms(Atom moleculeAtom, Atom patternAtom)
{
boolean atomsMatch = false;
if(patternAtom.isWildcard()){
markAndBindMolecules(moleculeAtom,patternAtom);
return true;
}
/** Check the bonds that are connected to these atoms */
if(/** Elementtyp gleich und noch nicht in Compound */) {
markAndBindMolecules(moleculeAtom,patternAtom);
/** Remind last bond that was put on the queue */
Vector<Bond> patternBonds = patternAtom.getBonds();
boolean bondMissing = false;
for(int i=0;i<patternBonds.size() && bondMissing == false;i++) {
Bond patternBond = patternBonds.elementAt(i);
if(patternBond.isVisited() == false) {
Vector<Bond> candidatesMolecule = getCandidates(moleculeAtom, patternAtom,
patternBond);
Vector<Bond> candidatesPattern = getCandidates(patternAtom, patternAtom,
patternBond);
if(candidatesMolecule.size() >= candidatesPattern.size()) {
/** Positions are number of pattern candidates, numbers are positions of
molecule candidates */
int[] mappingCandidates = new int[candidatesPattern.size()];
for(int j=0;j<mappingCandidates.length;j++) {
mappingCandidates[j] = -1;
}
boolean complete = false;
boolean invalid = false;
for(int j=0;j<candidatesPattern.size() && complete == false && invalid ==
false;) {
int k = (mappingCandidates[j]+1);
Bond bondPattern = candidatesPattern.elementAt(j);
/** Visit every bond in pattern and check candidates in molecule */
if(bondPattern.isVisited() == false) {
boolean match = false;
for(;k<candidatesMolecule.size() && match == false;) {
Bond bondMolecule = candidatesMolecule.elementAt(k);
Atom moleculeChild = bondMolecule.getConnectedAtom(moleculeRoot);
Atom patternChild = bondPattern.getConnectedAtom(patternRoot);
if(/** Bindungen noch nicht bearbeitet */) {
markAndBindBonds(bondPattern,bondMolecule);
match = compareAtoms(moleculeChild, patternChild);
if(match == true) {
mappingCandidates[j] = k;
j++;
if(j == candidatesPattern.size()) complete = true;
}
else {
unbindBonds(bondPattern,bondMolecule);
k++;
if(k == candidatesMolecule.size()) {
mappingCandidates[j] = -1;
j--;
if(j == -1) {
invalid = true;
unbindMolecules(moleculeAtom,patternAtom);
}
78
B Algorithmus zur Markierung funktioneller Gruppen
else {
int indexMoleculeToRemove = mappingCandidates[j];
int indexPatternToRemove = j;
/** hole Bindungen und Atome aus vorangegangenen Zuordnungen
* und setze sie und alle folgenden zurück */
}
}
}
}
else {
if(/** Atome besucht, Kanten jedoch nicht -> Zyklus */) {
markAndBindBonds(bondMolecule,bondPattern);
match = true;
mappingCandidates[j] = k;
j++;
if(j == candidatesPattern.size()) {
complete = true;
}
}
else {
k++;
if(k == candidatesMolecule.size()) invalid = true;
}
}
}
}
else j++;
}
if(invalid == true) bondMissing = true;
}
else bondMissing = true;
}
}
if(bondMissing == true) {
/** Entferne Zuordnung für Atompaar und alle nachträglichen Zuordnungen */
atomsMatch = false;
}
else atomsMatch = true;
}
return atomsMatch;
}
79
C Testergebnisse
Gruppenmarkierung
Testläufe mit speziellen Teststrukturen
Testmoleküle
Testmolekül 1
Testmolekül 2
Testmolekül 3
SMILES:
C(CC)=O
SMILES:
C(CC(C=O)=[S]=O)=O
SMILES:
C(C)(C(C(C(N)P)=S)
=O)=O
Testmolekül 4
Testmolekül 5
Testmolekül 6
SMILES:
S(C=[O](CN)C)C
=[O](C)C
SMILES:
C[O](C)=CSC=[O]1CCNC1
SMILES:
[S]12(C=[O](CN)CC1)
C=[O](C)CC2
Testmolekül 7
Testmolekül 8
Testmolekül 9
SMILES:
O=C1CC(=O)C1
SMILES:
O=C1CC(=O)N1
SMILES:
O=C(CC(=O)C)C
80
C Testergebnisse Gruppenmarkierung
Testmuster
Name
SMILES
Struktur
Charakteristik
CO-group
C=O
Part of group 3, 5, 6, 7,
9; Starting atom C
SO-group
S=O
Starting atom S
OCC- group
O=CC
Part of group 6, 7, 9;
Containing group 1;
Starting atom O
CNP- group
C(N)P
Starting atom C
COS- group
C(=O)S
Containing group 1;
Starting atom C
OCCC- group
O=C(C)C
Part of group 9; Containing group 1, 3;
Starting atom O
COCC- group
C=[O](C)C
Containing group 1, 3;
Starting atom C
OCNCC- group
O1CNCC1
Starting atom O
OCCCC- group
O=C1CCC1
Containing group 1, 3,
6; Starting atom O
RSR- group
[Re]S[Re]
Starting atom S; Containing WildcardElements (Re)
81
Testläufe
Strukturen ohne Zyklen
Musterart
Molekül
Markierte
Gruppen
Muster mit
2 Atomen
Molekül 1
CO-Group
Molekül 2
CO-group,
CO-group,
SO-group
Molekül 3
CO-group,
CO-group
Molekül 4
CO-group,
CO-group
Molekül 1
OCC-group
Molekül 2
OCC-group,
OCC-group
Molekül 3
CNP-group,
OCC-group,
OCC-group
Molekül 4
COS-group
Molekül 1
-
Molekül 2
-
Muster mit
3 Atomen
Muster mit
4 Atomen
Struktur
82
Musterart
Molekül
Markierte
Gruppen
Molekül 3
OCCC-group
Molekül 4
COCC-group,
COCC-group
Molekül 1
CO-group
Molekül 2
CO-group,
CO-group,
SO-group
Molekül 3
CNP-group,
CO-group,
CO-group
Molekül 4
COCC-group,
COCC-group
Molekül 1
OCC-group
Molekül 2
OCC-group,
OCC-group,
SO-group
Molekül 3
CNP-group,
OCCC-group
Molekül 4
COCC-group,
COCC-group
Struktur
Muster mit
4 Atomen
Gruppen mit
2, 3 und 4 Atomen
Gruppen mit
2, 3 und 4 Atomen
und
Musterdefinitionen,
die mit den
seltensten Atomen
beginnen (S,O)
83
Strukturen mit Zyklen
Musterart
Molekül
Markierte
Gruppen
Molekül 5
COCC-group,
COCC-group
Molekül 6
COCC-group,
COCC-group
Molekül 7
OCCC-group,
CO-group
Molekül 8
OCC-group,
CO-group
Molekül 5
COCC-group,
COCC-group
Struktur
Gruppen mit
2, 3 und 4 Atomen
Gruppen mit
2, 3 und 4 Atomen
und
zyklischen Mustern
COCC-group,
COCC-group
Molekül 6
84
Musterart
Gruppen mit
2, 3 und 4 Atomen
und
zyklischen Mustern
Gruppen mit
2, 3 und 4 Atomen
und
Wildcard-Element
Molekül
Markierte
Gruppen
Molekül 7
OCCCCgroup
Molekül 8
OCC-group,
CO-group
Molekül 1
CO-group
Molekül 2
CO-group,
CO-group,
SO-group
Molekül 3
CNP-group,
CO-group,
CO-group
Molekül 4
COCC-group,
COCC-group
Molekül 5
COCC-group,
COCC-group
Molekül 6
COCC-group,
RSR-group
Struktur
85
Musterart
Gruppen mit
2, 3 und 4 Atomen
und
Wildcard-Element
Molekül
Markierte
Gruppen
Molekül 7
OCCCCgroup
Molekül 8
OCC-group,
CO-group
Molekül 9
OCCC-group,
CO-group
Struktur
86
Testläufe mit Molekülen des Datenbestands
Nr
Markierte
Gruppen
5
2 Alkane,
2 Alkene,
2 Ketone,
1 Primäre
Amine
8
2 Alkane,
2 Alkene,
2 Ketone,
1 Nitro
457
3 Alkane,
1 Alkene,
2 Ketone,
1 Primäre
Amine
529
2 Alkane,
2 Alkene,
1 Alkohol,
1 Carboxylsäure,
1 Amide
Struktur
Struktur (markiert)
87
Laufzeiten für Gruppenmarkierung
Laufzeit (in s)
Anzahl Moleküle
1000
2000
3000
4000
5000
6000
7000
8000
9000
10000
Testlauf 1
Testlauf 2
Testlauf 3
Testlauf 4
Mittelwert
11
22
31
42
51
64
73
84
91
102
11
22
31
42
54
62
74
84
94
104
10
22
30
42
53
63
74
85
92
102
11
22
30
42
52
61
74
83
92
102
10,75
22
30,5
42
52,5
62,5
73,75
84
92,25
102,5
Molekül
#Atome
#Bindungen
#Gruppen
Größe
Mittlere Laufzeit
(in ms)
molecule7488
9
8
2
sehr klein
15,8
molecule9734
11
10
2
sehr klein
15,4
molecule3194
10
9
6
sehr klein
15,6
molecule7926
19
19
5
klein
15,6
molecule3670
21
20
7
klein
15,6
molecule4111
23
23
7
klein
18,6
molecule8646
28
29
5
mittel
19
molecule5
26
28
7
mittel
22,4
molecule6793
27
28
7
mittel
22,2
molecule529
30
31
7
mittel
16
molecule5892
36
35
9
groß
47
molecule 6838
38
38
14
groß
25
molecule2280
46
45
14
groß
19
molecule6842
45
45
16
groß
22
molecule9366
64
63
20
sehr groß
22
molecule8234
76
75
25
sehr groß
25
molecule7562
104
109
40
sehr groß
34,4
molecule7561
198
208
48
sehr groß
81,6
molecule3573
230
235
70
sehr groß
78,2
88
D Testergebnisse
Molekülvergleich
Getestete Konfigurationen
Model
Compound
Atom
Bond
Attribut
V
Attribut
V
Attribut
V
Attribut
V
K1
threshold
compounds
1.0
1.0
threshold
name
O:atoms
O:bonds
0.8
0.5
0.25
0.25
threshold
elementType
I:target
0.2
0.6
0.4
threshold
O:target
0.4
1.0
K2
threshold
compounds
1.0
1.0
threshold
name
O:atoms
O:bonds
0.8
0.5
0.25
0.25
threshold
elementType
I:target
0.2
0.6
0.4
threshold
order
O:target
0.8
0.5
0.5
K3
threshold
compounds
1.0
1.0
threshold
name
O:atoms
O:bonds
0.8
0.5
0.25
0.25
threshold
elementType
I:target
0.6
0.6
0.4
threshold
order
O:target
0.8
0.5
0.5
K4
threshold
compounds
1.0
1.0
threshold
name
O:atoms
O:bonds
0.8
0.5
0.25
0.25
threshold
elementType
I:target
0.6
0.6
0.4
threshold
O:target
0.2
1.0
K5
threshold
compounds
1.0
1.0
threshold
name
O:atoms
O:bonds
0.5
0.5
0.25
0.25
threshold
elementType
I:target
I:target/
O:target
0.6
0.6
0.3
0.1
threshold
order
O:target
O:target/
I:target
0.8
0.5
0.4
0.1
K6
threshold
compounds
1.0
1.0
threshold
name
O:atoms
O:bonds
0.5
0.5
0.25
0.25
threshold
elementType
I:target
I:target/
O:target
0.5
0.5
0.4
0.1
threshold
order
O:target
O:target/
I:target
0.6
0.5
0.3
0.2
89
D Testergebnisse Molekülvergleich
K7
K8
Model
Attribut
V
threshold
1.0
compounds 1.0
Compound
Attribut
V
threshold
0.5
name
0.5
O:atoms 0.25
O:bonds 0.25
Atom
Attribut
threshold
elementType
I:target
V
0.5
0.5
0.5
threshold
compounds
threshold
name
O:atoms
O:bonds
threshold
elementType
I:target
0.6
0.6
0.4
1.0
1.0
0.5
0.5
0.25
0.25
Bond
Attribut
threshold
order
O:target
O:target/
I:target
V
0.6
0.5
0.3
0.2
threshold
order
O:target
0.8
0.5
0.5
90
Testläufe mit speziellen Teststrukturen
Testläufe
Kategorie
Zyklenfreie
Strukturen ohne
funktionelle
Gruppen
Molekül 1
Molekül 2
Ergebnis
Komplett zugeordnet
Unentscheidbare
„S“-Atome am Ende
nicht zugeordnet
„N“- und „F“Unterschied nicht
zugeordnet, letztes
„S“-Atom dahinter
auch nicht
zugeordnet
Unentscheidbare
„SSB“-Zweige nicht
zugeordnet
zugeordnet
Zyklische
Strukturen
ohne
funktionelle
Gruppen
Komplett zugeordnet
Komplett zugeordnet
Erstes „C“-Atom und
Zyklus nicht zugeordnet
91
Kategorie
Zyklische
Strukturen
ohne
funktionelle
Gruppen
Molekül 1
Molekül 2
Ergebnis
Komplett zugeordnet
Komplett zugeordnet
„C“-Atome in Zyklus
außer dem ersten
nicht zugeordnet
Alle Strukturen
und
funktionelle
Gruppen
Komplett zugeordnet
„C“-Atom im Zentrum nicht zugeordnet
Mit
ParentForceMatch
Komplett zugeordnet
Komplett zugeordnet
Komplett zugeordnet
Komplett zugeordnet
Bis auf „FC“/„CN“Unterschied zugeordnet
Bis auf „FC“/„CN“Unterschied zugeordnet
92
Testläufe mit Molekülen des Datenbestands
Beispielüberlagerung zweier Strukturen
Molekül 5
Molekül 529
Molekül 5
Molekül 457
93
Testläufe 1.000 Moleküle
Anfragestruktur Molekül 8
Molekül 503
Molekül 605
Molekül 457
0.8705
Molekül 124
0.8292
Molekül 395
0.8588
Molekül 5
0.8292
0.8241
0.8205
94
Molekül 5
Molekül 605
Molekül 463
0.9625
Molekül 503
0.875
Molekül 529
0.8571
Molekül 8
0.8311
0.8287
0.817
95
Molekül 530
Molekül 5
Molekül 1548
0.885
Molekül 533
0.8826
Molekül 1540
0.8604
Molekül 486
0.8589
0.8571
0.8556
96
Molekül 756
Molekül 1180
Molekül 1475
0.8909
Molekül 1451
0.8571
Molekül 1340
0.8571
Molekül 171
0.8545
0.8448
0.8235
97
Molekül 756
Molekül 9623
Molekül 6138
0.9059
Molekül 5032
0.8925
Molekül 9301
0.8907
Molekül 111
0.88
0.8761
0.8571
98
Molekül 8052
0.8648
Molekül 4712
0.7007
Molekül 8064
Molekül 8061
0.8
Molekül 2716
Molekül 2712
0.7
0.7
Molekül 3632
0.6956
Molekül 2223
0.6935
Molekül 4813
0.6715
0.6666
99
Laufzeiten für Molekülvergleiche
Konfiguration
Mittlere Laufzeit für Vergleich 2000 Moleküle (in s)
K1
K2
K3
K4
K8
187,4333333
188,8
190,5
196,4
184,2
Laufzeit (in s)
Anzahl Moleküle
500
1.000
1.500
2.000
2.500
L1
L2
L3
L4
L5
L6
Mittelwert
53
105
151
198
261
53
103
152
200
252
52
98
148
193
245
52
99
145
191
242
55
105
152
203
252
56
107
152
203
255
53,5
102,83
149
195,5
250
100
Literaturverzeichnis
[Abo08]
About NCI/CADD Group. (2008). Abgerufen am 8. November 2008
von National Cancer Institute/CADD Group:
http://cactus.nci.nih.gov/ncicadd/about.html
[Ato08]
Atomic Coordinate Entry Format Description. (2008). Abgerufen am
5. November 2008 von Worldwide Protein Data Bank:
http://www.wwpdb.org/documentation/format3.1-20080211.pdf
[Ben08]
Bender, T. (2008). Spezifikation der SiDiff-Compare-Konfiguration.
Praktische Informatik. Universität Siegen.
[Ber07]
Berlik, S., & Fathi, M. (2007). Differences of Structured Documents Improving their Quality. IEEE International Conference on
Information Reuse and Integration, (S. 486-491).
[Blu06]
Blumenthal, G., Linke, D., & Vieth, S. (2006). Chemie - Grundwissen
für Ingenieure. Wiesbaden: Teubner Verlag.
[Bra94]
Brandstädt, A. (1996). Graphen und Algorithmen. Teubner Verlag.
[CAS08]
CAS REGISTRY and CAS Registry Numbers. (2008). Abgerufen am 6.
November 2008 von CAS - A division of the American Chemical
Society: http://www.cas.org/expertise/cascontent/registry/regsys.html
[Che082] Chemical Structure Lookup Service 2008. (2008). Abgerufen am 7.
November 2008 von National Cancer Institute:
http://cactus.nci.nih.gov/cgi-bin/lookup/search
[Che08]
Chemie für Mediziner: Funktionelle Gruppen. (2008). Abgerufen am
9. November 2008 von Chemgaroo:
http://www.chemgapedia.de/vsengine/vlu/vsc/de/ch/4/cm/funktgruppe
n.vlu.html
101
[Che081] Cheng, J., Yu, J. X., Ding, B., Yu, P. S., & Wang, H. (2008). Fast
Graph Pattern Matching. IEEE 24th International Conference on Data
Engineering, (S. 913-922).
[CML03] CML Core Specification. (2003). Abgerufen am 5. November 2008
von OpenSource Site for CML:
http://cml.sourceforge.net/schema/cmlCore/HTMLDOCS/cmlCore.pdf
[Def08]
Definition "Wild card". (2008). Abgerufen am 8. November 2008 von
MSN Encarta:
http://encarta.msn.com/dictionary_1861713247/wild_card.html
[Int08]
Definitionen chemischer Begriffe. (2008). Abgerufen am 6. November
2008 von International Union of Pure and Applied Chemistry:
http://goldbook.iupac.org/M04002.html
[Dow08]
Downloadable Structure Files of NCI Open Database Compounds.
(2008). Abgerufen am 6. November 2008 von National Cancer
Institute/CADD Group:
http://cactus.nci.nih.gov/ncidb2/download.html
[Gad07]
Gad, A. (2007). Differenzbestimmung für Poseidon-UML-Diagramme.
Praktische Informatik. Universität Siegen.
[Gen081] Gene Ontology Homepage. (2008). Abgerufen am 6. November 2008
von Gene Ontology Homepage: http://www.geneontology.org/
[Gen08]
Glossar chemischer Begriffe. (2008). Abgerufen am 6. November 2008
von General Chemistry Online:
http://antoine.frostburg.edu/chem/senese/101/index.shtml
[Häd06]
Hädener, A., & Kaufmann, H. (2006). Grundlagen der organischen
Chemie. Basel: Birkhäuser Verlag.
[Hag80]
Hagenstein, Cleve, Hoyer, & Seeger. (1980). Chemie - Funktionelle
Gruppen.
102
[Hel74]
Hellwinkel, D. (1974). Die systematische Nomenklatur der
Organischen Chemie. Berlin: Springer-Verlag.
[Hül08]
Hüllermeier, E. (2008). Vorlesung "Knowledge Discovery in
Structured Data: Methods and Applications in Bioinformatics".
Universität Marburg.
[Hüt06]
Hütt, M.-T., & Dehnert, M. (2006). Methoden der Bioinformatik - Eine
Einführung. Berlin Heidelberg: Springer Verlag.
[Jun94]
Jungnickel, D. (1994). Graphen, Netzwerke und Algorithmen.
Mannheim: BI-Wiss.-Verl.
[KEG08]
KEGG: Kyoto Encyclopedia of Genes and Genomes. (2008).
Abgerufen am 6. November 2008 von Kyoto Encyclopedia of Genes
and Genomes Homepage: http://www.genome.jp/kegg/
[Kel07]
Kelter, U. (2007). Begriffliche Grundlagen von Modelldifferenzen.
Lehrmodul Praktische Informatik. Universität Siegen.
[Kel071]
Kelter, U. (2007). Dokumentdifferenzen. Lehrmodul Praktische
Informatik. Universität Siegen.
[Kel05]
Kelter, U., Wehren, J., & Niere, J. (2005). A Generic Difference
Algorithm for UML Models. Software Engineering , S. 105-116.
[Koh07]
Kohlbacher, O. (2007). Vorlesung "Wirkstoffentwurf". Universität
Tübingen.
[Kro03]
Krone, O. (2003). Dokumentstruktur CML. Abgerufen am 6.
November 2008 von Diplomarbeit "Webfähige interaktive 3DVisualisierung von Proteinstrukturen: http://www-lehre.informatik.uniosnabrueck.de/~okrone/DIP/node30.html
[Lat08]
Latscha, H. P., Kazmaier, U., & Klein, H. A. (2008). Organische
Chemie - Basiswissen II. Berlin Heidelberg: Springer Verlag.
103
[Lip08]
Lipkus, A. H., Yuan, Q., Lucas, K. A., Funk, S. A., Bartelt III, W. F.,
Schenck, R. J., et al. (2008). Structural Diversity of Organic
Chemistry. A Scaffold Analysis of the CAS Registry. Journal of
Organic Chemistry , S. 4443-4451.
[Mod08]
Model of Entrez Databases. (2008). Abgerufen am 8. November 2008
von National Center of Biotechnology Information:
http://www.ncbi.nlm.nih.gov/Database/datamodel/index.html
[MOF07] MOF 2.0/XMI Mapping. (2007). Abgerufen am 7. November 2008 von
Object Management Group: http://www.omg.org/docs/formal/07-1201.pdf
[Mol96]
Molecular surface and volume. (1996). Abgerufen am 5. November
2008 von Computational Chemistry List:
http://www.ccl.net/cca/documents/molecular-modeling/node5.html
[Mor08]
More on Structured Data Format (SDF). (2008). Abgerufen am 5.
November 2008 von U.S. Environmental Protection Agency:
http://www.epa.gov/ncct/dsstox/MoreonSDF.html
[Mül05]
Müller, M. (2005). Funktionelle Gruppen und Verbindungsklassen.
Abgerufen am 8. November 2008 von ChemPage:
http://www.chempage.de/down/folien/foliefunkt.pdf
[Ohs041] Ohst, D. (2004). Differenz- und Mischwerkzeuge für UML. Interner
Bericht Praktische Informatik. Universität Siegen.
[Ohs04]
Ohst, D., Welle, M., & Kelter, U. (2003). Differences between
Versions of UML Diagrams. ACM SIGSOFT Software Engineering
Notes, (S. 227-236).
[Ope08]
Open Babel: The Open Source Chemistry Toolbox. (2008). Abgerufen
am 6. November 2008 von Open Babel Homepage:
http://openbabel.org/wiki/Main_Page
104
[Pol07]
Polanski, A., & Kimmel, M. (2007). Bioinformatics. Berlin
Heidelberg: Springer Verlag.
[Pro08]
Protein Data Bank Website. (2008). Abgerufen am 5. November 2008
von Worldwide Protein Data Bank: http://www.wwpdb.org/index.html
[Pub08]
PubChem Structure Search. (2008). Abgerufen am 5. November 2008
von National Center for Biotechnology Information:
http://pubchem.ncbi.nlm.nih.gov/search/search.cgi
[Rar98]
Rarey, M., & Dixon, J. S. (1998). Feature trees: A new molecular
similarity measure based on tree matching. Journal of Computer-Aided
Molecular Design , S. 471-490.
[Sch07]
Schmidt, M. (2007). SiDiff: generische, auf Ähnlichkeiten basierende
Berechnung von Modelldifferenzen. Praktische Informatik. Universität
Siegen.
[Str96]
Strazewski, P. (1996). Ausgewählte funktionelle Gruppen. Abgerufen
am 6. November 2008 von Vorlesungsunterlagen in organischer und
bioorganischer Chemie Universität Basel:
http://www.chemie.unibas.ch/~strazi/FunktionelleGruppen.pdf
[Tre07]
Treude, C. (2007). Einsatz multidimensionaler Suchstrukturen zur
Optimierung der Bestimmung von Dokumentdifferenzen. Praktische
Informatik. Universität Siegen.
[Ull76]
Ullmann, J. R. (1976). An Algorithm for Subgraph Isomorphism.
Journal of the ACM (JACM) , S. 31-42.
[Val97]
Valiente, G., & Martínez, C. (1997). An algorithm for graph patternmatching. Universität Bremen/Technical University of Catalonia.
[Var07]
Varró, G., Horváth, Á., & Varró, D. (2007). Recursive Graph Pattern
Matching With Magic Sets and Global Search Plans. Budapest
University of Technology and Economics.
105
[Var061]
Varró, G., Varró, D., & Schürr, A. (2006). Incremental Graph Pattern
Matching. Budapest University of Technology and
Economics/Technical University of Darmstadt.
[Var06]
Varró, G., Varró, D., & Schürr, A. (2006). Incremental Graph Pattern
Matching: Data Structures and Initial Experiments. Budapest
University of Technology and Economics/Technical University of
Darmstadt.
[VIA08]
VIATRA2 Project Overview. (2008). Abgerufen am 7. November 2008
von VIATRA2 Homepage:
http://dev.eclipse.org/viewcvs/indextech.cgi/gmthome/subprojects/VIATRA2/index.html
[Weh04]
Wehren, J. (2004). Ein XMI-basiertes Differenzwerkzeug für UMLDiagramme. Praktische Informatik. Universität Siegen.
[Wes05]
Weskamp, N., Hüllermeier, E., Kuhn, D., & Klebe, G. (2007).
Multiple Graph Alignment for the Structural Analysis of Protein
Active Sites. IEEE/ACM Transactions on Computational Biology and
Bioinformatics (TCBB), (S. 310-320).
[Wie04]
Wiedmann, V. (2004). Hydrophobizität und Hydrophilität. Abgerufen
am 6. November 2008 von Lehrstuhl Bioinformatik Ruprecht-KarlsUniversität Heidelberg: http://www.bioinformatikwegweiser.de/Hydrophobizitaet.html
[Zim00]
Zimmermann, M., Rarey, M., & Lengauer, T. (2000). Multiple Feature
Trees: Virtuelles HTS auf der Basis mehrerer Anfragemoleküle. St.
Augustin.
106
ERKLÄRUNG
Hiermit versichere ich, dass ich die vorliegende Arbeit selbständig verfasst und keine
anderen als die angegebenen Quellen und Hilfsmittel benutzt habe, insbesondere keine anderen als die angegebenen Informationen aus dem Internet.
Diejenigen Paragraphen der für mich gültigen Prüfungsordnung, welche etwaige
Betrugsversuche betreffen, habe ich zur Kenntnis genommen.
Der Speicherung meiner Diplom-Arbeit zum Zweck der Plagiatsprüfung stimme
ich zu. Ich versichere, dass die elektronische Version mit der gedruckten Version inhaltlich übereinstimmt.
.........................................
(Ort, Datum)
.....................................................................
(Unterschrift des Verfassers)
107

Volltext - Praktische Informatik

Transcription

Similar documents

Schritt für Schritt - Datenaustausch mit DWG, DXF

Kontaktallergie – neue Konzepte zur Gefahren

Einführung in die Computerchemie

RD-M760 RD-M580

Teil 6: Relationale Algebra

Seminarband - Lehrgebiet Datenbanksysteme für neue Anwendungen

Über eine Brücke musst du gehen!

WH-R550 - FA Technik

WH-7850-C24-TU WH-7850-C50-TU

bachelorarbeit - Institut für Physik