Embed Size (px)
Citation preview
Christoph Kurek Rheinaustr. 11 68163 Mannheim E-Mail: [email protected] Studiengang Wirtschaftsinformatik Matrikelnummer 5470491 Erstgutachter: Dr. Guido Gryczan Zweitgutachter: Prof. Dr. Norbert Ritter 04.10.2011
Universität Hamburg Fachbereich Informatik Arbeitsbereich Softwaretechnik
Diplomarbeit
Ein Vergleich der Methoden automatisierter Dublettenerkennung.
Inhaltsverzeichnis
1 Einleitung ..........................................................................................................................................1
1.1 Motivation ..................................................................................................................... 1
1.2 Zielsetzung ..................................................................................................................... 2
1.3 Aufbau ........................................................................................................................... 2
2 Grundlagen der Dublettenerkennung ..............................................................................................4
2.1 Einordnung und Relevanz des Problems ....................................................................... 4
2.2 Formale Definition......................................................................................................... 6
2.3 Ein iterativer Algorithmus zur Dublettenerkennung ..................................................... 7
2.4 Fokus der Arbeit und Einschränkung des Problems ...................................................... 8
3 Ähnlichkeitsbestimmung ..................................................................................................................9
3.1 Token-basierte Ähnlichkeitsfunktionen ...................................................................... 10
3.1.1 Jaccard-Ähnlichkeit ............................................................................................. 11
3.1.2 Cosinus-Ähnlichkeit mit tf/idf Gewichtung ......................................................... 12
3.2 Edit-basierte Ähnlichkeitsfunktionen .......................................................................... 15
3.2.1 Levenshtein und Needleman-Wunsch Distanz ................................................... 15
3.2.2 Affine Gapkosten, Smith-Waterman und Smith-Waterman-Gotoh Distanz ....... 16
3.2.3 Jaro und Jaro-Winkler Distanz ............................................................................. 17
3.3 Hybride Ähnlichkeitsfunktionen .................................................................................. 19
3.3.1 Erweiterte Jaccard Ähnlichkeit ............................................................................ 19
3.3.2 Monge-Elkan Ähnlichkeit .................................................................................... 20
3.3.3 Soft tf/idf Ähnlichkeit .......................................................................................... 21
4 Dublettenbestimmung .................................................................................................................. 23
4.1 Ähnlichkeitsbasierte Entscheidungsverfahren ............................................................ 24
4.1.1 „Ein Attribut“ Verfahren ...................................................................................... 25
4.1.2 Durchschnittverfahren ........................................................................................ 25
4.2 Probabilistische Entscheidungsverfahren ................................................................... 26
4.2.1 Bayes-Entscheidungsregel der kleinsten Fehlerrate ........................................... 26
4.2.2 Die kostenoptimale Bayes-Entscheidungsregel .................................................. 27
4.2.3 Die Klasse der möglichen Dubletten ................................................................... 28
4.3 Maschinelles Lernen .................................................................................................... 28
4.3.1 Entscheidungsbäume .......................................................................................... 29
4.3.2 Support Vector Machine ..................................................................................... 30
4.3.3 Nächste-Nachbarn-Klassifikation ........................................................................ 32
4.3.4 Künstliche neuronale Netze ................................................................................ 33
4.4 Erfolgsmessung der Dublettenerkennung .................................................................. 36
5 Anforderungen, Vorgehensweise und Versuchsaufbau ............................................................... 39
5.1 Die Datenbasis ............................................................................................................. 39
5.2 Anforderungen an die Umsetzung der Evaluation ...................................................... 41
5.2.1 Ähnlichkeitsbestimmung ..................................................................................... 42
5.2.2 Dublettenbestimmung ........................................................................................ 42
5.2.3 Erfolgsmessung ................................................................................................... 43
5.3 Evaluationsimplementierung ...................................................................................... 43
5.3.1 Ähnlichkeitsbestimmung ..................................................................................... 43
5.3.2 Dublettenbestimmung und Erfolgsmessung ....................................................... 47
6 Durchführung und Ergebnisse der Evaluation .............................................................................. 50
6.1 Ähnlichkeitsbestimmung ............................................................................................. 50
6.2 Dublettenbestimmung ................................................................................................ 51
6.2.1 Naive Bayes ......................................................................................................... 52
6.2.2 Entscheidungsbäume .......................................................................................... 53
6.2.3 Support Vector Machine ..................................................................................... 54
6.2.4 Nächste-Nachbarn-Klassifikation ........................................................................ 55
6.2.5 Künstliche neuronale Netze ................................................................................ 55
6.3 Erfolgsmessung und Ergebnisanalyse ......................................................................... 56
6.3.1 Erfolgsmessung bei dem ähnlichkeitsbasierten Entscheidungsverfahren .......... 56
6.3.2 Erfolgsmessung bei dem Verfahren des maschinellen Lernens .......................... 57
6.3.3 Analyse und Beurteilung der Ergebnisse ............................................................. 58
6.3.4 Analyse der Fehlerbilder ..................................................................................... 60
7 Zusammenfassung, Fazit und Ausblick .......................................................................................... 63
7.1 Zusammenfassung ....................................................................................................... 63
7.2 Fazit ............................................................................................................................. 64
7.3 Ausblick ....................................................................................................................... 64
Anhang A ............................................................................................................................................... 65
Anhang B ............................................................................................................................................... 67
Anhang C ............................................................................................................................................... 72
Anhang D ............................................................................................................................................... 73
Literaturverzeichnis ............................................................................................................................... 74
Eidesstattliche Erklärung ....................................................................................................................... 79
1
1 Einleitung
Durch die ständig wachsende Menge an Daten in der Datenverarbeitung ergeben sich
zwangsläufig Datenqualitätsprobleme. Eines der sehr häufig anzutreffenden Probleme dieser
Art sind Dubletten. Als Dubletten bezeichnet man verschiedene Datensätze, die dasselbe
Realweltobjekt repräsentieren [vgl. Elma07, S.1]. In dieser Arbeit geht es um die Methoden der
automatischen Erkennung von Dubletten und einen Vergleich dieser Methoden, sowohl
untereinander als auch gegenüber einer manuellen Dublettenerkennung.
1.1 Motivation
Das Entstehen von Dubletten kann unerwünscht sein, wenn es sich um mehrfach geführte
Kunden in einem Kundenmanagementsystem, verschiedene Repräsentationen eines Produkts
in einer Produktdatenbank oder doppelt gebuchte Bestellungen handelt. Die Ursachen,
weshalb es zu unerwünschten Dubletten kommt, sind vielfältig und können sowohl auf
maschinelle Vorgänge wie Datenintegration in einem Data Warehouse, als auch auf manuelle
Erfassung von Daten, beispielsweise am Telefon, zurückgeführt werden. Die Folgen sind oft
nicht unerhebliche wirtschaftliche Schäden. So kann es zum Beispiel zur doppelten
Aussendung eines Kundenkatalogs an den gleichen Empfänger oder zur unnötigen
Lagerhaltung identischer Ersatzteile kommen. Eine aufgrund schlechter Daten verfälschte
Auswertung und die daraus folgenden falschen, strategischen Entscheidungen können sehr
weitreichende Folgen haben. Aus diesen Gründen ist Dublettenerkennung eine wichtige
Maßnahme bei der Sicherung der Datenqualität.
Dublettenerkennung kann bei der Erfassung neuer Daten erfolgen, indem ein neu erfasster
Datensatz online mit den existierenden Datensätzen abgeglichen wird. Als Folge wird dem
Benutzer eine Liste möglicher Dubletten präsentiert. Dieser kann dann entscheiden, ob der
neue Datensatz angelegt werden soll, oder dieser bereits existiert. In bereits existierenden
Datenquellen erfolgt meistens ein Batchlauf, in dem Dubletten möglichst automatisch erkannt
werden sollen. Das Ziel dabei ist es, die Eingriffe von Benutzern möglichst gering zu halten.
Auch eine Suche nach Dubletten zwischen zwei verschiedenen Quellen kann sinnvoll sein, um
eine Verknüpfung der Daten zu erreichen. Dadurch ergibt sich eine Datenanreicherung und
somit einen Informationsgewinn. Ein Beispiel dafür könnte der Abgleich der Daten eigener
Kunden mit den Daten einer Insolvenzdatenbank sein, um so zahlungsunfähige Kunden zu
identifizieren und weitere Geschäfte mit diesen zu verhindern.
Unter Dublettenerkennung versteht man prinzipiell einen paarweisen Vergleich von
Datensätzen. Als Ergebnis des Vergleichs ergeben sich eine oder mehrere Maßzahlen für die
Ähnlichkeit von Datensatzpaaren. Die Identität eines Datensatzpaares ist das trivialste Maß
und allein für die Dublettenerkennung wenig geeignet [vgl. Naum10, S.1]. Vielmehr müssen
Ähnlichkeiten zwischen eventuell leicht unterschiedlichen Attributwerten der Datensätze
ermittelt werden. Sind diese Ähnlichkeiten ausreichend groß, so spricht man von einer
Dublette. Um die Entscheidung zu treffen, ob die Ähnlichkeit ausreichend groß ist, bedient
2
man sich Entscheidungsverfahren aus dem Bereich der Wahrscheinlichkeitstheorie oder des
maschinellen Lernens.
Methoden der Dublettenerkennung sollen in erster Linie effektiv, also von hoher Qualität sein.
Ziel ist es, möglichst viele der tatsächlich vorhandenen Dubletten zu finden. Gleichzeitig sollen
möglichst wenige Datensätze als Dubletten erkannt werden, die keine Dubletten sind. Hier
spielen das gewählte Ähnlichkeitsmaß und die Entscheidungsmethodik eine entscheidende
Rolle. Die Messung der Effektivität einer Dublettenerkennungsmethode ist kein triviales
Unterfangen. Um dies zu bewerkstelligen, muss man die Dublettenzuordnungen bereits
kennen. Es gibt es kaum frei zugängliche Quellen, bei denen die Zuordnungen, auch golden
standard genannt, bekannt sind. Es liegt zum einen daran, dass „echte“ Daten, zum Beispiel in
Form von großen Adressdatenbanken, oft dem Datenschutz beziehungsweise einem
Betriebsgeheimnis unterliegen. Zum anderen ist die Bestimmung der Dublettenzuordnungen
ein zumindest teilmanueller und deshalb aufwendiger Prozess. Diese Zuordnung für größere
Datenbestände zu bestimmen, kann hunderte von Arbeitsstunden an Aufwand bedeuten [vgl.
Naum10, S.65f].
1.2 Zielsetzung
Das Ziel dieser Arbeit ist ein Vergleich aktueller Methoden der Dublettenerkennung. Als
Grundlage dazu dient ein großer Bestand deutscher Geschäftsadressen, die über Jahre manuell
sorgfältig auf die Darstellung des gleichen Realweltobjekts, in dem Fall einer Firma, geprüft
wurden. Mithilfe dieses Datenbestands ist es möglich zu prüfen, mit welchen automatisierten
Methoden der Dublettenerkennung ein ähnlich gutes Ergebnis wie bei der manuellen Prüfung
erzielt werden kann. Am Ende soll die Frage beantwortet werden, welche Methoden der
Dublettenerkennung innerhalb der speziellen Domäne der Geschäftsadressen die höchste
Effektivität besitzen, um diese Daten automatisch auf Dublettenzuordnungen zu prüfen. Auch
die manuellen Dublettenzuordnungen sollen überprüft werden und die hier erzielten
Fehlerquoten mit den Fehlerquoten der automatischen Methoden verglichen werden. Neben
dieser zentralen Fragestellungen ergeben sich weitere Nebenfragen, wie zum Beispiel ob es
wirklich signifikante Unterschiede zwischen den Methoden gibt. Des Weiteren soll geprüft
werden, inwiefern sich der Prozess der Dublettenfindung automatisieren oder der in vielen
Fällen hohe manuelle Aufwand zumindest deutlich reduzieren lässt, ohne Einbußen bei der
Qualität.
1.3 Aufbau
Im zweiten Kapitel dieser Arbeit werden die Bedeutung und Einordnung der
Dublettenerkennung als eine Datenqualitätsmaßnahme beschrieben und der Fokus der Arbeit
verdeutlicht. Im Kapitel drei werde ich die verschiedenen Methoden und Algorithmen für
Ähnlichkeitsmaße zur Messung der Ähnlichkeit von Zeichenketten vorstellen, die für die
Ähnlichkeitsbestimmung von Attributwerten eingesetzt werden. Das vierte Kapitel stellt
Methoden der Dublettenbestimmung vor, das heißt die Methoden der Entscheidung, ob es
3
sich bei den gegebenen Datensätzen um eine Dublette handelt oder nicht. Hier liegt der
Schwerpunkt auf den Methoden des maschinellen, überwachten Lernens. Auch die Methoden
zur Messung des Erfolgs dieser Entscheidungen werden vorgestellt, da diese ein zentrales
Instrument zum Vergleich der Methoden der Dublettenerkennung sind. Kapitel fünf beschreibt
die Vorgehensweise bei der Evaluation und den verwendeten Versuchsaufbau. Es wird zuerst
die Datenbasis für die Evaluation vorgestellt. Anschließend widme ich mich den Anforderungen
an den Aufbau der Evaluation. Schließlich erläutere ich, wie diese Anforderungen umgesetzt
wurden und beschreibe die dabei entstandenen Implementierungen. Im Kapitel sechs geht es
um die Durchführung der Evaluation und die dabei entstandenen Ergebnisse. Bei der
Beschreibung der Durchführung gehe ich insbesondere auf die verwendeten Methoden und
deren Konfiguration. Danach erläutere ich die bei der Erfolgsmessung der Dublettenerkennung
entstandenen Ergebnisse. Dabei liegt der Fokus auf dem Vergleich der manuellen und der
automatisierten Dublettenerkennung. Anschließend stelle ich die entstandenen Fehlerbilder
der automatisierten Dublettenerkennung vor und zeige mögliche Lösungen für die Fehler auf.
Kapitel sieben fasst die gesamte Evaluation zusammen. Hier werde ich ein Fazit aus den
ermittelten Ergebnissen ziehen und versuche einen Ausblick auf die mögliche Fortführung der
Arbeit, basierend auf den erzielten Ergebnissen, zu geben.
4
2 Grundlagen der Dublettenerkennung
Im folgenden Kapitel werde ich das Problem der Dublettenerkennung genau definieren. In
Kapitel 2.1 beschreibe ich die Dublettenerkennung als eine Maßnahme zur Verbesserung der
Daten- und Informationsqualität und verdeutliche die wirtschaftliche Relevanz des Themas
mithilfe von Beispielen. In Kapitel 2.2 werden der Input und der Output einer
Dublettenerkennung formal definiert. In Kapitel 2.3 wird die Vorgehensweise einer iterativen
Dublettenerkennung vorgestellt. In Kapitel 2.4 schließlich schränke ich das Thema ein und gehe
auf die in dieser Arbeit adressierte Problemstellung genauer ein.
2.1 Einordnung und Relevanz des Problems
Bei der Dublettenerkennung geht es um die Identifizierung unterschiedlicher Datensätze, die
dasselbe, eindeutige Realweltobjekt repräsentieren [vgl. Elma07, S.1].
ID Vorname Nachname Telefonnummer E-Mail
1 Max Mustermann +49 (40) 123456 [email protected]
2 Max Mustermann +49 (40) 123456 [email protected]
3 Max Münstermann 040/123456 [email protected] Tabelle 1 Ein Beispiel für Dubletten.
Die Tabelle 1 zeigt ein Beispiel für Dublettendatensätze, kurz Dubletten genannt. Die
Datensätze mit ID 1 und ID 2 sind exakte Dubletten. Sie sind über alle Attributwerte, außer
dem Wert für Primärschlüssel ID, identisch. Der Datensatz mit ID 3 repräsentiert offensichtlich
dasselbe Realweltobjekt wie die Datensätze 1 und 2, ist aber nicht mit diesen identisch. Es
handelt sich um eine unscharfe Dublette. Das Erkennen von exakten Dubletten ist relativ trivial
und lässt sich mithilfe einer einfachen Sortierung problemlos realisieren [vgl. Naum10, S.1].
Das Erkennen von unscharfen Dubletten ist hingegen ein komplexer Prozess, der den
Schwerpunkt dieser Arbeit bildet.
Dublettenerkennung ist kein neuer Forschungszweig. Einer der ersten Definitionen, hier unter
dem Begriff „automatic record linkage“, wurde bereits im Jahr 1959 verfasst [vgl. Newc59].
Dublettenerkennung gehört zu dem Forschungsbereich Informations- und Datenqualität.
Qualität wird von Juran als Gebrauchstüchtigkeit (fitness for use), bezeichnet [vgl. Jura91,
S.14]. Diese Definition wird für den Bereich Datenqualität zum Beispiel von Wang [vgl.
Wang96] angewendet. Desweitern werden in [Wang96] 15 Dimensionen der
Informationsqualität definiert. Diese Definition der Dimensionen wurde 2007 von der DGIQ
e.V. (Deutsche Gesellschaft für Informations- und Datenqualität e.V.) ins Deutsche übertragen
[vgl. DGIQ07]. Diese Übertragung ist in Abbildung 1 dargestellt.
5
Abbildung 1 15 Dimensionen der Informationsqualität [DGIQ07].
Das Ziel der Dublettenerkennung ist die Erhöhung der Informationsqualität in den
Dimensionen der Fehlerfreiheit und Vollständigkeit. Fehlerfreiheit wird definiert als die
Übereinstimmung der Informationen mit der Realität. Dies wird durch die Dublettenerkennung
verbessert, da hierdurch die redundanten Repräsentationen eines Realweltobjekts aufgedeckt
werden. Vollständigkeit wird verbessert, da die gefundenen Dubletten oft unterschiedliche
Informationen über ein Realweltobjekt enthalten, die zusammen eine vollständigere Abbildung
des Objekts ergeben.
Dass mangelnde Informationsqualität und insbesondere Dubletten wirtschaftlichen Schaden
verursachen können, sollen folgende Beispiele verdeutlichen:
Ein Versandhändler versendet regelmäßig Kataloge an Kunden. Durch Dubletten im
Kundenstamm entstehen unnötige Kosten für Druck und Versand. Doppelt mit
Katalogen belieferte Kunden zweifeln an dem Qualitätsmanagement des
Unternehmens, was einen Imageschaden für das Unternehmen zu Folge hat.
Ein Handelsunternehmen gewährt seinen Kunden einen Kreditrahmen. Dubletten in
einer Kundendatenbank können dazu führen, dass ein Kunde den Kreditrahmen
mehrfach ausschöpft. Im Falle einer Insolvenz des Kunden drohen hohe
Forderungsausfälle. Ein zusätzlicher Abgleich der Kundendaten mit Daten der
Insolvenzmeldungen kann verhindern, dass Geschäfte mit bereits insolventen
Unternehmen getätigt werden.
Ein Maschinenbauunternehmen bestellt ein wichtiges Ersatzteil für eine Maschine, da
dieses offensichtlich nicht auf Lager ist. Durch eine Dublette im Materialstamm wurde
leider übersehen, dass das benötigte Teil doch auf Lager ist, aber unter einer
Bezeichnung, die einen Tippfehler enthält. Es kommt zu unnötigen
Produktionsverzögerungen, zusätzlich zu unnötigen Lagerkosten und Kapitalbindung.
6
Die Liste lässt sich beliebig fortsetzen. Fazit ist, dass das Problem der Dubletten von hoher
wirtschaftlicher Relevanz ist.
2.2 Formale Definition
Um das Thema der Dublettenerkennung formal zu definieren, ist es nötig mit
Grunddefinitionen des relationalen Modells anzufangen [vgl. Naum10, S.13f].
Als Grundlage für eine Dublettenerkennung dient eine Relation R. Die Relation R besitzt ein
Schema SR, das aus einer Menge von Attributen besteht: { }. Jeder Datensatz
d, der in einer Relation R gespeichert ist, ordnet jedem Attribut einen Wert w zu. Somit kann
man einen Datensatz als eine Menge von Werten definieren: { } oder eine
Menge von Attribut-Wert Paaren: {( ) ( ) ( )}.
Ich nehme im Rahmen dieser Arbeit an, dass alle Datensätze, die für die Dublettenerkennung
relevant sind, diesem Schema entsprechen. Aufgrund der Komplexität wird die
schemaübergreifende Dublettenerkennung und Dublettenerkennung in komplexen Relationen,
wie zum Beispiel 1:n verknüpfte Relationen, ausgeklammert. Ich nehme an, dass
gegebenenfalls im Vorfeld eine Datenvorbereitung im Sinne von Parsen, Transformation und
Standardisierung, bereits stattgefunden hat. Solche Datenaufbereitung bezeichnet man häufig
mit dem Begriff ETL (Extaction, Transformation, Loading) [vgl. Elma07].
Aus der Menge der Datensätze wird eine Untermenge als Dublettenkandidaten bestimmt. Dies
können alle Datensätze der Relation sein oder nur eine Teilmenge, zum Beispiel alle seit der
letzten Dublettenerkennung veränderten Datensätze. So erhält man eine Menge von
Kandidaten aus einer Relation R: { } .
Nicht alle Attribute einer Relation sind für eine Dublettenerkennung relevant. Künstliche
Primärschlüssel, wie zum Beispiel im Kapitel 2.1 in der Tabelle 1 das Attribut ID, sind für die
Dublettenerkennung irrelevant. So werden für die Dublettenerkennung relevanten Attribute
als Projektion der Menge SR bestimmt. Diese Beschreibung eines Kandidaten k definiere ich als
( ) {( ) ( ) ( )} beziehungsweise ( ) { }. Die Menge
der entsprechend definierten Kandidaten wird als Input für den Dublettenerkennungsprozess
verwendet.
Das Ziel einer Dublettenerkennung ist eine Partitionierung der Kandidaten. Jede der
Partitionen enthält demnach nur die Kandidaten, die dasselbe Realweltobjekt repräsentieren.
Als Notation für die Partitionierung der Kandidaten verwende ich .
Um die Notation zu veranschaulichen, wende ich diese Notation auf das Beispiel der Relation
aus Kapitel 2.1, Tabelle 1 an. Diese hat das folgende Schema:
{ }
Die Relation enthält drei Datensätze. Ich Definiere beispielhaft den ersten Datensatz:
{ }
7
Für den Abgleich werden alle Datensätze als Kandidaten verwendet:
{ }
Da ich das Attribut ID für den Abgleich nicht verwende, ergibt sich folgende Beschreibung für
den Kandidaten 1:
( ) { }
Nach der Durchführung des Abgleichs ergibt sich folgende Partitionierung der Kandidaten:
{( )}
Es gibt also nur eine Partition, da alle Kandidaten das gleiche Realweltobjekt repräsentieren.
2.3 Ein iterativer Algorithmus zur Dublettenerkennung
Im Kapitel 2.2 habe ich den Input und den Output einer Dublettenerkennung definiert. Um
eine Partitionierung der Kandidaten zu erreichen, geht man üblicherweise nach dem Schema
eines iterativen Dublettenerkennungsalgorithmus vor [vgl. Naum10, S.15]. Zuerst werden von
einem Algorithmus Kandidatenpaare (k1, k2) bestimmt, für die im zweiten Schritt eine
Ähnlichkeit sim(k1, k2) berechnet wird. Es ist eine Funktion, die zwei Kandidaten als Parameter
nimmt und als Ergebnis eine Ähnlichkeit liefert, meistens eine Zahl zwischen 0 und 1. Bei
mehreren Attributen ist es möglich, die Ähnlichkeiten pro Attribut zu bestimmen, was als
Ergebnis mehrere Ähnlichkeiten in Form eines Vektors liefert. Je nach definiertem
Schwellenwert θ für die Ähnlichkeit, kann die Entscheidung getroffen werden, ob zwei
Kandidaten eine Dublette darstellen, das heißt, ob sie dasselbe Realweltobjekt repräsentieren.
Formal würde man sagen, dass zwei Kandidaten (k1, k2) eine Dublette sind, wenn sim(k1, k2) > θ
ist. Im Falle der Ähnlichkeitsmessung pro Attribut bei mehreren Attributen ist eine
Dublettenentscheidung komplexer. Hier bedient man sich zum Beispiel der Methoden der
Wahrscheinlichkeitsrechnung oder des maschinellen Lernens. In der Praxis ist es schwierig,
eine solche Entscheidung automatisch zu treffen. Deswegen wird oft ein bestimmter Bereich
bestimmt, in dem ein menschlicher Experte die endgültige Entscheidung treffen muss. Doch
trotz dieser Maßnahme ist es in der Praxis sehr schwierig, ein perfektes Ergebnis zu erreichen,
das auch als golden standard bezeichnet wird. Es kann dazu kommen, dass manche Dubletten
nicht entdeckt werden, da diese eine zu geringe Ähnlichkeit zueinander aufweisen. Dieses
Fehlerbild bezeichnet man als false negatives. Umgekehrt kann es dazu kommen, dass zwei
Datensätze trotz hoher Ähnlichkeiten der Attributwerte keine Dubletten sind. Hier spricht man
von false positives. Den letzten Schritt bildet die Bestimmung der Transitivität und Erzeugung
der Partitionierung. Per Definition repräsentieren zwei Datensätze, die als Dubletten erkannt
wurden, dasselbe Realweltobjekt. Wenn also A eine Dublette von B ist und B eine Dublette von
C, dann ist auch A eine Dublette von C, da A, B und C dasselbe Realweltobjekt repräsentieren
[vgl. Naum10, S.15]. Wenn man das Modell der Kandidaten und Dublettenpaare als einen
Graphen betrachtet, mit Kandidaten als Knoten und den Kanten als Dublettenbeziehungen,
8
dann erhält man durch die Bestimmung der transitiven Hülle die gewünschte Partitionierung.
Die nachfolgende Abbildung 2 zeigt schematisch den beschriebenen Ablauf.
Abbildung 2 Ein prototypischer Ablauf einer Dublettenerkennung.
2.4 Fokus der Arbeit und Einschränkung des Problems
Wie im Kapitel 1.2 beschrieben, ist das Ziel dieser Arbeit die Bestimmung der besten
Dublettenerkennungsmethodik für die vorliegende Domäne der Daten, in diesem Fall der
deutschen Geschäftsadressen. Aufgrund der Beschaffenheit der Daten und der Komplexität
des gesamten Dublettenerkennungsalgorithmus, konzentriere ich mich in dieser Arbeit auf die
zwei zentralen Schritte der Dublettenerkennung: die Bestimmung der Ähnlichkeit der
Attributwerte und die Entscheidung, ob es sich bei den Kandidatenpaar um eine Dublette
handelt oder nicht. Die für die Evaluation im Rahmen dieser Arbeit zur Verfügung stehenden
Daten liegen als Datensatzpaare vor, zusammen mit einer Markierung, die beschreibt, ob es
sich um ein Dublettenpaar handelt oder nicht. Somit ist die Auswahl der Kandidaten bereits
getroffen. Des Weiteren stammen die Datenpaare nicht aus einer Quelle, womit die
Bestimmung der Partitionen hier ebenfalls nicht möglich beziehungsweise sinnvoll ist. In den
folgenden beiden Kapiteln stelle ich die Methoden der Ähnlichkeitsbestimmung für
Attributwerte und der Dublettenbestimmung auf der Basis dieser Ähnlichkeiten vor.
Relation R
Algorithmus zur Auswahl von Kandidatenpaaren (k1, k2)
Bestimmung der Ähnlichkeit der Attribute sim(k1, k2)
Entscheidung, ob das Kandidatenpaar (k1, k2) eine Dublette ist.
Bestimmung zusammenhängender Komponenten
Partitionierung
9
3 Ähnlichkeitsbestimmung
Wie in Kapitel 2.3 vorgestellt, wird vor der Klassifizierung zweier Kandidaten als „Dublette“
oder „nicht Dublette“ zuerst eine Ähnlichkeitsfunktion verwendet, um die Ähnlichkeit der
einzelnen Attributwerte zu bestimmen. In den meisten Fällen sind die Attributwerte
Zeichenketten oder werden als solche behandelt. Deswegen konzentriere ich mich in diesem
Kapitel auf Ähnlichkeitsfunktionen für Zeichenketten.
In diesem Kapitel werden die wichtigsten Ähnlichkeitsfunktionen für Zeichenketten vorgestellt.
Diese Ähnlichkeitsfunktionen ermöglichen es, Zeichenketten auf Ihre Ähnlichkeit zu
überprüfen, konkreter ausgedrückt, deren typographischen Abweichungen numerisch zu
bewerten. Einige der hier beschriebenen Funktionen sind Distanzfunktionen, denn diese
messen den Abstand zweier Zeichenketten. Bei einer Ähnlichkeitsfunktion sind zwei
Zeichenketten umso ähnlicher, je höher deren berechnete Ähnlichkeit ist. Bei einer
Distanzfunktion, im Gegensatz zur Ähnlichkeitsfunktion, sind zwei Zeichenketten umso
ähnlicher, je geringer die Distanz ist. Eine Umrechnung der Distanz in eine Ähnlichkeit ist
problemlos Möglich und wird in diesem Kapitel ebenfalls vorgestellt. Zur Vereinfachung
verwende ich im Rahmen dieser Arbeit die einheitliche Bezeichnung Ähnlichkeitsfunktionen.
Die Ähnlichkeitsfunktionen für Zeichenketten kann man nach ihrer grundlegenden
Funktionsweise in drei Klassen aufteilen. Im Kapitel 3.1 stelle ich die Token-basierten
Ähnlichkeitsfunktionen, die als Input eine Menge von Tokens entgegennehmen. Kapitel 3.2
beschreibt die Edit-basierten Ähnlichkeitsfunktionen, die direkt auf Zeichenketten arbeiten
und die Kosten der Edit-Operationen berechnen. Die beiden Klassen lassen sich auch zu
sogenannten hybriden Ähnlichkeitsfunktionen kombinieren, die in Kapitel 3.3 vorgestellt
werden.
Die Auswahl der konkreten Algorithmen, die in diesem Kapitel beschrieben werden, erfolgte
auf Basis einer Literaturstudie, insbesondere [Elma07] und [Naum10]. Die dort vorgestellten
Algorithmen kommen bei der im Rahmen dieser Arbeit durchgeführten Evaluation zum Einsatz.
Abbildung 3 zeigt den Überblick über die angesprochenen Klassen der Ähnlichkeitsfunktionen
und die entsprechende Zuordnung der in den folgenden Kapiteln beschriebenen Algorithmen.
Die jeweils eng verwandten Algorithmen werden gemeinsam in einem Kapitel vorgestellt.
10
Abbildung 3 Die Hierarchie der Zeichenkettenähnlichkeitsfunktionen.
3.1 Token-basierte Ähnlichkeitsfunktionen
Der erste Schritt eines Token-basierten Ähnlichkeitsalgorithmus ist es, eine Zeichenkette in
eine Menge von Tokens, auch atomic strings genannt [vgl. Mong96], zu zerlegen. Für die
Funktion, die eine Zeichenkette in eine Menge von Tokens überführt, verwende ich die
Notation tokenize(.). Die einfachste Möglichkeit, eine Zeichenkette in Tokens zu zerlegen, ist
die Verwendung von Satzzeichen, vor allem Leerzeichen [vgl. Mong96]. Nach diesem Prinzip
wurde eine Zerlegung der Zeichenkette „Angelina Jolie“ zur folgenden Menge an Tokens
führen: {Angelina, Jolie}. Die Satzzeichen werden bei der Zerlegung weggelassen. Man kann
innerhalb der tokenize(.) Funktion noch weitere Normierungen vornehmen, wie zum Beispiel
die Überführung in Kleinbuchstaben. Weitere Maßnahmen wären die Entfernung bestimmter
häufiger Wörter, der sogenannten stopwords, oder die Eliminierung von häufigen
Abkürzungen. Diese Maßnahmen sind aber nur domainspezifisch möglich, da diese unter
anderem von der verwendeten Sprache abhängen.
Ähnlichkeitsfunktionen
Token-basierte
Jaccard Ähnlichkeit
Cosinus-Ähnlichkeit mit tf/idf Gewichtung
Edit-basierte
Levenshtein Distanz
Needleman-Wunsch Distanz
Affine Gapkosten Distanz
Smith-Watermann Distanz
Smith-Watermann-Gotoh Distanz
Jaro Distanz
Jaro-Winkler Distanz
Hybride
Erweiterte Jaccard Ähnlichkeit
Monge-Elkan Ähnlichkeit
Soft tf/idf Ähnlichkeit
11
Eine spezielle Form der Zerlegung in Tokens ist die Bildung von q-Grammen, in der Literatur
auch häufig n-Gramme genannt [vgl. Ullm77 und Ukko92]. Die so entstandenen Tokens haben
eine konstante Länge q. Außerdem überlappen sich so erzeugte Tokens, im Gegensatz zu der
Satzzeichen-Methode. Um eine Zeichenkette in q-Gramme zu zerlegen, verschiebt man ein
Fenster der Länge q über alle Zeichen der Zeichenkette jeweils um eins. Der Inhalt eines
solchen Fensters ist jeweils ein Token. Damit jedes Zeichen einer Zeichenkette, auch das erste
und das letzte, gleich häufig, in dem Fall q Mal, in der Menge der Tokens vorkommen, werden,
vorne und hinten an der Zeichenkette q-1 spezielle, im verwendeten Alphabet sonst nicht
vorkommende, Sonderzeichen angehängt [vgl. Grav01]. Als Beispiel zerlege ich die
Zeichenkette „Angelina Jolie“ in q-Gramme mit der Länge q=3, auch Trigramme genannt. Als
Sonderzeichen für den Anfang und das Ende der Zeichenkette verwende ich #. Zum
verdeutlichen von Leerzeichen ersetze ich diese durch _. Somit ergibt sich folgende Menge an
Trigrammen: {##A, #An, Ang, nge, gel, eli, lin, ina, na_, a_J, _Jo, Jol, oli, lie, ie#, e##}.
In den folgenden Unterkapiteln werde ich Ähnlichkeitsfunktionen vorstellen, die ermöglichen,
mithilfe von tokenize(.) Funktion erzeugten Tokens, die Ähnlichkeit zweier Zeichenketten zu
ermitteln.
3.1.1 Jaccard-Ähnlichkeit
Eine einfache und oft sehr effektive Token-basierte Metrik ist die Jaccard Ähnlichkeit [vgl.
Bile03]. Generell vergleicht die Jaccard Ähnlichkeit zwei Mengen mithilfe folgender Formel:
( ) | |
| |
Mit der Jaccard Ähnlichkeit wird das Verhältnis der Schnittmenge der Mengen S und T zu allen
Elementen der Vereinigungsmenge von S und T ausgedrückt. Im Kontext der
Dublettenerkennung sind die Mengen S und T Mengen von Tokens zweier Zeichenketten. Bei
gegebenen zwei Zeichenketten z1 und z2 und einer, wie in Kapitel 3.1 definierten Funktion
tokenize(.), ergibt sich folgende Formel für die Jaccard Ähnlichkeit:
( ) | ( ) ( )|
| ( ) ( )|
Hier zwei Beispiele für die Berechnung der Jaccard Ähnlichkeit:
Beispiel 1: Im ersten Beispiel verwende ich zwei Zeichenketten z1 = “Frau Angelina Jolie“ und z2
= “Herr Angelina Jolie“. Zudem verwende ich eine tokenize(.) Funktion, die, wie in Kapitel 3.1
beschrieben, Tokens als Wert erzeugt. Somit ergeben sich folgende Tokenmengen:
( ) { }
( ) { }
12
Die Vereinigung beider Mengen ergibt eine Anzahl von vier disjunkten Elementen. Die
Schnittmenge enthält zwei Elemente Angelina und Jolie. Somit ergibt sich folgende Jaccard
Ähnlichkeit:
( )
In diesem Beispiel erkennt man, dass schon die Veränderung eines Wortes, in dem Fall die
Anrede, die ermittelte Ähnlichkeit deutlich verringert. Dabei würde man intuitiv sagen, dass
nur ein Unterschied in der Anrede keine so starke Abwertung rechtfertigt. Das ist einer der
Nachteile der Jaccard Ähnlichkeit. Im nächsten Kapitel werde ich zeigen, wie man mithilfe der
Cosinus-Ähnlichkeit diesen Nachteil ausgleichen und dabei erreichen kann, dass offensichtlich
unwichtige Tokens geringer gewichtet werden. Ein Vorteil dieser Berechnung der Jaccard
Ähnlichkeit ist, dass die Wortreihenfolge keinen Einfluss auf den Wert der berechneten
Ähnlichkeit hat. Die kleinsten Unterschiede in der Schreibweise einzelner Wörter würden die
Ähnlichkeit jedoch massiv verringern. Dieser Nachteil lässt sich mit einer modifizierten
tokenize(.) Funktion ausgleichen, nämlich mit einer, die q-Gramme erzeugt, wie in Kapitel 3.1
beschrieben.
Beispiel 2: Ich verwende zwei Zeichenketten z1 = “Frau Angelina Jolie“ und z2 = “Herr Angelino
Yolie“. Bei dieser Zeichenkettenkombination würde sich mit der tokenize(.) Funktion aus
Beispiel 1 eine Jaccard Ähnlichkeit von null ergeben. Ich verwende eine tokenize(.) Funktion,
die q-Gramme mit q=3 (Trigramme) als Wert erzeugt. Hier ergeben sich folgende
Tokenmengen:
( )
{ }
( )
{ }
Die Vereinigung beider Mengen enthält eine Anzahl von 32 disjunkten Elementen. Die
Schnittmenge enthält zehn Elemente. Somit ergibt sich folgende Jaccard Ähnlichkeit:
( )
Die Jaccard Ähnlichkeit ist hier zwar noch geringer als im Beispiel 1, aber deutlich höher als
null. Somit wird deutlich, dass durch die Verwendung von q-Grammen eine Toleranz
gegenüber typografischen Fehlern erreicht werden kann. Techniken, die speziell diese Form
von Fehlern ansprechen, werde ich im Kapitel 3.2 vorstellen.
3.1.2 Cosinus-Ähnlichkeit mit tf/idf Gewichtung
Die Cosinus-Ähnlichkeit ist ein Ähnlichkeitsmaß, das aus dem Bereich des information retrieval,
zu Deutsch Informationsabruf, stammt. In [Cohe98] ist ein WHIRL genanntes Modell
beschrieben, das die Cosinus-Ähnlichkeit mit dem sogenannten tf-idf Gewichtungsschema
kombiniert, um die Ähnlichkeit zweier Zeichenketten zu berechnen.
13
Generell wird bei der Cosinus-Ähnlichkeit der Cosinus eines Winkels α zwischen zwei n-
dimensionalen Vektoren V und W berechnet:
( ) ( )
| | | |
|V| bezeichnet die Länge des Vektors V = [a,b,c,…], berechnet als √ . In der
Dublettenerkennung repräsentieren die Vektoren V und W Gewichte der Tokens der jeweils zu
vergleichenden Zeichenketten. Die Vektoren haben d Dimensionen, wobei d die disjunkte
Anzahl aller Tokens in allen Zeichenketten einer endlichen Domäne D ist. Diese Tokens
entstehen durch die Anwendung der tokenize(.) Funktion auf die Zeichenkette, die einen Wert
w eines Attributs a in einer Relation R darstellt.
Wie schon in Kapitel 3.1.1 angedeutet, liegt die Besonderheit der hier beschriebenen Cosinus-
Ähnlichkeit in der Gewichtung der Tokens. Dazu definiert man einen Termvektor T der Domäne
D, der ebenfalls d Dimensionen besitzt. Dieser Vektor beinhaltet ein Gewicht für jeden der
disjunkten Tokens aus D. Mit diesem Gewicht soll die Relevanz der einzelnen Tokens in
Verhältnis zu allen anderen Tokens in D ausgedrückt werden. Dazu wird die Tokenhäufigkeit-
inverse Dokumentenhäufigkeit, kurz tf-idf, als Maß verwendet. Zuerst definiere ich für die
einzelnen Komponenten Tokenhäufigkeit tf (term frequency) und inverse
Dokumentenhäufigkeit idf (inverse document frequency) [vgl. Cohe98].
Die Tokenhäufigkeit drückt aus, wie oft ein Token in einer Zeichenkette vorkommt und
beschreibt somit die Relevanz des Tokens innerhalb einer Zeichenkette. Innerhalb der
Definition heißt es, ein Token t ist enthalten im Wert w einer Kandidatenbeschreibung des
Kandidaten k, sodass (a,w) ϵ B(k), die Notation tft,k besitzt.
Inverse Dokumentenhäufigkeit bedeutet, dass jene Tokens eine höhere Gewichtung
bekommen, die in der Gesamtmenge aller Kandidatenbeschreibungen weniger häufig
vorkommen. Ziel dabei ist es, häufig vorkommende Tokens geringer zu gewichten, da diese für
die Unterscheidung der Kandidaten weniger geeignet sind. Als Beispiel nehme ich eine fiktive
Datenbank mit Namen von Steuerberatern. Fast in jedem Namensfeld kommt der Token
„Steuerberater“ vor. Für die Ermittlung der Gleichheit zweier solcher Namen ist dieser Token
wenig relevant und erhält eine niedrige inverse Dokumentenhäufigkeit. Formal wird die
inverse Dokumentenhäufigkeit folgendermaßen definiert, wobei n die Gesamtanzahl der
Kandidaten bezeichnet:
|{ |( ) ( )} ⋀ ( )|
In dem WHIRL Modell werden die Termhäufigkeit und die inverse Dokumentenhäufigkeit zur
folgenden Tokengewichtung kombiniert.
( ) ( )
Diese Gewichtung wird für jeden Token ti ϵ D berechnet. Jetzt können die Vektoren V und W
erstellt werden. Der Wert an der i-ten Stelle der Vektoren entspricht der tf-idf Gewichtung des
jeweiligen Tokens, oder ist null, falls dieser Token in den zu vergleichenden
14
Kandidatenzeichenketten nicht vorkommt. Mithilfe dieser Gewichtung kann die
Cosinusähnlichkeit berechnet werden.
Beispiel 3: Die Beispielberechnung führe ich mit einem Auszug aus einer fiktiven Datenbank für
Steuerberater. Dieser Auszug ist in der
Tabelle 2 dargestellt.
ID Name
1 Steuerberater Kreft
2 Steuerkanzlei Stapelmann
3 Steuerkanzlei Nack
4 Steuerberater Dipl-Betriebswirt Hans-Joachim Ziemer
5 Dr. Walter Burger & Partner Steuerberatungsgesellschaft
6 Dittmann & Kollegen Steuerberatungsgesellschaft mbH
7 Steuerberater Brandt
8 Steuerberater Foster
9 Steuerbüro Schneemann
10 Hosse-Weigl Steuerberatungsgesellschaft mbH Tabelle 2 Beispieltabelle mit Steuerberatern.
Man sieht, dass in jeden Namen die Tokens jeweils nur einmal vorkommen, sodass die
Termfrequenz tf immer 1 oder 0 ist. Wir wollen die Namen „Steuerberater Kreft“ und
„Steuerberater Foster“ vergleichen. Die Terme „Kreft“ und „Foster“ kommen in dieser Domäne
jeweils einmal vor, somit besitzen beide eine idf von
, also 10. Der Term „Steuerberater“
kommt hingegen vier Mal vor und hat einen idf Wert von
. Somit ergeben sich folgende
Vektoren mit tf-idf Werten (zur Vereinfachung lasse ich die Stellen, die bei beiden Vektoren 0
sind, weg), die in der Tabelle 3 dargestellt sind.
Term V W
Kreft ≈ 0,30 0
Foster 0 ≈ 0,30
Steuerberater ≈ 0,12 ≈ 0,12 Tabelle 3 Die Vektoren der zu vergleichenden Zeichenketten.
Daraus ergibt sich folgende Cosinusähnlichkeit:
( )
√
Eine vergleichbare Jaccard Ähnlichkeit würde hier
betragen und somit erheblich mehr als die
hier berechnete Cosinusähnlichkeit. Die Übereinstimmung des Tokens „Steuerberater“ wird
hier deutlich geringer bewertet, da dieser Token öfter in der gegebenen Domäne vorkommt
und somit die Übereinstimmung dieses Tokens weniger über die Ähnlichkeit der Namen
aussagt.
15
Die Gewichtung der Terme soll die Wichtigkeit deren für die Ähnlichkeit wiederspiegeln. Dabei
ist die Verwendung der tf-idf Gewichtung, wie im WHIRL Modell vorgeschlagen, nur eine der
Möglichkeiten für die Cosinusähnlichkeit. Auch andere, zum Beispiel domänenspezifische
Gewichtungen, sind möglich.
3.2 Edit-basierte Ähnlichkeitsfunktionen
Im Unterschied zu den im Kapitel 3.1 beschriebenen Token-basierten Algorithmen, werden bei
den Edit-basierten Ähnlichkeitsfunktionen die zu vergleichenden Zeichenketten nicht in Tokens
zerlegt. Es werden vielmehr Operationen verwendet, wie Einfüge-, Lösch- oder Ersetzungs-
Operationen, um eine Zeichenkette in eine andere umzuwandeln [vgl. Nava01].
3.2.1 Levenshtein und Needleman-Wunsch Distanz
Die Levenshtein Distanz ist eine Metrik zur Bestimmung von Distanz beziehungsweise Abstand
zweier Zeichenketten. Die Distanz zwischen zwei Zeichenketten z1 und z2 wird hier errechnet
als die minimalen Kosten, um z1 in z2 zu überführen. Diese Kosten werden als die Summe der
Kosten der für die Überführung nötigen Operationen berechnet. Jeder Operation werden die
entsprechenden Kosten zugeordnet. Die Levenshtein Distanz zwischen zwei Zeichenketten z1
und z2 LevDist(z1, z2) definiert die Kosten für Einfüge-, Lösch- und Ersetzungs- Operation als 1.
Somit ist die LevDist(z1, z2) die minimale Anzahl dieser Operationen die nötig ist, um z1 in z2 zu
überführen [vgl. Leve66].
Beispiel 4: Als Beispiel nehme ich zwei Zeichenketten z1 = “Hase“ und z2 = “Rasen“. Die
minimalen Kosten, um z1 in z2 zu überführen, betragen hier zwei. Es sind nämlich zwei
Operationen nötig, eine Ersetzungsoperation des ersten Buchstabens „H“ in „R“ und eine
Einfügeoperation am Ende, wo ein „n“ eingefügt wird. Es gibt noch unzählige weitere
Möglichkeiten der Überführung, wie zum Beispiel das Löschen aller Zeichen aus z1 und das
Einfügen aller Zeichen von z2. Die Kosten betragen dann aber neun und sind nicht minimal.
Ein populärer Algorithmus zur Berechnung der Levenshtein Distanz basiert auf der
dynamischen Programmierung. Es initialisiert eine (|z1|+1)x(|z2|+1) große Matrix M, wobei |z|
die Länge der jeweiligen Zeichenketten ist. Wenn der Wert in der Spalte i und der Zeile j in der
Matrix als Mi,j definiert ist und die Position i in der Zeichenkette n als zn,i, so werden die Werte
in der Matrix folgendermaßen berechnet:
{
( )
16
Die Berechnung beginnt an der Stelle M0,0. Das Ergebnis, also die Levenshtein Distanz, kann
nach der Berechnung an der Stelle M|z1|,|z2| abgelesen werden.
Für die Berechnung des Beispiels mit z1 = “Hase“ und z2 = “Rasen“ ergibt sich folgende, in der
Tabelle 4 dargestellte Matrix.
H A S E
0 1 2 3 4
R 1 1 2 3 4
A 2 2 1 2 3
S 3 3 2 1 2
E 4 4 3 2 1
N 5 5 4 3 2 Tabelle 4 Berechnung der Levenshtein Distanz.
Eine Erweiterung der Levenshtein Distanz, die andere Kosten für Einfüge-, Lösch- und
Ersetzungs- Operationen als 1 erlaubt, ist die Needleman-Wunsch Distanz, die ansonsten
analog zu der Levensthtein Distanz definiert ist [vgl. Need70]. Darüber hinaus erlaubt die
Needleman-Wunsch Distanz unterschiedliche Bewertung der verschiedenen
Ersetzungsoperationen. Beispielsweise kann eine Ersetzung ähnlich klingender oder auf einer
Tastatur nebeneinander liegender Zeichen mit geringeren Kosten bewertet werden als andere
Ersetzungen. Das erlaubt eine domänenspezifische Optimierung der berechneten Distanz.
3.2.2 Affine Gapkosten, Smith-Waterman und Smith-Waterman-Gotoh
Distanz
Die Levenshtein Distanz ist wenig geeignet zum Vergleich von Zeichenketten, bei denen sich
ganze Segmente unterscheiden, zum Beispiel wenn Abkürzungen verwendet werden („Hans J
Wurst“ und „Hans Jürgen Wurst“) oder wenn einer der Zeichenketten einen Präfix besitzt
(„Prof. Hans Wurst“ und „Hans Wurst“). In diesem Kapitel werden kurz Algorithmen
vorgestellt, die diese Schwächen der Levenshtein Distanz fokussieren, ansonsten in Ihrer
Grundfunktionalität der Levenshtein Distanz entsprechen. Im Folgenden gehe ich deswegen
nur auf die Unterscheide zu der Levenshtein Distanz ein.
Das Problem der Abkürzungen wird von der affinen Gapkosten Distanz angesprochen. Diese
erweitert die Operationen der Levenshtein Distanz um neue Operationen, die das Einfügen
oder Löschen von kompletten Zeichenblöcken und nicht nur einzelner Zeichen erlauben. Die
Kosten dieser Operationen sind niedriger als das Einfügen beziehungsweise Löschen aller
Zeichen innerhalb dieser Blöcke [vgl. Wate76]. So zum Beispiel bei Zeichenketten z1 = “Hans J
Wurst“ und z2 = “Hans Jürgen Wurst“. Man erkennt zwei übereinstimmende Blöcke „Hans J“
und „ Wurst“ und einen Block, der eingefügt werden muss, um z1 in z2 zu überführen, nämlich
17
„ürgen“. Die Kosten für das Einfügen eines solchen Blocks können als die Summe aus den
Kosten für das Öffnen des Blocks o und die Erweiterung des Blocks um ein Zeichen e berechnet
werden. Wenn man die Kosten als o = 1 und e = 0,1 definiert, ergeben sich die Gesamtkosten
für das Einfügen des gesamten Beispielblocks „ürgen“ als o + 4e = 1 + 4 x 0,1 = 1,4. Die Kosten
für das Öffnen des Blocks beinhalten bereits die Kosten für das Einfügen des ersten Zeichens.
Diese Gesamtkosten sind erheblich niedriger als bei der Levenshtein Distanz, die dort 5
betragen würden. Deswegen eignet sich die Methode besonders gut für Zeichenketten mit
Abkürzungen oder fehlenden Fragmenten.
Die Problematik der unterschiedlichen Bewertung von Präfix beziehungsweise Suffix einer
Zeichenkette wird von der Smith-Waterman Distanz behandelt [vgl. Smit81]. Zuerst wird die
längste gemeinsame Subsequenz zwischen zwei Zeichenketten bestimmt. Bei dem Beispiel z1 =
“Prof. Hans Wurst“ und z2 = “Hans Wurst“ wäre das „Hans Wurst“. Da diese Subsequenz der
gesamten Zeichenkette z2 entspricht, stellt man fest, dass der Unterschied zwischen z1 und z2
in einem Präfix „Prof.“ besteht. Grundsätzlich werden bei der Smith-Watertman Distanz die
Zeichenketten in Präfix, gemeinsame Subsequenz und Suffix zerlegt. Das Einfügen
beziehungsweise Löschen von Präfix oder Suffix der Länge l kann, ähnlich der affinen
Gapkosten Distanz, mit niedrigeren Kosten versehen werden als das Ersetzen oder Löschen
von l Zeichen. Somit führen die Unterschiede in Präfix oder Suffix zu geringeren Distanz, als es
bei der Levenshtein Distanz der Fall wäre.
Eine Kombination beider Techniken, die sowohl Präfix und Suffix als auch affine Gaps
berücksichtigt, wird als Smith-Waterman-Gotoh Distanz bezeichnet [vgl. Goto82]. Des
Weiteren bedient sich dieser Ähnlichkeitsfunktion als Grundlage der Needleman-Wunsch
Distanz. Somit können auch die Edit-Operationen mit unterschiedlichen Kosten versehen
werden, wie in Kapitel 3.2.1 beschrieben.
3.2.3 Jaro und Jaro-Winkler Distanz
Die Jaro und Jaro-Winkler Distanz unterscheiden sich von den bis jetzt von mir vorgestellten,
Edit-basierten Algorithmen vor allem durch die Berücksichtigung einer neuen Operation. Diese
erlaubt eine Zeichenvertauschung. Des Weiteren werden die Algorithmen nicht mittels
dynamischer Programmierung implementiert.
Die Jaro Distanz vergleicht zwei Zeichenketten z1 und z2, indem zuerst die gemeinsamen
Zeichen der beiden Zeichenketten identifiziert werden. Als gemeinsam werden Zeichen
bezeichnet, die gleich sind und deren Position innerhalb der Zeichenketten, hier als i und j
bezeichnet, nicht mehr als die Hälfte der Länge der kürzeren Zeichenkette abweicht. Formal
ausgedrückt:
| | (| | | |)
Nachdem die gemeinsamen Zeichen identifiziert sind, werden alle Zeichen der Zeichenketten
nacheinander durchlaufen, um die Anzahl der Zeichenvertauschungen t der gemeinsamen
Zeichen zu identifizieren. Zeichenvertauschung bedeutet, dass das gemeinsame Zeichen aus z1
18
an der Position i nicht gleich ist mit dem gemeinsamen Zeichen an der Position i aus z2. Wenn σ
die Menge der gemeinsamen Zeichen ist, ergibt sich folgende Formel für die Jaro Ähnlichkeit:
( )
(
| |
| |
| |
| |
| |
| |)
[vgl. Jaro89].
Beispiel 5: Als Beispiel für die Berechnung nehme ich z1 = “Prof. Hans Wurst“ und z2 = “Dr. Hasn
Wurst“. Es ergeben sich die Längen |z1| = 16 und |z2| = 14. Der maximale Abstand zwischen
zwei gemeinsamen Zeichen ist 0,5 x min(16, 14) = 7. Die Menge der gemeinsamen Zeichen ist σ
= {r, ., _, H, a, n, s, _, W, u, r, s, t}, wobei _ für das Leerzeichen steht. Streng genommen handelt
es sich um eine Multimenge, da gleiche Elemente mehrfach vorkommen können. Da die
Zeichen n und s bei Hans in den Zeichenketten jeweils vertauscht sind, ergibt sich t = 2, da es
zwei Zeichen gibt, die sich nicht an der gleichen Position in den beiden Zeichenketten
befinden. Es ergibt sich folgende Jaro Ähnlichkeit:
( )
(
)
Die Jaro Ähnlichkeit funktioniert sehr gut bei Zeichenketten mit geringen Abweichungen.
Durch die gegebene Definition der gemeinsamen Zeichen ergeben sich aber Probleme mit
Zeichenketten, die einen längeren Zeichenblock als Präfix beinhalten. Ein einfaches Beispiel
wäre z1 = “Professor Hans Wurst“ und z2 = “Hans Wurst“. Es lassen sich lediglich vier
gemeinsame Zeichen identifizieren. σ = {s, s, r, _} und ein t = 2. Das ergibt lediglich eine Jaro
Ähnlichkeit von circa 0,45. Und das, obwohl der Unterschied nur in einem recht langen Präfix
besteht. Ein ähnliches Verhalten lässt sich mit einem Suffix beobachten.
Um die Jaro Ähnlichkeit vor allem in Hinsicht auf den Vergleich der Namensfelder zu
verbessern, wurde die Jaro-Winkler Ähnlichkeit entwickelt. Die Jaro-Winkler Ähnlichkeit geht
davon aus, dass ein Präfix in den Namensfeldern wichtig ist und die Übereinstimmung einer
Aufwertung bedarf. Bei zwei gegebenen Zeichenketten z1 und z2 mit einem gemeinsamen
Präfix ρ und einem Korrekturfaktor f, der die Korrektur der Ähnlichkeit nach oben in
Abhängigkeit von dem gemeinsamen Präfix darstellt, ergibt sich folgende Formel:
( ) ( ) | | ( ( ))
[vgl. Wink91].
Beispiel 6: Als Beispiel nehme ich die Zeichenketten z1 = “Hans“ und z2 = “Hans Peter“. Diese
Besitzen vier gemeinsame Zeichen und ein gemeinsames Präfix ρ = “Hans“. Es gibt keine
Zeichenvertauschungen in σ, somit ist t = 0. Daraus ergibt sich JaroSim(z1, z2) = 0,8. Mit einem
Aufwertungsfaktor f = 0,1 ergibt sich folgende Jaro-Winkler Ähnlichkeit:
( ) ( )
19
3.3 Hybride Ähnlichkeitsfunktionen
In diesem Kapitel geht es um Ähnlichkeitsfunktionen, die bei der Ähnlichkeitsberechnung die
Funktionsweise der in Kapitel 3.1 beschriebenen Token-basierten Ähnlichkeitsfunktionen mit
der aus dem Kapitel 3.2 bekannten Edit-basierten Ähnlichkeitsfunktionen kombinieren.
Deswegen die Bezeichnung hybride Ähnlichkeitsfunktionen. Alle diese Ähnlichkeitsfunktionen
besitzen die Gemeinsamkeit, dass sie eine sekundäre Ähnlichkeitsfunktion verwenden. In
folgendem stelle ich drei Beispiele der hybriden Ähnlichkeitsfunktionen vor.
3.3.1 Erweiterte Jaccard Ähnlichkeit
Die Jaccard Ähnlichkeit wurde bereits im Kapitel 3.1.1 als eine Token-basierte Ähnlichkeit
beschrieben. Jetzt geht es um zwei mögliche Erweiterungen dieser Funktion mit Elementen der
Edit-basierten Ähnlichkeitsfunktionen.
In der ursprünglichen Definition der Jaccard Ähnlichkeit werden zwei Zeichenketten z1 und z2
zuerst mittels einer tokenize(.) Funktion in zwei Mengen von Tokens zerlegt. Als Elemente der
Schnittmenge der beiden Tokenmengen werden die gleichen Tokens definiert. In der ersten
Erweiterung der Jaccard Ähnlichkeit geht es darum, auch ähnliche Tokens für die Schnittmenge
zuzulassen, um so geringe Schreibfehler innerhalb der Tokens auszugleichen [vgl. Anan02].
Dazu kann eine beliebige Ähnlichkeitsfunktion, bevorzugt eine Edit-basierte, verwendet
werden. Wenn diese sekundäre Ähnlichkeitsfunktion als TokenSim(t1, t2) definiert ist für
Tokens t1 ϵ tokenize(z1) und t2 ϵ tokenize(z2) und θ ein Ähnlichkeitsschellenwert für diese
Funktion darstellt, dann kann man die Schnittmenge der Tokens zwischen z1 und z2 wie folgt
definieren:
( ) {( )| ( ) ( ) ( ) }
Es stellt kein Problem dar, statt der sekundären Ähnlichkeitsfunktion eine Distanzfunktion zu
verwenden. Dazu muss lediglich ( ) durch ( ) ersetzt
werden.
Ausgehend von dieser Definition können wir auch die Tokens, die nur in z1 vorkommen,
definieren als:
( ) { | ( ) ( ) ( )}
Und die Tokens, die nur in z2 vorkommen als:
( ) { | ( ) ( ) ( )}
Eine weitere Erweiterung der Jaccard Ähnlichkeit baut auf der ersten auf und erweitert diese
um eine Gewichtung g für die Tokens [vgl. Weis05]. So können zum Beispiel die Tokens der
Schnittmenge mit deren Ähnlichkeit gewichtet werden. Die Aggregationsfunktion, die die
individuellen Gewichtungen aggregiert, wird als A bezeichnet. Mithilfe der beiden eben
beschriebenen Erweiterungen ergibt sich folgende Formel:
20
( )
( ) ( ) ( )
( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( )
Die Gewichtung der Tokens aus Shared(z1, z2), Unique(z1) und Unique(z2) kann auch
unterschiedlich sein. Das kann nötig sein, wenn zum Beispiel für Shared(z1, z2) die Ähnlichkeit
als Gewichtung fungiert, denn diese liegt für die Tokens aus den Unique Mengen einfach nicht
vor.
Beispiel 7: Für das Beispiel nehme ich zwei Zeichenketten z1 = “Frau Angelina Jolie“ und z2 =
“Herr Angelino Yolie“. Bei der Anwendung der in Kapitel 3.1.1 beschriebenen Jaccard
Ähnlichkeit ergeben sich, je nach der verwendeten tokenize(.) Funktion, Ähnlichkeiten von 0
bei der Trennung nach Satzzeichen, wie in Beispiel 1, oder 0,3125 bei der Verwendung von
Trigrammen, wie in Beispiel 2. Ich verwende die Levenshtein Distanz als sekundäre
Ähnlichkeitsfunktion für die Bestimmung der Schnittmenge der Tokens mit dem Schwellenwert
θ = 0.75. Für die Anwendung der hybriden Jaccard Ähnlichkeit erhalten wir folgende Mengen:
( ) {( ) ( )}
( ) { }
( ) { }
Für die Unique Tokens verwenden wir die Gewichtung von 1. Für die Shared Tokens nehme ich
eine Levenstein Ähnlichkeit. Diese kann, ausgehend von der Levenstein Distanz, wie folgt
berechnet werden:
( ) ( )
(| | | |)
Eine solche Berechnung ist möglich, da die maximale Levenstein Distanz nicht größer sein kann
als die Länge der längeren Zeichenkette.
Die Aggregationsfunktion A soll die Gewichte aufsummieren. Es ergibt sich folgende hybride
Jaccard Ähnlichkeit:
( )
3.3.2 Monge-Elkan Ähnlichkeit
In Folgendem beschreibe ich eine weitere hybride Ähnlichkeitsfunktion, die als Monge-Elkan
Ähnlichkeit bekannt ist [vgl. Mong96]. Nach der Anwendung der tokenize(.) Funktion auf zwei
Zeichenketten z1 und z2 wird zu jedem Token ti aus z1 ein Token tj aus z2 gesucht, der die
höchste Ähnlichkeit hat, das heißt bei dem TokenSim(ti, tj) maximal ist. Diese maximalen
21
Ähnlichkeiten für jeden Token aus z1 werden aufsummiert, und die Summe wird mit der Anzahl
der Tokens in z1 normalisiert. Formal ausgedrückt:
( )
| ( )|∑
| ( )| ( )
| ( )|
Beispiel 8: Als Beispiel nehme ich wieder die Zeichenketten z1 = “Frau Angelina Jolie“ und z2 =
“Herr Angelino Yolie“. Als TokenSim Funktion verwende ich erneut, analog zum Beispiel 7 für
die erweiterte Jaccard Ähnlichkeit, eine Levenstein Ähnlichkeit:
( ) ( )
(| | | |)
Die maximale Ähnlichkeit zu dem Token „Frau“ hat „Herr“ mit der Ähnlichkeit 0, für „Angelina“
ist es „Angelino“ mit der Ähnlichkeit 0,875 und für „Jolie“ ist es „Yolie“ mit 0,8. Es ergibt sich
folgende Monge-Elkan Ähnlichkeit:
( )
3.3.3 Soft tf/idf Ähnlichkeit
Die soft tf/idf Ähnlichkeit erweitert prinzipiell auf die gleiche Art und Weise die Cosinus tf/idf
Ähnlichkeit, wie die erweiterte Jaccard Ähnlichkeit die Jaccard Ähnlichkeit erweitert [vgl.
Naum10, S.36f]. Auch hier wird eine sekundäre Ähnlichkeitsfunktion TokenSim(t1, t2) definiert,
um die Tokens zu vergleichen. Des Weiteren wird eine Menge Close(θ, z1, z2) der Tokens ti
tokenize(z1) definiert, zu denen ein Token tj tokenize(z2) existiert, sodass TokenSim(t1, t2) >
θ. Dabei ist θ wieder ein Schwellenwert für die sekundäre Ähnlichkeitsfunktion. Formal
ausgedrückt:
( ) { | ( ) ( ) ( ) }
Der Unterschied zu der Shared(z1, z2) Menge aus der Definition der erweiterten Jaccard
Ähnlichkeit ist, dass Close(θ, z1, z2) nur Tokens aus der Zeichenkette z1 enthält. Tokens aus der
Zeichenkette z2, die ähnlich zu Tokens aus z1 und in Close(θ, z1, z2) enthalten sind, werden
mithilfe folgender Gleichung berücksichtigt, die den ähnlichsten Token tj tokenize(z2) zu
jedem ti Close(θ, z1, z2) bestimmt:
( ) ( )
( )
Die soft tf/idf Ähnlichkeit ist dann wie folgt definiert:
( ) ∑ (
| |
| | ( ))
( )
22
V und W sind Vektoren, die jeweils die tf-idf Gewichtung für Terme aus z1 und z2 enthalten,
analog zur Definition für die Cosinus Ähnlichkeit im Kapitel 3.1.2.
Beispiel 9: Ich bediene mich des gleichen Beispiels wie bei der Monge-Elkan Ähnlichkeit und
vergleiche Zeichenketten z1 = “Frau Angelina Jolie“ und z2 = “Herr Angelino Yolie“. Zudem
verwende ich die gleiche sekundäre Ähnlichkeitsfunktion TokenSim:
( ) ( )
(| | | |)
Ich nehme an, dass sich in der gesamten Domäne zehn Dokumente befinden. Jeweils fünf
enthalten den Token „Herr“ und fünf den Token „Frau“. Die restlichen Tokens kommen jeweils
nur einmal vor. Es ergeben sich folgende Vektoren V und W:
{ }
{ }
Bei einem Schwellenwert für die sekundäre Ähnlichkeitsfunktion θ = 0,75 erhält man folgende
Menge Close(θ, z1, z2) = {Angelina, Jolie}. Daraus ergibt sich folgende Ähnlichkeit:
( )
√
√
Der Unterschied zu der im vorherigen Kapitel besprochenen Monge-Elkan Ähnlichkeit besteht
darin, dass bei Monge-Elkan die Terme gleiche Gewichtung besitzen, wohingegen bei soft tf/idf
Ähnlichkeit die tf/idf Gewichtung verwendet wird. Des Weiteren verwendet soft tf/idf
Ähnlichkeit nur sekundäre Ähnlichkeiten über einem bestimmten Schwellenwert θ. Bei der
Monge-Elkan Ähnlichkeit finden alle sekundären Ähnlichkeiten der Tokens aus z1 zu Tokens aus
z2 Verwendung.
23
4 Dublettenbestimmung
Die im Kapitel 3 vorgestellten Ähnlichkeitsfunktionen eignen sich alle zum Vergleich einzelner
Attributwerte der Dublettenkandidaten. Meistens aber haben die Kandidaten mehrere
Attribute, so wie zum Beispiel bei einer üblichen deutschen Geschäftsadresse, die die Attribute
{Name, Straße, Postleitzahl, Ort} enthält. Wie bereits in Kapitel 2.2 definiert, wird für die
Kandidaten eine Projektion der Attribute definiert, auf dieser ein Dublettenvergleich
stattfindet: ( ) { } und ( ) { }. Beim Vergleich der
Ähnlichkeit pro Attribut erhält man einen Vektor mit Ähnlichkeiten:
( ) { ( ) ( ) ( )}
Ich verwende an dieser Stelle eine etwas andere Notation, die bereits 1969 von Fellegi und
Sunter eingeführt wurde und in Zusammenhang mit Dublettenbestimmung seitdem sehr
häufig verwendet wird [vgl. Fell69].
Seien A und B zwei Tabellen, die verglichen werden sollen und n gleiche Attribute enthalten.
Die Kandidatenpaare werden hier mit (α, β) bezeichnet, wobei α aus der Tabelle A stammt und
β aus der Tabelle B (α A, β B). Jedes Kandidatenpaar ist entweder der Klasse M oder U
zugewiesen. M enthält die Kandidatenpaare, die dasselbe Realweltobjekt repräsentieren, U
diejenigen, die unterschiedliche Realweltobjekte repräsentieren. Jedes dieser Kandidatenpaare
wird von einem Vektor, in Folgendem auch Entscheidungsvektor genannt, der folgenden Form
repräsentiert:
Die n Komponenten des Vektors korrespondieren mit den n Attributen der Kandidaten und
beschreiben die Übereinstimmung des i-ten Attributes der Kandidaten α und β. Das können
Ähnlichkeiten sein, die mit Methoden aus Kapitel 3 bestimmt wurden oder binäre Werte mit xi
= 1 bei einer Übereinstimmung oder xi = 0 bei keiner Übereinstimmung. Diese
Übereinstimmung kann ebenfalls mithilfe von Methoden aus Kapitel 3 bestimmt werden. Dies
geschieht mithilfe eines Schwellenwertes, wie in der Einführung in Kapitel 3 beschrieben.
In diesem Kapitel werden Methoden beschrieben, die auf der Basis eines solchen Vektors eine
Entscheidung ermöglichen, ob es sich bei einem Kandidatenpaar um Dubletten handelt. Den
Schwerpunkt lege ich besonders auf die Methoden, die sich gut für die Datenbasis eignen, die
für den Vergleich der Methoden im Rahmen dieser Arbeit zur Verfügung steht. Zuerst
beschreibe ich einfache Methoden der Entscheidung, die direkt auf den berechneten
Ähnlichkeiten basieren. Besonders interessant für die vorliegenden Daten sind Methoden, die
eine Trainingsmenge verwenden können beziehungsweise müssen und darauf basierend ein
Entscheidungsmodel erstellen, weil die zur Verfügung stehenden Datenpaare bereits als
„Dublette“ beziehungsweise „keine Dublette“ gekennzeichnet sind. Dies sind vor allem
Verfahren aus dem Bereich des maschinellen Lernens. Vor allem diese Verfahren werden im
Rahmen der Evaluation zum Einsatz kommen.
Die konkrete Auswahl der hier beschriebenen Methoden basiert auf [Elma07, S.6f], im Bereich
des maschinellen Lernens ergänzt um die künstlichen neuronalen Netze. Abbildung 4 zeigt
24
schematisch die Methoden, die bei der Evaluation zum Einsatz kommen und verdeutlicht den
Schwerpunkt der Methoden des maschinellen Lernens. Die Beschreibung der probabilistischen
Entscheidungsverfahren ist in dem Zusammenhang trotzdem wichtig, da es zum einen hilft, die
Grundlagen der Dublettenbestimmung zu verstehen. Zum anderen stellten diese Verfahren
über mehrere Jahrzehnte in der Fachliteratur die dominierenden Methoden für die
Dublettenbestimmung dar.
Abbildung 4 Die Methoden der Dublettenbestimmung.
4.1 Ähnlichkeitsbasierte Entscheidungsverfahren
Als erstes werde ich Entscheidungsverfahren vorstellen, die direkt auf den berechneten
Ähnlichkeiten zwischen den Zeichenketten basieren. Die Methoden der
Ähnlichkeitsberechnung wurden bereits im Kapitel 3 vorgestellt. Die ähnlichkeitsbasierten
Entscheidungsverfahren gehen davon aus, dass es nur eine Ähnlichkeit pro
Dublettenbestimmung
Ähnlichkeits-basierte
Verfahren
Ein Attribut
Durchschnitt
Probabilistische Verfahren
Naive Bayes
Maschinelles Lernen
Entscheidungsbäume
Support Vector Machine
Nächster-Nachbar-Klassifikation
Künstliche neuronale Netze
25
Dublettenkandidatenpaar gibt, was damit vergleichbar ist, dass der Entscheidungsvektor x nur
eine Dimension besitzt. Das Entscheidungsproblem für kann dann auf folgendes Vorgehen
reduziert werden:
( ) { ( )
( )
Das ist möglich, falls zum Beispiel die Kandidaten α und β nur ein Attribut besitzen. Der
optimale Schwellenwert lässt sich durch die Optimierung der Parameter precision und recall
bestimmen, die in Kapitel 4.4 vorgestellt werden. Die hier vorgestellten Methoden basieren
auf der Evaluation, die in [Bile03] beschrieben wurde.
4.1.1 „Ein Attribut“ Verfahren
Bei dem „ein Attribut“ Verfahren geht es darum, dass man die Entscheidung, ob α und β
Dubletten sind, auf Basis der Ähnlichkeitsberechnung eines Attributwerts fällt. Existieren in α
und β mehrere Attribute, so erzeugt man ein neues, künstliches Attribut, das alle Werte der
anderen Attribute hintereinander geschrieben und getrennt durch einen Trenner, wie zum
Beispiel ein Leerzeichen, beinhaltet. Auf diesem Attribut lässt sich die Ähnlichkeit berechnen,
in dem man die Inhalte des Attributs, die Zeichenketten z1 und z2, mithilfe einer
Ähnlichkeitsfunktion vergleicht. Mithilfe dieser Ähnlichkeit und eines Schwellwertes lässt
sich entscheiden, ob es sich bei α und β um eine Dublette handelt:
( ) { ( )
( )
Dieses Verfahren wurde zum Beispiel in [Mong96] vorgeschlagen. Aus dieser Basis wurde auch
die Monge-Elkan Ähnlichkeit entwickelt, die in Kapitel 3.3.2 vorgestellt wurde.
4.1.2 Durchschnittverfahren
Eine weitere Möglichkeit, die Entscheidung auf der Basis einer Maßzahl zu treffen, ist den
Durchschnitt der Ähnlichkeiten einzelner Attributwerte zu bilden. Auf der so erzeugten Zahl
kann man ebenfalls einen Schwellenwert anwenden [vgl. Bile03]. Einer Weiterentwicklung
dieser Methode könnte sein, die Ähnlichkeit der einzelnen Attribute bei der
Durchschnittsberechnung unterschiedlich zu gewichten. Die Suche nach der geeigneten
Gewichtung wird so sehr komplex und ähnelt den probabilistischen Entscheidungsproblem,
das ich in Kapitel 4.2 vorstelle [vgl. Elma07, S.9]. Deswegen wird in der Evaluation in Rahmen
dieser Arbeit nur der einfache Durchschnitt verwendet, ähnlich wie in der Evaluation aus
[Bile03].
26
4.2 Probabilistische Entscheidungsverfahren
Bereits 1959 beschreibt Newcombe die Dublettenerkennung als eine Aufgabe der
Diskriminanzanalyse [vgl. Newc59]. Zehn Jahre später wurde dieser Gedanke formalisiert und
beherrschte seitdem die Fachliteratur zum Thema Entscheidungsverfahren bei der
Dublettenerkennung [vgl. Fell69]. Der Merkmalsvektor x dient als Input für eine
Entscheidungsregel, die x der Klasse M beziehungsweise U zuordnet. Die Hauptannahme dabei
ist, dass die Dichtefunktionen des Merkmalsvektors x für M und U unterschiedlich sind. Wenn
diese Dichtefunktionen bekannt sind, kann dieses Entscheidungsverfahren als eine Aufgabe für
eine Bayes-Entscheidungsregel angesehen werden. In Folgenden stelle ich
Entscheidungsverfahren vor, die auf dieser Idee basieren.
4.2.1 Bayes-Entscheidungsregel der kleinsten Fehlerrate
Sei x ein Vergleichsvektor der Kandidaten (α, β). Eine Entscheidung nach einer Bayes-
Entscheidungsregel wie folgt definiert [Fahr98, S.360]:
„Eine Zuordnung erfolgt nach der Bayes-Entscheidungsregel, wenn ein Objekt mit dem
beobachteten Merkmalsvektor x derjenigen Klasse (…) zugeordnet wird, die die größte a
posteriori-Wahrscheinlichkeit besitzt.“
Ob (α, β) M oder (α, β) U lässt sich also wie folgt auf Basis einer Bayes-
Entscheidungsregel entscheiden:
( ) { ( | ) ( | )
Das bedeutet, falls die Wahrscheinlichkeit, dass der Vektor x zu M gehört, größer ist als die
Wahrscheinlichkeit, dass x zu U gehört, dann wird x als zu M angehörig qualifiziert und
umgekehrt. Unter Verwendung des Bayestheorems kann diese Regel wie folgt ausgedrückt
werden:
( ) { ( )
( | )
( | )
( )
( )
In dem Fall ist
( ) ( | )
( | )
ein sogenanntes Likehood und
( )
( )
27
ein Schwellenwert für Likehood bei dieser Entscheidung. In [Fahr98, S.361] findet man einen
Beweis für den folgenden Satz:
„Unter allen Entscheidungsregeln besitzt die Bayes-Entscheidungsregel für alle x die kleinste
bedingte Fehlerrate, wenn x beobachtet wird, und damit auch die kleineste
Gesamtfehlerrate.“
Somit kann diese Entscheidungsregel als optimal im Sinne der kleinsten Fehlerrate bezeichnet
werden. Voraussetzung dafür ist natürlich, dass die Verteilung von p(x|M) und p(x|U) und
auch p(M) und p(U) bekannt sind. Diese können mithilfe einer sogenannten Lernstichprobe
geschätzt werden.
Ein möglicher Ansatz, um die Verteilungen p(x|M) und p(x|U) zu berechnen, ist die sogenannte
naive Bayes Methode. Dazu wird angenommen, dass die Elemente des Entscheidungsvektors
unabhängige Beobachtungen darstellen und damit die Wahrscheinlichkeiten p(xi|M) und
p(xj|M) bei i ≠ j unabhängig sind. Diese Entscheidungsmethode liefert auch gute Ergebnisse,
wenn die Wahrscheinlichkeiten nicht vollkommen unabhängig sind [vgl. Samm11, S.713], was
in der Praxis der Dublettenbestimmung meistens der Fall ist. Genau das Gleiche gilt für die
Wahrscheinlichkeiten p(xi|U) und p(xj|U) bei i ≠ j. In diesem Fall werden die
Wahrscheinlichkeiten wie folgt berechnet:
( | ) ∏ ( | )
( | ) ∏ ( | )
Die Werte für p(xi|M) und p(xi|U) können mithilfe einer sogenannten Lernstichprobe aus
vorqualifizierten Kandidatenpaaren ermittelt werden. Als vorqualifizierte Datenpaare
bezeichnet man die Kandidatenpaare, bei denen die Zugehörigkeit zu Klasse M
beziehungsweise U a priori bekannt ist.
4.2.2 Die kostenoptimale Bayes-Entscheidungsregel
Die Minimierung der Fehlklassifikationswahrscheinlichkeit ist nicht immer das beste Kriterium
für eine Entscheidungsregel. Die falsche Zuordnung zu Klasse M oder U kann unterschiedliche
Konsequenzen haben. Die unterschiedliche Bewertung einer Fehlqualifikation kann durch
Berücksichtigung von Kosten cij ausgedrückt werden. Dies sind Kosten für eine Zuordnung des
Vektors x zu Klasse i, wenn dieser Vektor tatsächlich zu Klasse j gehört. Die Kostenfunktionen
können wie folgt ausgedrückt werden:
( ) ( | ) ( | )
( ) ( | ) ( | )
28
Somit ergibt sich folgende Entscheidungsregel:
( ) { ( ) ( )
Unter Anwendung des Bayestheorems ergibt sich folgende Entscheidungsregel:
( ) { ( )
( ) ( )
( ) ( )
Im Falle der symmetrischen Kosten, das heißt cUM – cMM = cMU - cUU, ist die kostenoptimale
Entscheidungsregel identisch mit der Regel der kleinsten Fehlerrate [vgl. Very03].
Die Festlegung der Kosten ist schwierig und in der Literatur oft kritisch beurteilt [Fahr98,
S.363]:
„Die Festlegung allgemeiner Kostenfunktionen ist allerdings meist schwierig und (…) von einem
hohen Maß an Willkür geprägt.“.
4.2.3 Die Klasse der möglichen Dubletten
Erwähnenswert in Zusammenhang mit den probabilistischen Entscheidungsverfahren ist noch
die Klasse der möglichen Dubletten. Dabei wird vorgeschlagen, eine dritte Klasse für die
Entscheidungsregel einzuführen, nämlich die der möglichen Dubletten, in [Fell69] „possible
link“ genannt. Dieser Klasse sollen Kandidatenpaare zugeordnet werden, bei denen der
Likehood l(x) im Rahmen einer festgelegten Fehlerquote nah am Schwellenwert liegt. Die
Kandidatenpaare, die der Klasse der möglichen Dubletten zugeordnet wurden, sollen manuell
von einem Experten auf die Zugehörigkeit zu den Klassen M und U überprüft werden [vgl.
Fell69].
4.3 Maschinelles Lernen
Die probabilistischen Entscheidungsverfahren, basierend auf Bayes-Entscheidungsregeln und
üblicherweise aufbauend auf den Ideen aus [Fell69], beherrschten über 20 Jahre lang den
Bereich der Dublettenbestimmung. Die Entwicklung neuer Verfahren im Bereich des
maschinellen Lernens führte dazu, dass diese neuen Methoden seit Anfang des 21.
Jahrhunderts den Eingang in die Dublettenbestimmung gefunden haben. Das maschinelle
Lernen setzt die Existenz von Lernstichproben voraus, die aus vorqualifizierten
Kandidatenpaaren bestehen. Bei diesen Kandidatenpaarten ist die Zugehörigkeit zu der Klasse
M oder U bekannt. Dies kann mithilfe einer manuellen Vorqualifizierung durch einen Experten
erfolgen. Da im Kontext dieser Arbeit eine große Menge solcher vorqualifizierten Daten zur
Verfügung steht, sind die Techniken des maschinellen Lernens eine sehr interessante
Dublettenbestimmungsmethode. In diesem Kapitel stelle ich die Methoden des maschinellen
29
Lernens vor, die in dem Kontext der Dublettenbestimmung interessant sind beziehungsweise
bereits in dem Zusammenhang mit Dublettenbestimmung untersucht wurden. Im Bereich des
maschinellen Lernens wird auch die Methode des naive Bayes eingesetzt, die bereits im Kapitel
4.2.1 vorgestellt wurde und in diesem Kapitel nicht erneut explizit vorgestellt wird.
4.3.1 Entscheidungsbäume
Als Entscheidungsbäume bezeichnet man gerichtete Bäume, die mehrstufige
Entscheidungsregeln darstellen [vgl. Borg98]. Mithilfe dieser Bäume ist es möglich,
automatisierte Klassifizierungen durchzuführen, in diesem konkreten Fall die
Dublettenbestimmung. Um eine Klassifizierung eines Kandidatenpaares (α, β) durchzuführen,
geht man vom Wurzelknoten entlang des Baumes. Bei jedem Knoten wird mithilfe eines
Attributwerts des Merkmalvektors x die Entscheidung getroffen, welcher Knoten für die
nächste Entscheidung verwendet wird. Dies geschieht so lange, bis man ein Blatt erreicht hat.
Die Blätter eines Entscheidungsbaums entsprechen den Klassifikationsklassen, in diesem Fall M
für Dublette und U für keine Dublette.
In Abbildung 5 ist ein möglicher Baum für Dublettenbestimmung dargestellt. Die Knoten tragen
die Bezeichnung des Attributs, dessen Ähnlichkeit ausgewertet wird. Die Ähnlichkeiten können
zum Beispiel mithilfe der Methoden aus Kapitel 3 bestimmt werden und die Attribute des
Entscheidungsvektors x darstellen. Die Kanten sind jeweils mit den Ähnlichkeiten beschriftet,
die zu dem jeweils nächsten Knoten führen. Die Blätter sind dann die entsprechenden Klassen
M und U.
Abbildung 5 Ein möglicher Entscheidungsbaum für Dublettenerkennung.
Entscheidungsbäume sind für Menschen sehr gut lesbar und können ebenso manuell erstellt
werden. Im Kontext dieser Arbeit stehen die Methoden des maschinellen Lernens, um
name
plz U
M U
> 0,5 ≤ 0,5
> 0,5 ≤ 0,5
30
Entscheidungsbäume zu induzieren, im Fokus. Die Induktion erfolgt üblicherweise rekursiv und
benötigt vorqualifizierte Lernstichproben. In jedem Induktionsschritt wird ein Attribut des
Entscheidungsvektors x gesucht, mit dem die Qualifizierung zu der bereits bekannten Klasse
sich am besten durchführen lässt. Wie diese Auswahl erfolgt und wie gegebenen falls die
Schwellenwerte für die Kanten berechnet werden, ist abhängig von dem jeweiligen
Algorithmus. Dies wird rekursiv auf den entstandenen Teilmengen so lange wiederholt, bis in
jeder Teilmenge möglichst nur noch Objekte einer Qualifikation vorhanden sind.
Der wohl erste bekannte Algorithmus zur Induktion der Entscheidungsbäumen ist der CHAID
(Chi-square Automatic Interaction Detectors) Algorithmus. Dieser verwendet für die Wahl der
Attribute einen Chi-Quadrat-Unabhängigkeitstest. Dieser Test berechnet die Abhängigkeit
zweier Variablen und drückt diese als Chi-Quadrat-Abstand aus. Je größer dieser Abstand,
desto größer die Abhängigkeit zweier Variablen. Das Attribut mit dem größten Abstand, somit
auch der größten Abhängigkeit zur Zielgröße, wird in der jeweiligen Rekursion als
Entscheidungsattribut für einen Knoten des Baums gewählt [vgl. Sonq64]. Der CHAID
Algorithmus erlaubt beliebig viele Verzweigungen pro Knoten. Dieser Algorithmus eignet sich
nur für diskrete Attributwerte und ist somit für die Entscheidungsvektoren mit reellwertigen
Attributwerten, wie es bei Ähnlichkeitswerten der Fall ist, nicht geeignet.
Der CARD (Classification And Regression Trees) Algorithmus ist für reellwertige Attribute
geeignet. Bei der Anwendung des CARD Algorithmus werden, im Gegensatz zu CHAID,
Binärbäume erzeugt. Die Auswahl der Attribute erfolgt durch die Minimierung der Entropie
(Maximierung des Informationsgehalts) in Bezug auf die Zielklassen. Des Weiteren wird ein
Schwellenwert gesucht, der auf Basis des jeweiligen Attributs die beste Trennung bezüglich der
Zielklassen erlaubt. Die Attribute und die dazugehörigen Schwellenwerte, die die höchste
Trefferquote bezüglich der Zielklasse besitzen und somit die niedrigste Entropie aufweisen,
finden sich weiter oben in dem Entscheidungsbaum [vgl. Brei84]. In [Coch01] findet sich ein
Vergleich verschiedener Methoden des maschinellen Lernens im Kontext der
Dublettenentscheidung. Hier erreicht der CARD Algorithmus im Vergleich zur linearen
Diskriminanzanalyse und einer Variante der Nächste-Nachbarn-Klassifikation die niedrigste
Fehlerquote.
Es existieren zahlreiche Weiterentwicklungen des CARD Algorithmus, wie der ID3-, C4.5- oder
C.5.0- Algorithmus, die aber alle die Grundidee der Minimierung der Entropie verfolgen.
4.3.2 Support Vector Machine
Die Idee einer SVM (Support Vector Machine), zu Deutsch Stützvektormaschine, basiert auf
Arbeiten vom Wladimir Wapnik [vgl. Wapn95]. Die Grundidee dieses Klassifikators ist, die
Entscheidungsvektoren einer Lernstichprobe mit vorqualifizierten Trainingsobjekten durch
eine Hyperebene gemäß deren Klassenzugehörigkeit möglichst gut zu trennen. Dabei soll der
Abstand der Hyperebene zu den Vektoren, die ihr am nächsten liegen, maximiert werden.
Diese Maximierung soll helfen, Entscheidungsvektoren unbekannter Klassen möglichst gut
automatisch zu klassifizieren. Abbildung 6 zeigt ein einfaches Beispiel einer solchen
31
Hyperebene in einem zweidimensionalen Raum. Die als Punkte eingezeichneten
Entscheidungsvektoren gehören jeweils einer roten und einer blauen Klasse.
Abbildung 6 Ein Beispiel einer vom SVM erzeugten Hyperebene.
Die Lage der Hyperebene ist nur von den Vektoren abhängig, die der Ebene am nächsten
liegen. Mithilfe dieser Stützvektoren wird die Hyperebene exakt mathematisch beschrieben.
Eine Trennung mithilfe einer Hyperebene ist im Normalfall nur möglich, wenn die Vektoren
auch linear trennbar sind. Dies ist in der Praxis aber oft nicht der Fall. Hier bedient man sich
eines Kernels. Die Aufgabe eines Kernels ist es, den Vektorraum mit den dazugehörigen
Entscheidungsvektoren in einen höherdimensionalen Raum zu überführen. In diesem Raum
wird dann die Hyperebene berechnet. Anschließend wird eine Rücktransformation in den
ursprünglichen, niedrigerdimensionalen Raum durchgeführt. Dadurch kann die Hyperebene zu
einer nichtlinearen Hyperfläche werden, die auch nicht zwingend zusammenhängend sein
muss, um die Entscheidungsvektoren korrekt zu trennen.
Eine weitere Möglichkeit, SVMs flexibler zu gestalten, ist die Einführung von Schlupfvariablen.
Diese sollen die Kosten einer Fehlklassifikation bestimmen und somit steuern, inwiefern
Fehlklassifikationen bei der Berechnung der Hyperebene erlaubt sind.
Eine SVM berechnet bei der Klassifizierung für jeden Vektor den Abstand zur Hyperebene.
Dieser Abstand kann dazu genutzt werden, bestimmte Entscheidungsvektoren mit sehr
niedrigem Abstand zur Hyperebene einer dritten Klasse möglicher Dubletten zuzuordnen, wie
es für die Bayes-Entscheidungsregeln im Kapitel 4.2.3 vorgeschlagen wurde.
Die Dublettenentscheidungen mithilfe einer SVM wurden bereits untersucht. Es wurde gezeigt,
dass eine SVM in den meisten Fällen einfacheren, auf Ähnlichkeiten basierenden
Hyperebene
32
Entscheidungsmethoden überlegen ist [vgl. Bile03]. Es wurde gleichzeitig betont, dass die
optimale Entscheidungsmethode für Dubletten domänenabhängig ist. Somit können für
verschiedenartige Daten unterschiedliche Methoden zum Erfolg führen.
4.3.3 Nächste-Nachbarn-Klassifikation
Die Nächste-Nachbarn-Klassifikation wird mithilfe eines k-Nearest-Neighbor-Algorithmus, kurz
k-NN, implementiert. Es ist ein relativ einfaches und intuitives Verfahren, bei dem die
Trainingsdaten nur gespeichert werden, was als lazy learning bezeichnet wird. Die
Entscheidung über die Klassenzugehörigkeit eines neuen Entscheidungsvektors wird mithilfe
seiner k nächsten Nachbarn getroffen. Um die Abstände zwischen den Vektoren zu berechnen,
kann man sich eines beliebigen Abstandsmaßes bedienen, zum Beispiel des euklidischen
Abstands. Die Entscheidung über die Klassenzuordnung ist dann eine Mehrheitsentscheidung.
Je nachdem, zu welcher Klasse die meisten k nächsten Nachbarn des Entscheidungsvektors
gehören, wird auch der neue Entscheidungsvektor zugeordnet [vgl. Fix51]. Abbildung 7 zeigt
eine beispielhafte Klassifikation eines neuen Vektors in einem zweidimensionalen Raum mit
unterschiedlichen Werten für k.
Abbildung 7 Beispiel einer k-NN Klassifikation in einem zweidimensionalen Raum.
An diesem Beispiel wird deutlich, dass die Auswahl der Größe von k entscheidend für die
Qualität der Klassifikation ist. Ein kleines k oder gar ein k = 1 kann schnell zu einer falschen
Zuordnung führen. Ein großes k kann Vektoren in die Entscheidung einbeziehen, die sehr weit
entfernt liegen. Dem kann man zum Beispiel mit einer gewichteten Abstandsmetrik begegnen,
die näher liegende Vektoren höher gewichtet [vgl. Hall08].
k = 7
k = 1
33
Im Kontext der Dublettenbestimmung wurde die Nächste-Nachbarn-Klassifikation bereits
untersucht. Obwohl diese nicht am besten abgeschnitten hat, ist die Nächste-Nachbarn-
Klassifikation wegen ihrer Einfachheit und Schnelligkeit durchaus interessant [vgl. Coch01]. Es
gibt auch Ansätze, die die Nächste-Nachbarn-Klassifikation mit einer SVM kombinieren und
dadurch eine sehr gute Klassifikation erreichen können [vgl. Chri08].
4.3.4 Künstliche neuronale Netze
Eine weitere bekannte Technik aus dem Bereich des maschinellen Lernens sind die künstlichen
neuronalen Netze. Es sind Netze aus künstlichen Neuronen, die sich am Vorbild der
biologischen neuronalen Netze orientieren. Ein künstliches neuronales Netz kann wie folgt
definiert werden [Krie07, S.36]:
„Ein Neuronales Netz ist ein sortiertes Tripel (N, V, w) mit zwei Mengen N, V sowie einer
Funktion w, wobei N die Menge der Neurone bezeichnet und V eine sortierte Menge
{( )| }
ist, deren Elemente Verbindungen von Neuron i zu Neuron j heißen. Die Funktion
definiert die Gewichte, wobei w((i, j)), das Gewicht der Verbindung von Neuron i zu Neuron j,
kurz mit wi,j bezeichnet wird. Sie ist je nach Auffassung entweder undefiniert oder 0 für
Verbindungen, welche in dem Netz nicht existieren.“
Das zentrale Bestandteil der künstlichen neuronalen Netze sind künstliche Neuronen. Diese
nehmen eine oder mehrere Eingaben x entgegen, die mithilfe der Gewichte w gewichtet
werden. Die Eingaben können die Ausgaben anderer Neuronen oder externe Eingaben sein.
Die Propagierungsfunktion erzeugt aus den Eingaben und den Gewichtungen eine
Netzeingabe. Die Propagierungsfunktion bildet oft einfach die Summe der gewichteten
Eingaben [vgl. Brau95].
∑
Ein künstliches Neuron wird aktiviert, wenn die Netzeingabe einen Schwellenwert
überschreitet. Der Aktivierungszustand, also auch die Ausgabe eines künstlichen Neurons, wird
von einer Aktivierungsfunktion berechnet, die die Netzeingabe, den alten Aktivierungszustand
und den Schwellenwert als Eingaben verwendet.
( )
t wird dabei als Zeitschritt bezeichnet. Die eben beschriebene Form eines künstlichen Neurons
zeigt die Abbildung 8.
34
Abbildung 8 Ein künstliches Neuron.
Manchmal wird auch eine Ausgabefunktion verwendet. Diese berechnet aus der Aktivierung aj
die Ausgabe eines künstlichen Neurons oj [vgl. Grau92]. In der von mit verwendeter
Darstellung ist die Aktivierung gleichzeitig die Ausgabe des Neurons.
Künstliche neuronale Netze können verschiedene Topologien besitzen. In Rahmen dieser
Arbeit werde ich mich auf die FeedForward-Netze beschränken. Die FeedForward-Netze
werden wie folgt definiert [Krie07, S.41]:
„Ein FeedForward-Netz besitzt klar abgetrennte Schichten von Neuronen: Eine Eingabeschicht,
eine Ausgabeschicht und beliebig viele innere, von außen nicht sichtbare
Verarbeitungsschichten (auch versteckte Schichten bzw. hidden layer genannt). Verbindungen
sind nur zu Neuronen der jeweils nächsten Schicht erlaubt.“
Im Kontext der Dublettenbestimmung kann die Eingabeschicht aus den Attributen des
Entscheidungsvektors bestehen und die Ausgabeschicht die jeweilige Klassen M und U
repräsentieren. Ein Beispiel eines solchen Netzes zeigt Abbildung 9.
x1,j
x2,j
xn,j
.
.
.
w1,j
w2,j
wn,j
∑⬚ fact
Θj
oj
Eingaben Gewichtungen Propagierungs-
funktion
Netzeingabe
netj
Aktivierungs-
funktion
Schwellenwert
Aktivierung
35
Abbildung 9 Ein Beispiel eines FeedForward-Netzes für eine Dublettenentscheidung.
Das in Abbildung 9 dargestellte Netz ist ein sogenanntes Perceptron. Es besitzt eine feste
Eingabeschicht, dann eine oder mehrere trainierbare Gewichtsschichten (in Abbildung 9 sind
es zwei) und eine feste Ausgabeschicht. Die Schichten sind jeweils vollverknüpft. Als
Propagierungsfunktion wird die als Beispiel angesprochene gewichtete Summe verwendet [vgl.
Rose58].
Die einfachste Form eines Perceptrons ist ein Singlelayerperceptron, abgekürzt SLP. Ein SLP
besitzt lediglich Eingabe- und Ausgabeneutronen, die mit einer variablen Gewichtsschicht
verbunden sind und somit keine Verarbeitungsschicht. Als Lernalgorithmus für SLPs wird
meistens die sogenannte Delta-Regel verwendet [vgl. Krie07, S.75f]. Im Prinzip geht es bei der
Delta-Regel darum, dass der Output des SLP, für gegebene Entscheidungsvektoren als Input,
möglichst immer der bekannten Klassenzuordnung der Lernstichprobe entspricht. Der
Gesamtfehler, also die Summe der Fehlzuordnungen, wird durch eine Fehlerfunktion
ausgedrückt. Eine Fehlerfunktion ist eine Funktion der Gewichte der Propagierungsfunktion,
die den quadratischen Abstand zwischen der Ausgabe und der gewünschten Klassifizierung
optimiert. Die Funktion wird auf alle Gewichte, die als Vektor betrachtet werden, angewendet.
Der Lernprozess verändert die Gewichte und sucht nach dem Minimum der Fehlerfunktion.
Dazu wird diese Funktion abgeleitet, um das Gesamtminimum zu finden. Die Ableitung
geschieht mithilfe der Gradienten, die eine Verallgemeinerung der Ableitung für
mehrdimensionale Funktionen sind. Die Suche nach dem Minimum wird mithilfe des
Gradientenabstieges durchgeführt. Dies ist eine Methode, um vom beliebigen Startpunkt der
Funktion entgegen den Gradienten schrittweise in Richtung kleinerer Werte zu gehen. Es sei
erwähnt, dass diese Methode nicht immer das globale Minimum findet. Da die Delta-Regel sich
nur auf lineare Aktivierungsfunktionen beschränkt, wird die Aktivierungsfunktion ebenfalls in
die Ableitung aufgenommen. Da sowohl die Propagierungsfunktion als auch die
Aktivierungsfunktion linear sind, geschieht es durch Verschachtelung der Funktionen und
Anwendung der Kettenregel. Wichtig ist, dass ein SLP nur linear separierbare Daten
qualifizieren kann.
Eingabeschicht
Ausgabeschicht
M
N
Name
Strasse
PLZ
Ort
Verarbeitungsschicht
Gewichtsschicht Gewichtsschicht
36
Das Beispielnetz aus Abbildung 9 ist ein Multilayerperceptron, kurz MLP. Ein MLP besitzt, im
Gegensatz zu SLP, zwei oder mehrere trainierbare Gewichtsschichten, die durch eine
Verwendung von hidden Layers hinzugefügt werden. Dies sind Schichten von künstlichen
Neuronen, die zwischen die Eingabe- und die Ausgabeschicht platziert werden, um mehrere
Gewichtsschichten zu ermöglichen. Als Lernalgorithmus wird hier oft der Backpropagation of
Error Algorithmus verwendet. Dieser verallgemeinert die Delta-Regel auf MLPs, indem die
Fehlerfunktion auf mehrere Gewichtsschichten erweitert wird. Dieser Algorithmus wurde von
Paul Werbos entwickelt [vgl. Werb74]. Durch die Einführung mehrerer Schichten ist es möglich
auch nicht linear separierbare Daten zu klassifizieren.
4.4 Erfolgsmessung der Dublettenerkennung
Da es in dieser Arbeit um einen Vergleich der Methoden der Dublettenerkennung geht, spielt
die Erfolgsmessung eine zentrale Rolle. Die Erfolgsmessung einer Entscheidungsregel ist
insofern schwierig, da sie voraussetzt, dass die Zugehörigkeit der Kandidatenpaare zu den
Entscheidungsklassen M (Dublette) und U (keine Dublette) bekannt sein muss. Dies erfordert
einen hohen manuellen Aufwand, um die Kandidatenpaare zu klassifizieren.
Allgemein werden Klassifizierungsfehler erst einmal als spezifische Fehler gemessen. Ein
spezifischer Fehler ist der Fehler einer Klassifizierung, ausgedrückt durch den Abstand der
erwarteten und der vorgenommenen Klassifizierung. Wenn man das Ergebnis einer
Klassifizierung als Vektor betrachtet, kann der spezifische Fehler als euklidischer Abstand oder
Root-Mean-Square ausgedrückt werden [vgl. Krie07, S.58]. Der Gesamtfehler ist dann die
Summe der spezifischen Fehler aller vorgenommenen Qualifizierungen. Diese Berechnungen
lassen sich im Kontext der Dublettenerkennung vereinfachen, da es hier nur zwei mögliche
Klassifizierungen gibt.
Bei zwei Entscheidungsklassen, wie es bei der Dublettenerkennung der Fall ist, ergeben sich
zwei Typen von Fehlern. Ein Kandidatenpaar, das keine Dublette darstellt, kann als Dublette
qualifiziert werden. In dem Fall spricht man von false positive. Umgekehrt kann eine Dublette
als „keine Dublette“ qualifiziert werden. Dann spricht man von false negative. Bei
Kandidatenpaaren, die korrekt als „Dublette“ beziehungsweise „keine Dublette“ qualifiziert
werden, spricht man dementsprechend von true positive oder true negative [vgl. Naum10,
S.61f]. Abbildung 10 zeigt anschaulich diese vier Fehlergruppen.
37
Abbildung 10 Fehlergruppen bei der Dublettenerkennung [Naum10, S.62].
Basierend auf diesen Fehlergruppen werden zwei Metriken definiert, die im Bereich der
Dublettenerkennung populär sind, nämlich precision und recall [vgl. Naum10, S.61f]. Precision
misst das Verhältnis der korrekt identifizierten Dubletten zu allen gefundenen Dubletten.
Recall ist das Verhältnis der korrekt identifizierten Dubletten zu den tatsächlichen Dubletten.
Beide Metriken sind wie folgt definiert [Naum10, S.61]:
| |
| | | |
| |
| |
| |
| | | |
| |
| |
Um eine hohe precision zu erhalten, ist es am besten, möglichst wenige Kandidatenpaare der
Klasse der Dubletten zuzuordnen. Das führt aber zu schlechtem recall, denn hier führt das
Zuordnen aller Kandidatenpaare zur Klasse der Dubletten zum besten Ergebnis, was sich
wiederum in einer schlechten precision niederschlägt. Um einen Kompromiss zwischen den
zwei Metriken zu finden, wird das F-Measure verwendet. Es ist ein harmonisches Mittel von
precision und recall, der wie folgt definiert ist [Naum10, S.62]:
Um ein gutes F-Measure zu erreichen, müssen also precision und recall möglichst hoch sein. Je
nach der Datendomäne beziehungsweise dem späteren Einsatz der Daten kann es erforderlich
sein, eine hohe precision oder ein hohes recall zu erreichen. Beispielsweise für eine
Beurteilung der Kreditwürdigkeit einer Person ist die Zusammenführung zweier Datensätze,
die nicht dieselbe Person (dasselbe Realweltobjekt) darstellen, ein viel gravierenderer Fehler
Tatsächlic
Gefunden
false positives
true negatives
false negatives
true positives
Daten
gefundene Dubletten
tatsächliche Dubletten
38
als das Nichtentdecken einer Dublette. Somit ist in solchen Fällen eine hohe precision
erforderlich, auch auf Kosten eines niedrigeren recall [vgl. Weis08]. Dies kann durch ein
gewichtetes F-Measure erreicht werden, das wie folgt definiert ist [Mann08, S.156]:
( )
Mit β=1 ergibt sich das F-Measure als harmonisches Mittel, wie oben beschrieben. Deswegen
spricht man dabei oft von dem F1-Measure.
39
5 Anforderungen, Vorgehensweise und Versuchsaufbau
In diesem Kapitel werde ich die Vorgehensweise bei der Evaluation beschreiben. Zuerst werde
ich die vorliegende Datenbasis vorstellen. Danach beschreibe ich, welche Anforderungen an
die einzelnen Schritte der Implementierung der Evaluation von mir gestellt wurden.
Anschließend widme ich mich der Implementierung des Versuchsaufbaus und den dabei
verwendeten Technologien und Softwaretechniken. Im Wesentlichen ist der Versuchsaufbau in
drei Teile unterteilt. Der erste Teil dient der Bestimmung der Ähnlichkeiten der vorliegenden
Dublettenkandidatenpaare. Im zweiten Teil geht es darum, auf der Basis dieser
Ähnlichkeitswerte automatisiert zu bestimmen, ob es sich bei den Kandidatenpaaren um
Dubletten handelt oder nicht. Der dritte Teil ist die Erfolgsmessung der Dublettenbestimmung,
die mithilfe der zu den Dublettenkandidaten zugehörigen, manuell erstellten
Dublettenmarkierung, durchgeführt wird. Diese manuelle Entscheidung wird der
automatischen gegenüber gestellt. Dabei werden die Abweichungen gemessen und bewertet.
5.1 Die Datenbasis
Um die Güte der automatischen Dublettenentscheidungen zu verifizieren, benötigt man
Dublettenkandidatenpaare, bei denen bereits bekannt ist, ob es sich um eine Dublette handelt
oder nicht. Um diese manuell zu erstellen, ist ein hoher Aufwand nötig. Offen zugängliche
Quellen mit Daten, bei denen die Dublettenzuordnungen bereits bekannt sind, die in der
Literatur auch golden standard genannt werden, sind äußerst rar. Daten dagegen, die im
Rahmen von Geschäftsprozessen verwendet werden und dabei auf Dubletten geprüft wurden,
sind oft aufgrund von Datenschutzbestimmungen oder Betriebsgeheimnissen nicht offen
zugänglich. Künstlich hergestellte Dublettenkandidaten spiegeln hingegen häufig nicht die
Probleme und Abweichungen wieder, die in der Praxis bei Dubletten vorkommen [vgl.
Naum10, S. 65f].
Bei den Daten, die für diese Evaluation zur Verfügung stehen, handelt es sich um deutsche
Firmenadressen. Die Dublettenkandidatenpaare entstanden im Rahmen eines
Geschäftsprozesses, bei dem zwei Datenbanken A und B, die Firmenadressen enthalten,
gegeneinander abgeglichen wurden. Täglich wurden die Neuzugänge und Änderungen aus der
Datenbank A gegen den kompletten Datenbestand der Datenbank B abgeglichen. Der Abgleich
bestand aus einer simplen Vergleichslogik. Verglichen wurden die Attributwerte der Attribute
Name, Straße, Postleitzahl und Ort der Adressen. Die in der Datenquelle verwendeten Namen
für die Attribute sind name, strasse, plz und ort. Die Werte der Attribute wurden vor dem
Abgleich in Kleinschreibung überführt. Bei einer Identität der Attribute wurde die
Dublettenentscheidung automatisch getroffen. Falls nur Teile der Attributwerte
übereingestimmt haben, wie zum Beispiel die Postleitzahl und die ersten fünf Buchstaben des
Namens, wurden die Datensätze zur manuellen Qualifizierung ausgesteuert. Falls keine
Übereinstimmung von Teilen der Attributwerte festgestellt wurde, wurden die Kandidaten
automatisch als „keine Dubletten“ gekennzeichnet. Aus Gründen des Betriebsgeheimnisses
40
muss hier leider auf eine detaillierte Beschreibung der Vergleichslogik verzichtet werden.
Abbildung 11 stellt schematisch den angesprochenen Prozess dar.
Abbildung 11 Die Qualifizierung von Dublettenkandidatenpaaren.
Bei der manuellen Dublettenklassifizierung hat ein Experte die Entscheidung getroffen, ob es
sich bei dem Kandidatenpaar um eine Dublette handelt oder nicht. Da es ein
geschäftskritischer Prozess ist, wurde dabei sehr sorgfältig gearbeitet. Somit kann man von
einer sehr geringen Quote an Falschzuordnungen ausgehen, wobei, wie bei jedem manuellen
Vorgang, Fehler nicht ausgeschlossen werden können. In diesem Prozess wurden circa 88
Kandidatenpaare pro Tag manuell qualifiziert. Die Daten für die Evaluation stammen direkt aus
dem System, in dem die manuelle Qualifizierung stattgefunden hat, und liegen in mehreren
Tabellen einer relationalen Datenbank vor.
Für die spätere Auswertung der Ergebnisse ist es wichtig zu wissen, dass bei der Entscheidung,
ob ein Dublettenkandidatenpaar eine Dublette darstellt oder nicht, prozessbedingt sehr auf
die rechtliche Eigenständigkeit der verglichenen Firmen geachtet wurde. Dazu ein Beispiel
eines Dublettenkandidatenpaars in
Tabelle 5, das bei der manuellen Bearbeitung als „keine Dublette“ markiert wäre. Der Grund ist
die unterschiedliche Rechtsform, einmal „GmbH“ und einmal „OHG“. Selbst wenn sich bei der
GmbH um eine Nachfolgefirma der OHG handelt, so stellen die beiden Datensätze, rechtlich
gesehen, Adressen von zwei unterschiedlichen Firmen dar [vgl. Schi02, S.36f].
Dubletten-
kandidatenpaar
Dublette Keine
Dublette
Manuelle
Qualifizierung
Automatische
Qualifizierung
41
Name Strasse PLZ Ort
Muster GmbH Musterstr. 11 12345 Musterstadt
Muster OHG Musterstr. 11 12345 Musterstadt
Tabelle 5 Ein Bespiel eines Dublettenkandidatenpaares, dass als „keine Dublette“ markiert wäre.
Für die Evaluation habe ich 88.072 Kandidatenpaare ausgewählt, die im Zeitraum von circa drei
Jahren manuell qualifiziert wurden. Die Menge enthält 3.227 Kandidatenpaare, die als
„Dublette“ qualifiziert wurden, und 84.845 Kandidatenpaare, die als „keine Dublette“
qualifiziert wurden. Für die Evaluation kann also eine große Menge manuell qualifizierter
Dublettenkandidatenpaare, die aus einem echten Geschäftsprozess stammen, verwendet
werden. Somit ist zu erwarten, dass die Evaluation durchaus praxisrelevante Ergebnisse für die
Güte einer automatisierten Dublettenerkennung in der Domäne der deutschen
Geschäftsadressen liefert.
5.2 Anforderungen an die Umsetzung der Evaluation
Die Evaluation soll in drei Schritten erfolgen. Im ersten Schritt wird für alle
Dublettenkandidatenpaare die Ähnlichkeit der Attribute bestimmt. Für die Berechnung der
Ähnlichkeit kommen die Ähnlichkeitsbestimmungsmethoden zum Einsatz, die in Kapitel 3
beschrieben wurden. Somit entsteht pro Kandidatenpaar und
Ähnlichkeitsbestimmungsmethode ein Vektor, der die Ähnlichkeiten der Attributwerte enthält.
Dieser Vektor soll dazu dienen, mithilfe der Dublettenbestimmungsmethoden aus Kapitel 4 zu
bestimmen, ob es sich bei den Dublettenkandidatenpaaren um Dubletten handelt oder nicht.
Im letzten Schritt wird diese Entscheidung mit der bereits manuell getroffen Entscheidung für
das jeweilige Kandidatenpaar verglichen. Dies ermöglicht Erfolgsauswertungen mithilfe der
Methoden aus dem Kapitel 4.4. Abbildung 12 stellt diesen Prozess schematisch dar. Im
Folgenden widme ich mich den Anforderungen, anhand dessen diese Schritte realisiert werden
sollen. Dieser Beschreibung soll als Grundlage für die Umsetzung dienen.
Abbildung 12 Grundlegender Versuchsaufbau.
Ähnlichkeitsbestimmung Dublettenbestimmung Erfolgsmessung
42
5.2.1 Ähnlichkeitsbestimmung
Die Ähnlichkeitsbestimmung soll für alle Dublettenkandidatenpaare die Ähnlichkeit der
Attribute name, strasse, plz und ort bestimmen. Zusätzlich soll die Ähnlichkeit eines künstlich
erzeugten Attributes all berechnet werden. Dieses Attribut soll den Inhalt der anderen
Attribute enthalten, die hintereinander geschrieben und mit Leerzeichen getrennt sind. Für die
Berechnung sollen alle in Kapitel 3 beschriebenen Ähnlichkeitsfunktionen angewendet
werden. Für die Funktionen, die Konfigurationsparameter enthalten beziehungsweise, wie die
hybriden Ähnlichkeitsfunktionen aus Kapitel 3.3, eine sekundäre Ähnlichkeitsfunktion
verwenden, soll es eine einfache und flexible Konfigurationsmöglichkeit geben. Die Ergebnisse
der Ähnlichkeitsbestimmung sollen in einer Datenbank persistiert werden.
Da die Ähnlichkeitsbestimmung ein komplexer Prozess ist, ist zu erwarten, dass für die
komplette Durchführung der Berechnung mithilfe aller Methoden eine Berechnungsdauer von
mehreren Stunden erforderlich sein wird. Deswegen soll es nach einer Konfiguration möglich
sein, die Ähnlichkeitsbestimmung für alle Kandidatenpaare und alle Konfigurationen der
Ähnlichkeitsfunktionen in einem manuell angestoßenen Schritt durchzuführen.
Für die Durchführung beziehungsweise die Implementierung der Ähnlichkeitsbestimmung soll
möglichst auf bereits vorhandene Implementierungen und Frameworks zurückgegriffen
werden. Diese sollen unter einer open source Lizenz stehen, die eine lizenzkostenfreie
Verwendung im Rahmen einer wissenschaftlichen Arbeit erlaubt.
5.2.2 Dublettenbestimmung
Die Ergebnisse der Ähnlichkeitsbestimmung bilden die Basis für die Dublettenbestimmung. Die
Dublettenbestimmung soll mit den Methoden aus Kapitel 4 durchgeführt werden, wobei
vorrangig die Methoden des maschinellen Lernens zu Einsatz kommen sollen. Zum Vergleich
sollen ähnlichkeitsbasierte Methoden aus Kapitel 4.1 verwendet werden. Bei den Methoden
des maschinellen Lernens sollen die Modelle, die in der Trainingsphase entstehen, ersichtlich
und auswertbar sein. Idealerweise sollten diese, wenn möglich, auch graphisch darstellbar
sein. Dies wäre zum Beispiel bei den Wahrscheinlichkeitsverteilungen der naive Bayes
Methode oder den induzierten Entscheidungsbäumen möglich.
Aufgrund der algorithmischen Komplexität der Verfahren des maschinellen Lernens soll eine
eigene Implementierung möglichst vermieden werden. Hier wäre eine geeignete Anwendung
beziehungsweise ein geeignetes Framework die bessere Wahl. Diese sollen die beschriebenen
Methoden implementieren, eine möglichst unkomplizierte Konfiguration bieten sowie die
Schritte des Lernens und der Evaluation beherrschen. Des Weiteren sollte die Anwendung
beziehungsweise die verwendeten Frameworks unter einer open source Lizenz stehen, die eine
lizenzkostenfreie Verwendung im Rahmen einer wissenschaftlichen Arbeit erlaubt.
43
5.2.3 Erfolgsmessung
Die Erfolgsmessung soll nach den Vorgaben aus dem Kapitel 4.4 erfolgen, also im Wesentlichen
precision, recall und F-Measure Messung vornehmen, und somit die Abweichung des
Ergebnisses der automatischen Methoden von der manuellen Dublettenbestimmung
ausdrücken. Da bei den gegebenen Daten sowohl eine hohe precision als auch ein hohes recall
gefragt ist, soll die ungewichtete Variante des F-Measures zum Einsatz kommen, auch F1-
Measure genannt. Das Zustandekommen der Metriken sollte transparent und nachvollziehbar
sein. Auch der Vergleich der automatischen Entscheidung mit der manuellen Markierung auf
der Ebene der einzelnen Dublettenkandidatenpaare soll möglich sein. Eine graphische
Auswertung der Metriken wäre ebenfalls wünschenswert.
5.3 Evaluationsimplementierung
In diesem Kapitel beschreibe ich, wie und mithilfe welcher Frameworks und Anwendungen, die
in Kapitel 5 beschrieben Anforderungen an die Evaluationsschritte von mir umgesetzt wurden.
5.3.1 Ähnlichkeitsbestimmung
Um die Anforderungen an die Ähnlichkeitsbestimmung zu realisieren, habe ich mich
entschlossen, eine eigene Implementierung zu erstellen. Es existieren einige wenige
Frameworks, die die Aufgabe haben, einen Vergleich verschiedener Methoden der
Ähnlichkeitsbestimmung zu ermöglichen. Eines davon ist DuDe: The Duplicate Detection
toolkit. Dieser wird in [Drai10] beschrieben und dort auch mit anderen, ähnlichen Frameworks
verglichen. DuDe entspricht weitgehend den Anforderungen, müsste allerdings erweitert
werden, da dieser nicht alle in Kapitel 3 beschriebenen Methoden der Ähnlichkeitsbestimmung
abdeckt. Außerdem ist DuDe darauf ausgerichtet, Dublettengruppen in größeren
Datenmengen zu suchen. Die Daten für die Evaluation liegen aber bereits als
Dublettenkandidatenpaare vor, sodass hier eine Anpassung des Frameworks nötig wäre. Des
Weiteren ist DuDe sehr generisch angelegt und bietet somit einiges an Funktionalität, die für
die Evaluation nicht benötigt wird. Diese generische Ausrichtung, wie zum Beispiel die interne
Darstellung der Daten in der JSON (JavaScript Object Notation, siehe dazu auch
http://json.org), ist in Bezug auf die Laufzeit kontraproduktiv. Aufgrund dieser Punkte habe ich
eine Entscheidung für eine eigene Implementierung getroffen, die gezielt und in möglichst
schlanker Form die Anforderung erfüllen soll.
Gemäß dem Werkzeug, Automat, Material-Ansatz (WAM-Ansatz) [vgl. Züll04], geht es bei der
Ähnlichkeitsbestimmung um die Implementierung eines Automaten. Diese Entwurfsmetapher
deckt sich mit dem in Anforderungen beschriebenen Szenario. Gemäß der Definition [Züll04,
S.70], ist ein Automat ein Gerät zum Behandeln von Material. Er soll Routinearbeiten
erledigen, die aus einer definierten Reihenfolge von Arbeitsschritten bestehen und zu einem
definierten Ergebnis führen, ohne eine menschliche Intervention. Normalerweise werden
44
Automaten im Hintergrund ausgeführt und einmal vor dem Start konfiguriert. Die Rolle des
Materials wird von den Dublettenkandidatenpaaren erfüllt. Ein Material ist laut Definition
[Züll04, S.68] ein Objekt, das mithilfe von Werkzeugen beziehungsweise Automaten bearbeitet
wird und auch ein Teil des Ergebnisses werden kann. Die Dublettenkandidatenpaare sollen von
dem Automaten bearbeitet werden, sodass als Ergebnis ein Ähnlichkeitsvektor entsteht, der
die Ähnlichkeiten der Attributwerte der Kandidatenpaare enthält.
Die Architektur der Implementierung soll sich an der 3-Schichten Architektur orientieren [vgl.
Züll04, S.297f]. Da keine Interaktion mit dem Benutzer geplant ist, entfällt die
Präsentationsschicht. Im Folgenden gehe ich auf die konkrete Implementierung der Daten- und
der Funktionsschicht ein.
Die Datenschicht enthält die Datenobjekte und kümmert sich um das Persistieren der
Datenobjekte in einer Datenbank. Die wesentlichen Datenobjekte sind hier DupeData, das die
Dublettenkandidatenpaare repräsentiert und SimResult, das die Ergebnisse der
Ähnlichkeitsbestimmung kapselt. Ein DupeData Objekt besteht im Wesentlichen aus Address
Objekten, die die Geschäftsadressen repräsentieren. SimResult enthält wiederrum SimScore
Objekte und entsprechende Referenz auf ein DupeData Objekt. Die Persistenz der
Datenobjekte wird mithilfe des DAO (Data Access Objects) Entwurfsmusters realisiert. DAOs
sind Objekte, die sich um das Persistieren und das Materialisieren von Datenobjekten
kümmern [vgl. Sun01]. Die Funktionsschicht greift auf die Datenschicht nur über die
Schnittstellen der DAOs. Die konkrete Implementierung der Persistenz ist für die
Funktionsschicht transparent.
Die Funktionsschicht implementiert die Logik des Abgleichautomaten. Ein wesentlicher Teil
dieser Logik sind die Implementierungen der Ähnlichkeitsfunktionen. All diese
Implementierungen besitzen eine gemeinsame, einheitliche Schnittstelle, die
StringComparatorService genannt wird. Diese erlaubt eine einfache Iteration über
verschiedene Implementierungen und ermöglicht eine unkomplizierte Erweiterung des
Automaten um weitere Ähnlichkeitsfunktionen. In dieser Schicht findet die Berechnung der
Ähnlichkeiten der Dublettenkandidatenpaare statt. Um die Durchführung der
Ähnlichkeitsberechnung kümmert sich die Implementierung der Schnittstelle
ComparisonService. Diese enthält nur eine Methode mit den Namen makeComparison. Die in
dieser Methode implementierte Logik iteriert über alle Dublettenkandidatenpaare. Zuerst
werden, falls nötig, Statistiken über alle Dublettenkandidatenpaare erstellt, die zum Beispiel
für die Berechnung der idf (inverse document frequency) notwendig sind. Für jedes
Kandidatenpaar werden dann alle vorkonfigurierten Ähnlichkeitsfunktionen auf den Werten
der Attribute name, strasse, plz, ort und all ausgeführt. Das Attribut all ist ein künstliches
Attribut, das als Wert die Werte aller anderen Attribute, hintereinander geschrieben und mit
Leerzeichen getrennt, enthält. Die entsprechenden Attributwerte werden vorher mit einer
Implementierung des PreparateComparsionService aufbereitet. Diese führt in der
Grundimplementierung die Umwandlung der Zeichenketten in Kleinbuchstaben durch. Die
Ergebnisse der Anwendung der Ähnlichkeitsfunktionen werden anschließend persistiert.
Abbildung 13 stellt den Prozess grafisch dar. Die blauen Pfeile symbolisieren die Iteration über
die Dublettenkandidaten. Die roten Pfeile stellen die verschachtelte Iteration über die
Dublettenkandidatenpaare und die verschiedenen Konfigurationen der Ähnlichkeitsfunktionen
dar.
45
Abbildung 13 Ablauf der Ähnlichkeitsbestimmung.
Die konkrete Implementierung des Automaten für die Ähnlichkeitsbestimmung erfolgte in der
Programmiersprache Java, Version 6. Diese wurde aufgrund der großen Anzahl frei erhältlicher
Entwicklungsumgebungen und Frameworks ausgewählt, die die Umsetzung erleichterten. Für
die Implementierung der meisten Ähnlichkeitsfunktionen habe ich die Bibliothek Simmetrics
verwendet. Diese Softwarebibliothek ist in Java implementiert und stellt im Wesentlichen eine
Sammlung von Implementierungen verschiedener Ähnlichkeits- und Tokenfunktionen dar [vgl.
Sour11]. Sie zeichnet sich gegenüber anderen Bibliotheken dieser Art, wie zum Beispiel Second
String [vgl. Cohe03], durch eine saubere Schnittstellendefinition und einheitliche
Rückgabewerte der Ähnlichkeitsfunktionen aus. Die in dieser Bibliothek nicht vorhandenen
Implementierungen von Ähnlichkeitsfunktionen habe ich mit eigenen Implementierungen
ergänzt. Abbildung 14 stellt die Struktur der Implementierung der Ähnlichkeitsfunktionen dar.
Aufbereiten der Attributwerte
Vorberechnen der idf Statistiken
Berechnen der Ähnlichekiten der Attributwerte
Persistieren der Ähnlichkeitswerte
46
Abbildung 14 Struktur der Implementierung der Ähnlichkeitsfunktionen.
Die Klasse SimmetricsStringComparatorService kapselt die Implementierungen der
Ähnlichkeitsfunktionen aus der Simmetrics Bibliothek. Die Abhängigkeit zu der konkreten
Implementierung wird anhand des Entwurfsmusters Dependency Injection hergestellt [vgl.
Fowl04]. Als Inversion of Control Container [vgl. Fowl04] dient dabei das Spring Framework.
Wie aus der Abbildung 14 ersichtlich, wurden die Ähnlichkeitsfunktionen für die Cosinus-
Ähnlichkeit mit tf/idf Gewichtung, Soft tf/idf Ähnlichkeit sowie Erweiterte Jaccard Ähnlichkeit,
selbst implementiert.
Die gesamte Implementierung baut auf dem Spring Framework auf. Neben der Funktion als
Inversion of Control Container bietet das Spring Framework eine einfache und flexible
Konfigurierbarkeit mittels einer XML Datei. Dies hilft bei der komplexen Konfiguration des
gesamten Automaten zur Ähnlichkeitsbestimmung. Alle Ähnlichkeitsfunktionen und weitere
für den Ablauf nötigen Parameter werden mithilfe dieser XML Datei konfiguriert. Für weitere
Informationen zum Spring Framework siehe [Wolf10].
Für die Kommunikation mit der Datenbank und die Realisierung der Persistenz wird JDBC (Java
DataBase Connectivity [vgl. Orac11]) eingesetzt. Wegen der teilweise komplexen SQL Anfragen
und der geringen Anzahl der unterschiedlichen, zu persistierenden Objekte, wurde auf einen
Einsatz eines ORM (Object-Relational Mapping [vgl. Ambl10]) Frameworks zur Abbildung der
Java-Objekte in einer relationalen Datenbank verzichtet. Um die Handhabung der Ressourcen
beim Einsatz von JDBC zu erleichtern, kommen die JDBC Helferklassen des Spring Frameworks
zum Einsatz [vgl. Wolf10, S.167f].
<<interface>>
StringComparatorService
AbstractStringComparatorService
AbstractStatisticalStringComparatorService
TfIdfStringComparatorService
SoftTfIdfStringComparatorService
ExtendedJaccardStringComparatorService
SimmetricsStringComparatorService
47
Da die der Evaluation zu Grunde liegenden Daten in Form von Relationen einer MySQL
Datenbank vorliegen, wurde für die gesamte Persistenz der Implementierung eine MySQL
Datenbank eingesetzt. Für weitere Informationen zur der MySQL Datenbank, siehe [Orac10].
Für das Logging in der Implementierung wird das Framework Logback eingesetzt. Es bietet
gegenüber anderen Open Source Loggingframeworks den entscheidenden Vorteil, dass die
Dokumentation von Logback frei verfügbar ist [vgl. Gülc11].
Für Tests der Implementierung, vor allem der Ähnlichkeitsfunktionen, wurden Testklassen
mithilfe des Frameworks JUnit implementiert [vgl. Pras09].
Als Build-Management-Tool kam Maven zum Einsatz. Dieses erlaubt ein standardisiertes
Erstellen und Verwalten von Java Applikationen [vgl. Obri11]. Insbesondere die komfortable
Verwaltung von Abhängigkeiten zu den anderen Softwareprojekten gab den Ausschlag für die
Verwendung von Maven.
Die gesamte Implementierung und Dokumentation in Form von JavaDoc ist auf einer CD im
Anhang C beigelegt.
5.3.2 Dublettenbestimmung und Erfolgsmessung
Die Implementierung der Dublettenbestimmung und Erfolgsmessung mithilfe von
ähnlichkeitsbasierten Entscheidungsverfahren, die im Kapitel 4.1 beschrieben wurden, erfolgte
als eine Eigenimplementierung. Zu diesem Zweck wurde ein Automat implementiert, der
ausgehend von den Ergebnissen der Ähnlichkeitsbestimmung, die Kennzahlen precision, recall
und F-Measure berechnet. Zuerst wird für jedes Kandidatenpaar eine Ähnlichkeitszahl
bestimmt. Bei dem „ein Attribut“ Verfahren ist es die Ähnlichkeit des künstlich erzeugten
Attributes all, bei dem Durchschnittsverfahren wird der ungewichtete Durchschnitt der
Ähnlichkeiten der Werte der Attribute name, strasse, plz und ort berechnet. Anschließend wird
für alle Schwellenwerte dieser Ähnlichkeit zwischen 0 und 1 in 0,01 Schritten die jeweilige
Anzahl von true positives, true negatives, false positives und false negatives berechnet und
persistiert. Im zweiten Schritt erfolgt auf dieser Basis die Berechnung von precision, recall und
F-Measure für alle Schwellenwerte. Die Ergebnisse der Berechnungen werden graphisch
beziehungsweise tabellarisch aufbereitet. Die graphische Aufbereitung erfolgt als HTML
Dokumente zur Anzeige im Browser, die tabellarische Aufbereitung in Form von Excel-
Tabellen. Die Implementierung erfolgte, analog zur Ähnlichkeitsbestimmung, mithilfe der
Programmiersprache Java und den bereits dort verwendeten Frameworks. Zusätzlich kamen
für die graphische Aufbereitung in HTML Dokumenten die Google Chart Tools zum Einsatz [vgl.
Goog11]. Die Erzeugung von Excel-Tabellen wurde mit dem Apache POI Framework realisiert
[vgl. Apac11].
Die Implementierung der Schritte der Dublettenbestimmung und Erfolgsmessung für die
Methoden des maschinellen Lernens, die im Kapitel 4.3 beschrieben wurden, erfolgte mithilfe
der Anwendung RapidMiner.
48
RapidMiner ist eine Anwendung, die eine Umgebung für maschinelles Lernen und Data Mining
zur Verfügung stellt. Innerhalb dieser Umgebung können Abläufe mithilfe von über 500
Operatoren erstellt werden. Die Operatoren decken unter anderem die Aufgaben der Ein- und
Ausgabe, Datenvorverarbeitung, maschinellen Lernens und Data Mining. Die definierten
Abläufe werden als XML Dateien gespeichert und können mittels einer graphischen
Benutzeroberfläche entwickelt werden. RapidMiner wurde 2001 unter den Namen YALE vom
Lehrstuhl für künstliche Intelligenz der Technischen Universität Dortmund entwickelt. Seit
2007 wird RapidMiner von der Firma rapid-i unter eine Open Source Lizenz weiterentwickelt.
RapidMiner ist in der Programmiersprache Java implementiert [vgl. Mier09].
RapidMiner wurde in erster Linie für die Evaluation ausgewählt, weil diese Anwendung alle
Algorithmen des maschinellen Lernens implementiert, die in Kapitel 4.3 vorgestellt wurden.
Des Weiteren ermöglicht diese Software eine einfache, graphische Modellierung sowohl der
Prozesse für die Trainingsphase der Algorithmen, als auch der Evaluation der Ergebnisse. Die
Modelle und auch die Ergebnisse der Evaluation können graphisch und sehr detailliert
dargestellt werden. Somit ist RapidMiner sowohl für die Dublettenbestimmung als auch für die
Erfolgsmessung geeignet. Es liegt unter Open Source Lizenz vor.
„Gemäß einer unabhängigen Vergleichsstudie der TU Chemnitz, die beim internationalen Data
Mining Cup 2007 (DMC-2007) vorgestellt wurde, schneidet RapidMiner unter den wichtigsten
Open Source Data Mining Tools sowohl hinsichtlich der Technologie als auch der
Anwendbarkeit am besten ab“ [Mier09].
Um eine Durchführung der Dublettenbestimmung zu ermöglichen, war es zunächst nötig, die
Ergebnisse der Ähnlichkeitsbestimmung aus der für die Persistenz verwendeten MySQL
Datenbank in die interne Repository von RapidMiner zu überführen. Die Repository dient bei
RapidMiner als Ablage für Daten, Prozesse, Modelle und Ergebnisse der Evaluationen. Der
Prozess des Ladens der Daten stellt Abbildung 15 dar.
Abbildung 15 Prozess des Ladens der Daten in die RapidMiner Repository.
Zunächst werden im Schritt Read Database die Daten mittels einer SQL Anweisung aus der
Datenbank gelesen. Im Schritt Nominal to Binomial wird das Attribut flag, das die Markierung,
ob es sich um eine Dublette handelt oder nicht, enthält, als Binomialattribut markiert. Im
weiteren Schritt Set Role wird das Attribut flag als sogenanntes label Attribut markiert. Dies
sind notwendige Schritte, um eine problemlose Datenverarbeitung im Rahmen des Trainings
49
der Dublettenbestimmungsmethoden zu gewährleisten. Anschließend werden die Daten im
Schritt Store inklusive der vorgenommenen Markierungen in der Repository von RapidMiner
gespeichert.
Um die Konfiguration der Dublettenbestimmungsprozesse zu erleichtern, bediente ich mich
einer Erweiterung für RapidMiner, die von dem Deutschen Forschungszentrum für Künstliche
Intelligenz GmbH entwickelt wurde. Die PaREn (Pattern Recognition Engineering) genannte
Erweiterung hilft beim Aufbau der Prozesse des maschinellen Lernens und beim Finden der
optimalen Konfigurationen für die einzelnen Verfahren, basierend auf der zur Verfügung
stehenden Lernmenge an Daten [vgl. Shaf10].
Für die weitere Optimierung der Parameter wurde der Operator Optimize Parameters (Grid)
verwendet. Dieser erlaubt das Optimieren der Parameter nach der Grid-Search Methode. Der
Operator iteriert durch die verschiedenen Kombinationen der vorher definierten Parameter
und führt für jede Kombination dieser Parameter den Schritt des Trainierens für den
gegebenen Algorithmus durch. Anschließend wird das trainierte Modell entsprechend auf eine
Teststichprobe angewendet. Als Ergebnis wird die Kombination von Parametern
zurückgegeben, die bezüglich einer definierten Zielgröße, in dem hier gegebenen Fall das F1-
Measure, die besten Ergebnisse liefert.
Für die eigentliche Evaluation wird ein Prozess mithilfe des Parallel:X-Validation Operators
aufgebaut. Dieser Operator führt eine Validierung eines gegebenen Operators für das
maschinelle Lernen durch. Dazu wird die Beispielmenge S, in diesem Fall die
Dublettenkandidatenpaare mit einer Dublettenmarkierung, in n Untermengen Si geteilt. Im
Schritt Training wird zuerst der Operator für das maschinelle Lernen mit der Menge von S / Si
Daten trainiert. Das so trainierte Model wird dann mithilfe der Datenmenge Si in Schritt
Testing erprobt. Dazu wird mithilfe des Operators Apply Model zuerst das im Schritt Training
erzeugte Modell auf die Datentestmenge angewendet. Anschließend werden im Schritt
Performance die vorher definierten Metriken für die Güte der Anwendung des Models
errechnet. Im Falle dieser Evaluation sind es precision, recall und F1-Measure. Diese Art von
Validierung wird Kreuzvalidierung genannt. Des Weiteren kann der Operator Parallel:X-
Validation die Schritte Training und Testing voneinander unabhängig und parallel ausführen.
Abbildung 16 zeigt den Aufbau der Kreuzvalidierung am Beispiel des Lernoperators für die
Lernmethode naive Bayes.
Abbildung 16 Kreuzvalidierung eines Operators am Beispiel von Naive Bayes.
50
6 Durchführung und Ergebnisse der Evaluation
In Kapitel 5 habe ich die Datenbasis für die Evaluation vorgestellt und Konzeption sowie
Implementierung der Evaluationsschritte Ähnlichkeitsbestimmung, Dublettenbestimmung und
Erfolgsmessung beschrieben. In diesem Kapitel wird die Durchführung der Evaluation
beschrieben. Es beinhaltet insbesondere die Beschreibung der verwendeten Konfigurationen
der Implementierungen sowie die Ergebnisse der Erfolgsmessung. Anschließend diskutiere ich
mögliche Verbesserungen der Verfahren zur automatisierten Dublettenerkennung. Ich werde
sowohl auf die von mir vorgenommenen Verbesserungen eingehen, als auch Ideen für weitere
Verbesserungen aufzeigen.
6.1 Ähnlichkeitsbestimmung
Die Ähnlichkeitsbestimmung wurde mithilfe der Ähnlichkeitsfunktionen, die in Kapitel 3
beschrieben wurden, in 15 verschiedenen Konfigurationen durchgeführt. Die
unterschiedlichen Konfigurationen können der
Tabelle 6 entnommen werden. Zusätzlich sollte erwähnt werden, dass bei den sekundären
Ähnlichkeiten, insofern diese gebraucht wurden, ein Schwellenwert von 0,8 verwendet wurde.
Für jede Konfiguration aus
Tabelle 6 wurden zwei Vergleiche durchgeführt. Einmal wurden die Attributwerte nur insofern
Aufbereitet, dass diese in Kleinschreibung umgewandelt wurden, um die Ähnlichkeit
unabhängig von der Groß-/Kleinschreibung zu berechnen. Das zweite Mal wurde die
Aufbereitung um die Vereinheitlichung von Abkürzungen erweitert. Zu diesem Zweck wurden
bei bestimmten Attributwerten folgende Ersetzungen vorgenommen: „gesellschaft“ wurde bei
Attribut name in „g“ umgewandelt und bei dem Attribut strasse wurde „strasse“
beziehungsweise „straße“ durch „str.“ ersetzt. Diese Art der Aufbereitung, auch als
Normierung bezeichnet, verlangt ein domänenspezifisches Wissen. Der Inhalt der zu
vergleichenden Attribute muss dem Ersteller dieser Normierungsregeln bekannt sein.
Deswegen werde ich im Folgenden von einer domänenspezifischen Aufbereitung der
Attributwerte sprechen. Mit dieser Aufbereitung sollte untersucht werden, inwiefern sich
solche Normierungen signifikant auf das Ergebnis der Erfolgsmessung auswirken.
Somit wurden für jedes Dublettenkandidatenpaar 30 Entscheidungsvektoren erstellt, die
jeweils fünf Dimensionen besitzen. Die Dimensionen entsprechen den verglichenen Werten
der Attribute name, strasse, plz, ort und all. Auf die entsprechenden Konfigurationen werde
ich im Folgenden mithilfe des Identifikators ID verweisen. Dabei besitzen die Konfigurationen
mit der einfachen Aufbereitung der Attributwerte die ID entsprechend der
Tabelle 6. Die Konfigurationen mit der domänenspezifischen Aufbereitung der Attributwerte
besitzen die ID aus der Spalte ID 2. So besitzt beispielsweise die Konfiguration mit der
Ähnlichkeitsfunktion Levenshtein und der einfachen Aufbereitung der Attributwerte gemäß der
Tabelle 6 die ID 7. Die Konfiguration mit der Ähnlichkeitsfunktion Levenshtein und der
domänenspezifischen Aufbereitung der Attributwerte entspricht demnach der ID 22.
51
ID ID 2 Ähnlichkeit Tokenizer Sekundäre Ähnlichkeit
1 16 Jaccard Leer- und Satzzeichen
2 17 Jaccard q-Gram q=2
3 18 Jaccard q-Gram q=3
4 19 Cosinus TF/IDF Leer- und Satzzeichen
5 20 Cosinus TF/IDF q-Gram q=2
6 21 Cosinus TF/IDF q-Gram q=3
7 22 Levenshtein
8 23 Needleman-Wunsch
9 24 Smith-Waterman-Gotoh
10 25 Jaro
11 26 Jaro-Winkler
12 27 Erweiterte Jaccard Leer- und Satzzeichen Levenshtein
13 28 Monge-Elkan Levenshtein
14 29 Soft TF/IDF Leer- und Satzzeichen Levenshtein
15 30 Monge-Elkan Smith-Waterman-Gotoh Tabelle 6 Die verwendeten Konfigurationen der Ähnlichkeitsfunktionen.
6.2 Dublettenbestimmung
Die Dublettenbestimmung mittels der ähnlichkeitsbasierten Methoden wurde mithilfe einer
eigenen Implementierung durchgeführt. Aufgrund der Einfachheit des Aufbaus wurde dieser
gemeinsam mit der Beschreibung der Implementierung im Kapitel 5.3.2 beschrieben.
Die Dublettenbestimmung mit den Methoden des maschinellen Lernens wurde mithilfe der
Anwendung RapidMiner durchgeführt. Zum Einsatz kamen fünf Verfahren aus dem Bereich des
maschinellen Lernens, die in Kapiteln 4.2 und vor allem 4.3 beschrieben wurden. Als
Datengrundlage kamen die bei der Ähnlichkeitsbestimmung erstellten Entscheidungsvektoren,
und zwar mit den Ähnlichkeitswerten für die Attributwerte der Attribute name, strasse, plz
und ort, zum Einsatz. Jeder Entscheidungsvektor wurde entsprechend mit der Markierung der
manuellen Entscheidung versehen, ob es sich bei dem Dublettenkandidatenpaar, zu dem
dieser Entscheidungsvektor gehört, um eine Dublette handelt oder nicht. Diese Markierung
wird bei RapidMiner als label bezeichnet. Für jede der 30 Konfigurationen der
Ähnlichkeitsfunktionen (15 mit jeweils zwei unterschiedlichen Aufbereitungsarten der
Attributwerte) wurde die Dublettenbestimmung mit den Methoden naive Bayes,
Entscheidungsbäume, Support Vectore Machine, Nächster-Nachbar-Qualifikation sowie
künstliche neuronale Netze durchgeführt. Dabei wurden im Vorfeld diejenigen
Entscheidungsvektoren rausgefiltert, die Fehlwerte enthielten, da die meisten hier
implementierten Verfahren mit solchen Werten nicht umgehen können. Fehlwerte entstanden
bei der Ähnlichkeitsbestimmung, wenn bei mindestens einem der beiden Dublettenkandidaten
bei einem der Attribute die Werte fehlten und infolge dessen keine Ähnlichkeit der
Attributwerte bestimmt werden konnte. In folgenden Kapiteln gehe ich genauer auf die
Konfigurationen der einzelnen Verfahren des maschinellen Lernens und auf die bei der
52
Trainingsphase entstandenen Entscheidungsmodelle ein. Die Ergebnisse, die durch die
Anwendung der jeweiligen Modelle auf die Evaluationsdaten entstanden sind, werden in
Kapitel 6.3 beschrieben.
6.2.1 Naive Bayes
Bei dem naive Bayes Verfahren werden für das Entscheidungsmodell die Dichtefunktionen für
die einzelnen Komponenten der Entscheidungsvektoren approximiert, da hier eine
Unabhängigkeit der einzelnen Komponenten angenommen wird. Für die Erstellung der
Dichtefunktionen wird eine Normalverteilung angenommen. Für weitere Details siehe Kapitel
4.2.1.
Die Konfiguration des Operators für naive Bayes hat lediglich einen Parameter. Dieser erlaubt
das Einschalten der Verwendung einer Laplace-Korrektur. Diese soll, laut der RapidMiner
Dokumentation, den starken Einfluss der Wahrscheinlichkeit 0 auf die berechnete
Gesamtwahrscheinlichkeit mindern. Diese Korrektur wurde verwendet.
Bei allen 30 Konfigurationen sehen die zu den trainierten Modellen zugehörigen
Dichtefunktionen ähnlich aus. Auffällig dabei ist, dass die Dichtefunktion für das Attribut name,
je nach dem jeweiligen label des Entscheidungsvektors, deutlich unterschiedlich ist. In
Abbildung 17 sieht man beispielhaft die beiden Dichtefunktionen. Die jeweiligen label der
Dublettenkandidatenpaare sind h für „Dublette“ und nh für „keine Dublette“. Diese
Bezeichnung der labels stammt aus den Originaldaten. Das Maximum der Dichtefunktionen für
keine Dublette ist bei einer Ähnlichkeit von circa 0,3. Das Maximum der Dichtefunktionen für
eine Dublette dagegen bei einer Ähnlichkeit von circa 0,9.
Abbildung 17 Dichtefunktion der Komponente des Entscheidungsvektors für das Attribut name.
53
Die Dichtefunktionen für „Dublette“ und „keine Dublette“ der anderen Attribute sehen
dagegen ähnlich der in Abbildung 18 dargestellten Funktionen für das Attribut ort aus. Hier
liegt bei beiden Funktionen das Maximum bei einer Ähnlichkeit von circa 1,0. Lediglich die
Dichtefunktion für „keine Dublette“ fällt etwas „flacher“ aus, was ein Hinweis für eine etwas
breitere Verteilung ist. Daraus kann man schließen, dass bei den zur Verfügung stehenden
Dublettenkandidatenpaaren vor allem die Ähnlichkeit des Attributwertes name dafür
ausschlaggebend ist, ob es sich um eine Dublette handelt oder nicht.
Abbildung 18 Dichtefunktion der Komponente des Entscheidungsvektors für das Attribut ort.
Die hier dargestellten Dichtefunktionen gehören zu den Entscheidungsvektoren der
Konfiguration der Ähnlichkeitsfunktion mit der ID 24, also Ähnlichkeitsfunktion Smith-
Waterman-Gotoh mit domänenspezifischer Aufbereitung der Attributwerte.
6.2.2 Entscheidungsbäume
Der RapidMiner Operator für die Erstellung von Entscheidungsbäumen verwendet einen
Algorithmus, der dem CART Algorithmus sehr ähnelt.
Die verwendete Konfiguration der Parameter für das Trainieren des Entscheidungsbaums und
die Beschreibung der Parameter gemäß der Dokumentation von RapidMiner kann
Tabelle 7 entnommen werden.
54
Parameter Wert Beschreibung
criterion gain_ratio Das Kriterium für die Auswahl der Attribute und der numerischen Spaltung. Weitere mögliche Ausprägungen: gain_ratio, information_gain, gini_index, accuracy.
minimal size of split 4 Die minimale Größe eines Knotens, um eine Spaltung zu ermöglichen.
minimal leaf size 2 Die minimale Größe aller Blätter.
minimal gain 0,1 Der minimale Gewinn, der erreicht werden muss, um eine Spaltung zu erzeugen.
maximal depth 20 Die maximale Tiefe des Baumes.
confidence 0,25 Das Konfidenzniveau, das für die pessimistische Fehlerberechnung der Vereinfachung (Pruning) verwendet wird.
Tabelle 7 Die Konfiguration des Operators für Entscheidungsbäume.
Die im vorherigen Kapitel 6.2.1 geäußerte Vermutung, dass die Dublettenentscheidung primär
von der Ähnlichkeit des Attributes name abhängt, bestätigt sich bei der Betrachtung des
ebenfalls für die Ähnlichkeitsfunktion mit der ID 24 induzierten Entscheidungsbaumes,
dargestellt in Abbildung 19. Auch hier stehen die jeweiligen label h für „Dublette“ und nh für
„keine Dublette“.
Abbildung 19 Entscheidungsbaum für die Konfiguration der Ähnlichkeitsfunktion mit der ID 24.
6.2.3 Support Vector Machine
name
ort nh
h nh
> 0,867 ≤ 0,867
> 0,613 ≤ 0,613
55
Die Software RapidMiner bietet verschiedene Operatoren, die eine SVM implementieren.
Meine Wahl fiel auf den Operator LibSVM, da diese Implementierung mittels PaREn (Pattern
Recognition Engineering, siehe Kapitel 5.3.2) optimiert werden kann. Diese Implementierung
bietet verschiedene SVM Typen. Verwendet habe ich C-SVM, ein für Klassifikationen
geeigneter Typ, der eine Kostenverteilung für die Klassen ermöglicht. Für den Wert des Faktors
C für die Kosten habe ich 0 verwendet, da beide Klassen gleich gewichtet werden sollten. Die
Implementierung erlaubt die Verwendung verschiedener Kerneltypen. Bei der Evaluation kam
der RBF (Radiale Basisfunktion) Kernel zum Einsatz. Der gamma Parameter für die
Kernelfunktion lag bei 0,05, die Toleranz der Terminierungskriteriums epsilon bei 0,001.
Das Modell einer SVM ist nicht so intuitiv und menschenlesbar, wie es zum Beispiel bei den
Entscheidungsbäumen der Fall ist. Auffällig jedoch war, dass eine sehr hohe Anzahl an
Stützvektoren verwendet wurde. Trotzdem gelang es der SVM in den meisten Fällen nicht eine
Trennung der beiden Klassen „Dublette“ und „keine Dublette“ zu erreichen. Das hatte zur
Folge, dass bei vielen Konfigurationen der Ähnlichkeitsfunktionen alle Entscheidungsvektoren
zur Klasse „keine Dublette“ zugeordnet wurden. Für Näheres zur Erfolgsmessung der
Methoden des maschinellen Lernens siehe Kapitel 6.3.2.
6.2.4 Nächste-Nachbarn-Klassifikation
Die Nächste-Nachbarn-Klassifikation besitzt als sogenanntes lazy learning Verfahren kein
eigenes Modell. Die Klassifikation eines neuen Entscheidungsvektors erfolgt durch die
Bewertung der am nächsten liegenden, bereits klassifizierten Vektoren. Der Operator wurde so
konfiguriert, dass die nächsten sieben Nachbarn ausgewertet wurden, und zwar je nach
Abstand gewichtet. Der Abstand wurde als euklidischer Abstand berechnet.
6.2.5 Künstliche neuronale Netze
Der Operator für künstliche neuronale Netze bei RapidMiner kann mittels der Backpropagation
of Error Algorithmus ein Netz in Form eines Multilayerperceptrons erstellen. Die Konfiguration
sah die Erstellung von zwei hidden Layer vor. Es sollten 500 Lernzyklen verwendet werden. Die
learning rate, die die Veränderung des Gewichts pro Schritt darstellt, betrug 0,6. Der
Parameter momentum, der den Bruchteil des vorhergehenden Gewichtsupdates bestimmt, das
auf das aktuelle Gewichtsupdate addiert wird, betrug 0,4. Es soll verhindern, dass lokale
Maxima gefunden werden. Der Parameter error epsilon hatte den Wert 0,00001. Dieser
bestimmt den erlaubten Fehler, bei dem die Berechnung abgebrochen werden kann.
Auch ein Modell eines künstlichen neuronalen Netzes ist für einen Menschen nicht einfach
lesbar, da dieser vor allem aus einer Menge von Eingangsgewichtungen besteht. Deswegen
verzichte ich an der Stelle auf eine ausführliche Darstellung des Modells. Alle erstellten
Modelle sind auf der CD im Anhang C beigefügt.
56
6.3 Erfolgsmessung und Ergebnisanalyse
Nach der erfolgten Dublettenbestimmung werde ich jetzt die Ergebnisse der Erfolgsmessung
vorstellen, die auch die Beurteilung erlaubten, welche Methoden der automatisierten
Dublettenbestimmung für die hier vorgestellte Domäne der deutschen Geschäftsadressen am
besten geeignet sind. Zuerst werde ich auf die Ergebnisse der einfachen, ähnlichkeitsbasierten
Entscheidungsverfahren, die in Kapitel 4.1 beschrieben wurden, eingehen. Diese sollen den
ersten Eindruck vermitteln, welche Methoden der Ähnlichkeitsbestimmung die besten
Ergebnisse liefern. Danach bespreche ich die Erfolgsmessungen der Verfahren des
maschinellen Lernens. Ich werde hier sowohl auf die Unterschiede zu den
ähnlichkeitsbasierten Methoden als auch auf die Unterschiede zwischen den Methoden des
maschinellen Lernens selbst eingehen. Anschließend werde ich beurteilen, inwiefern die
Methoden der automatisierten Dublettenerkennung mit der manuellen Dublettenerkennung
vergleichbare Ergebnisse erzielten.
Bei der Erfolgsmessung kamen die in Kapitel 4.4 beschrieben Kennzahlen precision, recall und
F1-Measure zum Einsatz. Das Ziel war es vor allem den Wert von F1-Measure zu maximieren.
6.3.1 Erfolgsmessung bei dem ähnlichkeitsbasierten
Entscheidungsverfahren
Für die Erfolgsmessung mittels des in Kapitel 4.1.1 beschriebenen „Ein Attribut“ Verfahrens
wurde das Argument all erstellt, das als Inhalt die Werte der Attribute name, strasse, plz und
ort enthält, getrennt jeweils durch ein Leerzeichen. Für alle Dublettenkandidatenpaare wurde
die Ähnlichkeit der Werte dieses Attributs mit den 15 in Kapitel 6.1 besprochenen
Konfigurationen der Ähnlichkeitsfunktionen berechnet. Hier kamen nur die Varianten ohne die
domänenspezifischen Optimierungen zum Einsatz. Anschließend wurden für die
Ähnlichkeitsschwellenwerte zwischen 0 und 1 in 0,01 Schritten jeweils precision, recall und
daraus resultierender F1-Measure berechnet. Für die Berechnung wurde als Referenz die
Markierung der manuellen Zuordnung der Dublettenkandidatenpaare verwendet. Die
Ergebnisse für die jeweils besten F1-Measures in Prozent können im Anhang A, Abbildung 20
betrachtet werden.
Der beste Wert wurde mithilfe der Jaccard-Ähnlichkeit mit einem q-Gramm Tokenizer mit q=2
ermittelt, und zwar bei einem Schwellenwert von 71%. Der damit ermittelte F1-Measure Wert
von 52,69% setzt sich zusammen aus einer precision von 53,46% und einem recall von 51,94%.
Grundsätzlich lässt sich beobachten, dass die Token-basierten Methoden mit q-Gramm
Tokenizer hier tendenziell am besten abschneiden. Dies bestätigt die Annahme, dass diese
Methoden für längere Zeichenketten gut geeignet sind. Trotzdem sind die gemessenen Werte
insgesamt sehr niedrig. Bei der Evaluation in [Bile03] zum Beispiel wurden teilweise F1-
Measure Werte von über 90 Prozent gemessen, allerdings mit teilweise künstlich erstellten
Dubletten.
57
Als nächstes habe ich eine Messung mithilfe des im Kapitel 4.1.2 beschriebenen
Durchschnittsverfahrens durchgeführt. Das Vorgehen war analog zu dem „Ein Attribut“
Verfahren. Der zugrunde liegende Ähnlichkeitswert ergab sich diesmal als der
durchschnittliche Wert der Ähnlichkeitswerte der Attribute name, strasse, plz und ort. Es
kamen alle 30 Konfigurationen der Ähnlichkeitsfunktionen zum Einsatz und zwar die 15
Grundkonfigurationen und weitere 15 Konfigurationen mit domänenspezifischen
Optimierungen, wie in Kapitel 6.1 beschrieben. Die Ergebnisse sind im Anhang A, Abbildung 21
dargestellt.
Diesmal wurde der beste Wert für F1-Measure mit 56,49% bei der Smith-Waterman-Gotoh
Ähnlichkeit gemessen, und zwar bei der Version mit domänenspezifischen Optimierungen. Der
optimale Schwellenwert betrug 93%. Der ermittelte Wert setzte sich zusammen aus einer
precision von 53,20% und einem recall von 60,22%. Der zweitbeste Wert mit 54,16% erzielte
die Smith-Waterman-Gotoh Ähnlichkeit ohne domänenspezifische Optimierungen. Danach
folgt die Monge-Elkan Ähnlichkeit mit Smith-Waterman-Gotoh als Sekundärähnlichkeit, jeweils
mit einem F1-Measure Wert von 53,82% in der domänenspezifisch optimierten Variante und
53,11% in der nicht optimierten Variante. Bei dieser Messung schnitten die Edit-basierten
beziehungsweise hybriden Ähnlichkeitsfunktionen besser ab als die Token-basierten. Es lässt
sich auch beobachten, dass die domänenspezifischen Optimierungen fast immer zu einer
Verbesserung des F1-Measures beigetragen haben. Insgesamt sind die ermittelten Werte auch
besser, als bei dem „Ein Attribut“ Verfahren.
6.3.2 Erfolgsmessung bei dem Verfahren des maschinellen Lernens
An dieser Stelle werde ich die Ergebnisse der Erfolgsmessung der Dublettenbestimmung
mithilfe der Methoden des maschinellen Lernens erörtern. Die vollständigen Ergebnisse in
tabellarischer Form können Anhang B entnommen werden. Die Erfolgsmessung wurde mithilfe
der in Kapitel 5.3.2 beschriebenen Kreuzvalidierung durchgeführt. Dabei wurde die
Grundgesamtheit der Daten in drei Untermengen zufällig unterteilt, bei denen das Verhältnis
der Anzahl von „Dubletten“ und „nicht Dubletten“, im Vergleich zu der Gesamtmenge,
beibehalten wurde.
Allgemein ist zu beobachten, dass, bis auf SVM, die Ergebnisse der Klassifikation mit den
Methoden des maschinellen Lernens denen des Durschnittverfahrens ähneln.
Bei der SVM ist auffällig, dass es dem Lernverfahren für die meisten Konfigurationen der
Ähnlichkeitsfunktionen nicht gelungen ist, eine geeignete Hyperebene zu finden, um eine
Klassifizierung vorzunehmen. Hier schneidet die Jaccard-Ähnlichkeit mit q-Gramm Tokenizer
(q=2) noch am besten ab mit den F-Measure Wert von 49,35% für die domänenoptimierte
Variante beziehungsweise 48,39% für die nicht optimierte. Dies sind Werte, die sogar
schlechter sind als bei den ähnlichkeitsbasierten Entscheidungsverfahren für diese
Ähnlichkeitsfunktion.
Bei dem naive Bayes Verfahren schneidet die Smith-Waterman-Gotoh Ähnlichkeit am besten
ab mit dem F-Measure von 56,54% für die Version ohne domänenspezifische Optimierung und
58
55,38% für die Version mit einer Optimierung. Als drittes folgt die Monge-Elkan Ähnlichkeit
ohne domänenspezifische Optimierung mit einem F-Measure Wert von 50,01%. Diese Werte
kommen den Werten des Durschnittverfahrens sehr nahe, sind aber geringfügig schlechter.
Somit bietet auch dieses Verfahren offensichtlich keinen Mehrwert gegenüber den einfachen,
ähnlichkeitsbasierten Entscheidungsverfahren.
Ähnliche Ergebnisse liefert auch die Nächste-Nachbarn-Klassifikation. Hier erreicht die
optimierte Monge-Elkan Ähnlichkeit mit einem F-Measure Wert von 55,56% das beste
Ergebnis. Nur wenig schlechter sind die Ergebnisse der Smith-Waterman-Gotoh Ähnlichkeit mit
jeweils 55,19% für die optimierte und 54,12% für die nicht optimierte Variante.
Etwas bessere Ergebnisse als mit den ähnlichkeitsbasierten Entscheidungsverfahren ließen sich
mithilfe der künstlichen neuronalen Netze erreichen. Hier schnitt wieder die Smith-Waterman-
Gotoh Ähnlichkeit am besten ab. Die F1-Measure Werte waren jeweils 58,98% für die Version
mit domänenspezifischen Optimierung und 58,77% ohne Optimierung. Das drittbeste Ergebnis
erzielte die optimierte Monge-Elkan Ähnlichkeit mit einem F-Measure Wert von 55,77%.
Die besten Ergebnisse wurden jedoch mit den Entscheidungsbäumen erzielt. Hier erreichte die
besten Werte wieder die Smith-Waterman-Gotoh Ähnlichkeit mit einem F1-Measure Wert von
60,18% beziehungsweise 60,02%, wobei auch hier die Variante mit domänenspezifischen
Optimierungen die bessere war. Als drittbeste Methode folgte die Jaro Ähnlichkeit ohne
domänenspezifische Optimierungen mit einem F1-Measure Wert von 54,77%.
6.3.3 Analyse und Beurteilung der Ergebnisse
Insgesamt kann man, basierend auf dem bisherigen Beobachtungen, sagen, dass für die
automatisierte Dublettenerkennung in der Domäne der deutschen Geschäftsadressen die
Smith-Waterman-Gotoh Methode für die Ähnlichkeitsmessung und Erstellung der
Entscheidungsvektoren am besten geeignet ist. Für die Entscheidungsfindung sind bestimmte
Methoden des maschinellen Lernens besser geeignet als die einfachen, ähnlichkeitsbasierten
Methoden. Darunter liefern die Entscheidungsbäume die besten Ergebnisse. Das ist, in
Anbetracht der Ergebnisse anderer Evaluierungen, wie zum Beispiel bei [Bile03], oder des sehr
einfachen Modells des Entscheidungsbaums, der in Kapitel 6.2.2 vorgestellt wurde, etwas
überraschend. Auch die domänenspezifischen Optimierungen scheinen einen positiven Effekt
zu haben, und das, obwohl für die Evaluierung nur sehr einfache, in Kapitel 6.1 beschriebene,
Optimierungen zum Einsatz kamen. Trotzdem erscheint der beste erzielte Wert für das F1-
Measure von 60,18% nicht besonders hoch. Die genaue quantitative Zusammensetzung für
dieses Ergebnis kann in
Tabelle 8 betrachtet werden. Die Entscheidungen basierten auf den Entscheidungsvektoren,
die mithilfe der domänenspezifisch optimierten Smith-Waterman-Gotoh Ähnlichkeitsfunktion
erstellt wurden.
59
Keine
Dublette
Dublette Summe
Als keine
Dublette
klassifiziert
83.393 1.213 84.606
Als Dublette
klassifiziert
1.452 2.014 3.466
Summe 84.845 3.227 88.072
Tabelle 8 Das Ergebnis der Erfolgsmessung für die Smith-Waterman-Gotoh Ähnlichkeitsfunktion mit domänenspezifischen Optimierungen und der Entscheidung mittels eines Entscheidungsbaums.
Wenn man das Ergebnis unter dem Aspekt der Fehlerquote betrachtet, so wurden von 88.072
Dublettenkandidatenpaaren 2.665 falsch qualifiziert. Das wäre eine Fehlerquote von circa 3%.
Diese Betrachtung veranlasste mich, die 2.665 falsch qualifizierten Dublettenkandidatenpaare
genauer zu betrachten. So habe ich eine eigene manuelle Qualifizierung dieser
Dublettenkandidatenpaare vorgenommen. Bei dieser manuellen Qualifizierung habe ich bei
1.583 Dublettenkandidatenpaaren eine andere Entscheidung getroffen, als die bereits bei den
Daten gespeicherte. Dabei habe ich immer die ursprüngliche manuelle Entscheidung in
Betracht gezogen und diese nur verändert, wenn sie offensichtlich falsch war. Wenn man
annimmt, dass es sich bei den 1.583 Dublettenkandidatenpaaren um alle falsche
Entscheidungen, die bei der manuellen Qualifizierung getroffen wurden, handelt, so lag die
Fehlerquote der ursprünglichen manuellen Entscheidung bei circa 1,8%. Mit den korrigierten
Entscheidungen habe ich eine erneute Qualifizierung mithilfe der Methoden des maschinellen
Lernens vorgenommen. Das bedeutet, dass ich dieselben Entscheidungsvektoren verwendet
habe und lediglich bei 1.583 Vektoren ein von mir korrigiertes label verwendet habe. Die
Ergebnisse für die mit der Smith-Waterman-Gotoh Ähnlichkeitsfunktion erstellten
Entscheidungsvektoren sind in
Tabelle 9 zusammengefasst, absteigend sortiert nach dem F1-Measure.
Methode precision recall F1-Measure
Entscheidungsbaum 80,78% 75,20% 77,89%
Neuronales Netz 82,97% 72,46% 77,37%
SVM 80,52% 72,95% 76,55%
k-NN 83,06% 70,53% 76,28%
Naive Bayes 57,71% 80,89% 67,36% Tabelle 9 Die Ergebnisse der Erfolgsmessung für die Smith-Waterman-Gotoh Ähnlichkeitsfunktion mit domänenspezifischen Optimierungen mit den korrigierten Labels für die manuelle Entscheidung.
60
Es fällt sofort auf, dass alle relevanten Messzahlen deutlich besser sind als vor der Korrektur.
Des Weiteren wurde auch mittels einer SVM ein zu den besten Verfahren ähnlich gutes
Ergebnis erzielt. Dies scheint ein Hinweis darauf zu sein, dass es vorher, vor allem wegen der
fehlerhaften Labels, nicht möglich war, ein zufriedenstellendes SVM Modell zu erstellen.
Davon abgesehen wurde das beste Ergebnis mit einem F1-Measure von 77,88% erneut mithilfe
eines Entscheidungsbaumes erreicht. Ein ähnlich gutes Ergebnis erreichte auch das künstliche
neuronale Netz mit 77,36%. Das detaillierte Ergebnis für das beste F1-Measure, das mittels
eines Entscheidungsbaums erreicht wurde, stellt
Tabelle 10 dar.
Keine
Dublette
Dublette Summe
Als keine
Dublette
klassifiziert
83.736 912 84.648
Als Dublette
klassifiziert
658 2.766 3.424
Summe 84.394 3.678 88.072
Tabelle 10 Das Ergebnis der Erfolgsmessung für die Smith-Waterman-Gotoh Ähnlichkeitsfunktion mit domänenspezifischen Optimierungen mit den korrigierten Labels für die manuelle Entscheidung, erzeugt mithilfe eines Entscheidungsbaums.
Diesmal wurden lediglich 1.570 Dublettenkandidatenpaare falsch klassifiziert. Das sind 13
weniger, als die im vorhergehenden Schritt korrigierten Labels für die manuelle Entscheidung.
Auch bei der Annahme, dass alle falschen manuellen Entscheidungen gefunden und korrigiert
wurden, ergibt sich bei der automatisierten Dublettenerkennung eine beinahe gleiche
Fehlerquote. Dies lässt den Schluss zu, dass es möglich ist, mithilfe automatisierter Methoden
ein mindestens ähnlich gutes Ergebnis zu erreichen, wie mithilfe einer manuellen
Klassifizierung durch Experten.
6.3.4 Analyse der Fehlerbilder
Bei der Betrachtung der mittels der besten automatischen Methode immer noch falsch
klassifizierten Dublettenkandidatenpaare wird klar, dass eine weitere Optimierung der
automatischen Klassifikation nur mithilfe von Methoden möglich ist, die ein gutes
Domänenwissen voraussetzen. Im Folgenden stelle ich drei typische Beispiele für eine falsche
Zuordnung gegenüber der manuellen Entscheidung, die mittels der automatischen Methode
61
erstellt wurde, vor. Dabei werde ich die Gründe für die Korrektur der Entscheidung erörtern
und gegebenenfalls Verbesserungsvorschläge für die automatische Methode beschreiben.
Obwohl die Smith-Waterman-Gotoh Ähnlichkeitsfunktion eine Toleranz gegenüber einem
Austausch gesamter Zeichenblöcke oder Unterschieden in Prä- und Suffixen besitzt fällt auf,
dass manche der unterschiedlichen Zeichenblöcke für diese Methode offensichtlich zu lang
oder nicht zusammenhängend genug sind. Dies führt dazu, dass die berechnete Ähnlichkeit zu
niedrig ausfällt, um eine korrekte Klassifizierung zu gewährleisten. Ein Bespiel dafür ist der
Vergleich folgender Werte des Attributs name: „ABCD Verwalt. + Bewirtschaft. GmbH
Zivildienstschule“ und „ABCD Verwaltung und Bewirtschaftung GmbH“. Die Smith-Waterman-
Gotoh Ähnlichkeitsfunktion liefert hier eine Ähnlichkeit von nur circa 64%. Obwohl die Werte
der anderen Attribute gleich sind und es sich offensichtlich um dieselbe Firma handelt, kommt
es zu einer Klassifizierung als „nicht Dublette“. In solchen Fällen kann eine domänenspezifische
Normierung im Sinne der Vereinheitlichung der verwendeten Abkürzungen helfen. So würde
die Ersetzung von „Verwalt.“ durch „Verwaltung“, „Bewirtschaft.“ durch „Bewirtschaftung“
und „+“ durch „und“ zu einer Ähnlichkeit des Attributwertes von 100% führen und somit zu
einer korrekten Zuordnung als „Dublette“.
Ein typisches Beispiel für eine falsche automatische Klassifizierung als „Dublette“ wäre bei
Werten des Attributes name von „ABCD GmbH“ und „ABCD GmbH & Co. KG“. Alle anderen
Attributwerte sind identisch. Der Attributwert von name erhält hier eine Ähnlichkeit von 100%,
da nur ein Unterschied im Suffix besteht, was zu keiner Abwertung bei der Smith-Waterman-
Gotoh Ähnlichkeitsfunktion führt. Korrekt wäre hier eine Klassifizierung als „nicht Dublette“, da
beide Unternehmen eine unterschiedliche Rechtsform besitzen und somit rechtlich
eigenständige juristische Personen darstellen [vgl. Schi02 S. 36f]. Um hier und in anderen
solchen Fällen eine korrekte Entscheidung zu erreichen, wäre eine Extraktion der Rechtsform
aus den Namen nötig. In einem der Ähnlichkeitsbewertung vorgelagerten Schritt könnte die
Rechtsform im Attribut name erkannt werden und in ein neues Attribut rechtsform
geschrieben werden. Die Ähnlichkeit der Werte dieses Attributs könnte dann den
Entscheidungsvektor entsprechend erweitern. Aufgrund der vielen in Deutschland zulässigen
Rechtsformen sowie deren Varianten für die Schreibweise stellt eine solche Extraktion, selbst
nur für die Domäne der deutschen Geschäftsadressen, kein triviales Unterfangen dar.
Ein nicht so eindeutiges Beispiel für falsche automatische Zuordnung wäre der Fall, wenn nur
der Wert des Attributs strasse keine Ähnlichkeit besitzt, die sonstigen Attributwerte aber
identisch sind. Das könnte einerseits darauf hinweisen, dass einer der Datensätze nicht aktuell
ist und inzwischen ein Wechsel des Unternehmenssitzes stattgefunden hat, zum Beispiel in
Folge eines Umzugs. In einem solchen Fall würde es sich trotzdem um eine „Dublette“
handeln, da die beiden Datensätze dasselbe Unternehmen beschreiben. Es könnte sich aber
auch um zwei Filialen einer großen Handelskette in der gleichen Stadt handeln, die oft, trotz
der Namensgleichheit oder großen Ähnlichkeit des Namens, juristisch eigenständige
Unternehmen darstellen. In einem solchen Fall wäre dieses Kandidatenpaar als „keine
Dublette“ zu kennzeichnen. Doch eine solche Entscheidung wäre nur mithilfe zusätzlicher
Informationen möglich, wie zum Beispiel einer Umzugsdatenbank oder mit Kenntnissen der
Unternehmensstrukturen. Solche Fälle müssten unter Umständen einer Klasse der möglichen
Dubletten zugeordnet werden. Eine Entscheidung würde dann manuell vorgenommen werden.
62
Automatisierte Lösungen sind denkbar, aber mit großem Aufwand verbunden. Ein Zugriff auf
strukturierte Zusatzinformationen wäre hier nötig.
63
7 Zusammenfassung, Fazit und Ausblick
Im folgenden Kapitel werde ich noch mal die im Rahmen dieser Arbeit vorgenommene
Evaluation zusammenfassen. Im Fazit werde ich abschließend die Ergebnisse noch einmal kurz
vorstellen und bewerten. Anschließend werde ich einen Ausblick geben, wie eine mögliche
Fortführung der Arbeit aussehen könnte.
7.1 Zusammenfassung
Im Rahmen dieser Arbeit habe ich eine Evaluation vorgenommen, dessen Ziel ein Vergleich der
aktuellen Methoden der automatisierten Dublettenerkennung war. Dieser Vergleich bezog sich
sowohl auf einen Vergleich der Methoden untereinander als auch auf einen Vergleich der
automatisierten Methoden mit einer manuellen Dublettenerkennung.
Als Grundlage der Evaluation diente ein Datenbestand mit 88.072 Dublettenkandidatenpaaren,
die bereits manuell klassifiziert wurden. Die Daten gehören der Domäne der deutschen
Geschäftsadressen und enthalten die Attribute für Name, Straße, Postleitzahl und Ort.
Im Rahmen der Evaluation wurden im ersten Schritt für jedes Dublettenkandidatenpaar
Entscheidungsvektoren erstellt, die als Grundlage für die automatisierte Entscheidung dienten,
ob es sich bei dem Dublettenkandidatenpaar um eine Dublette handelt oder nicht. Diese
Entscheidungsvektoren wurden mithilfe unterschiedlicher Ähnlichkeitsfunktionen für
Zeichenketten erstellt. Jeder Entscheidungsvektor setzte sich zusammen aus den Ähnlichkeiten
der Attributwerte, besaß also insgesamt fünf Dimensionen, vier für die bereits enthaltenen
Attribute und einen Wert für das künstlich erzeugte Attribut all.
Im zweiten Schritt wurde, mithilfe der Entscheidungsvektoren sowie verschiedener
automatischer Entscheidungstechniken, für jedes Dublettenkandidatenpaar die Entscheidung
getroffen, ob es sich um eine Dublette handelt oder nicht. Dieser Entscheidung wurde dann
jeweils mit der bereits manuell getätigten Entscheidung verglichen. Auf diese Weise war es
möglich, eine Erfolgsmessung durchzuführen. Es kamen zwei einfache, ähnlichkeitsbasierte
Entscheidungsmethoden zum Einsatz, sowie fünf Methoden aus dem Bereich des maschinellen
Lernens. Das Vorhandensein der manuellen Klassifizierung ermöglichte ein Training der
Methoden des maschinellen Lernens.
Das erhaltene Ergebnis habe ich einer Beurteilung unterzogen. Anschließend habe ich die
ausgewählten Fehlerbilder der automatisierten Zuordnung analysiert und Lösungsvorschläge
für diese erarbeitet.
64
7.2 Fazit
Der Vergleich der Methoden der automatisierten Dublettenerkennung hat für die gegebenen
Daten ergeben, dass die am besten geeignete Methode für die Erstellung der
Entscheidungsvektoren die Smith-Waterman-Gotoh Ähnlichkeitsfunktion ist. Als die beste
Entscheidungsmethode für Dubletten erwiesen sich die Entscheidungsbäume. Ein Vergleich mit
der manuellen Klassifizierung der Dubletten ergab, dass die von den automatischen Methoden
erreichten Fehlerquoten auf einem ähnlichen Niveau lagen, wie bei der manuellen
Klassifizierung. Mithilfe der vorgestellten Verbesserungsvorschläge ließe sich, auch wenn mit
einem nicht unerheblichen Aufwand, auch ein besseres Ergebnis für die automatisierten
Methoden erreichen. Es konnte also gezeigt werden, dass in der Praxis die Methoden der
automatisierten Dublettenerkennung eine mit einem menschlichen Bearbeiter vergleichbarer
Zuverlässigkeit erreichen können, die sich mithilfe eines guten Domänenwissens noch steigern
lässt.
Als zusätzliches Ergebnis dieser Arbeit entstanden Modelle für verschiedene Methoden des
maschinellen Lernens, die sicherlich für die Domäne der deutschen Geschäftsadressen, den
gleichen Aufbau bezüglich der Attribute vorausgesetzt, in der Praxis einsetzbar sind. Somit
können die hier erreichten Ergebnisse durchaus als praxisrelevant bezeichnet werden.
7.3 Ausblick
Obwohl die in Rahmen der hier durchgeführten Evaluation verwendeten Daten nicht
veröffentlicht werden können, ergeben sich durchaus Möglichkeiten, aufbauend auf den hier
vorgestellten Ergebnissen weitere Evaluationen durchzuführen oder die Ergebnisse dieser
Arbeit in der Praxis umzusetzen. Zum einen könnten die hier veröffentlichten Modelle für die
Methoden des maschinellen Lernens mithilfe weiterer Daten aus der Praxis validiert und auf
Ihre Allgemeingültigkeit im Rahmen der Domäne der deutschen Geschäftsadressen geprüft
werden. Zum anderen könnten die hier vorgestellten, domänenspezifischen Optimierungen
umgesetzt und implementiert werden. So können die im Rahmen dieser Arbeit
veröffentlichten Modelle verfeinert und für einen Einsatz in der Praxis überarbeitet werden.
65
Anhang A
Dieser Anhang enthält in grafisch aufbereiteter Form die Ergebnisse für die jeweils besten, mit
den Methoden der ähnlichkeitsbasierten Entscheidungsverfahren ermittelten F1-Measures in
Prozent. Die IDs der Konfigurationen der Ähnlichkeitsfunktionen können dem Kapitel 6.1
entnommen werden. Der Wert in Klammern, hinter der ID der Konfiguration der
Ähnlichkeitsfunktion, ist der Schwellenwert in Prozent, bei dem der jeweils beste F1-Measure
Wert ermittelt wurde. Die Werte sind nach dem ermittelten F1-Measure absteigend sortiert.
Abbildung 20 Die besten F1-Measure Werte, ermittelt mithilfe der „Ein Attribut“ Methode für die Ähnlichkeit des Wertes des Attributs all.
39,05%
39,69%
39,97%
40,69%
41,24%
42,99%
43,48%
46,70%
46,86%
47,17%
48,60%
50,88%
52,16%
52,52%
52,69%
8 (91%)
4 (57%)
1 (44%)
12 (50%)
13 (83%)
14 (67%)
7 (82%)
9 (88%)
5 (79%)
10 (82%)
6 (74%)
11 (92%)
15 (96%)
3 (64%)
2 (71%)
F1-Measure
66
Abbildung 21 Die besten F1-Measure Werte, ermittelt mithilfe der Durchschnittsmethode für den Durschnitt der Ähnlichkeiten der Werte der Attribute name, strasse, plz und ort.
31,72%
32,18%
33,29%
33,30%
34,35%
35,67%
36,43%
37,64%
39,63%
40,42%
40,59%
43,77%
44,33%
44,86%
48,75%
48,80%
49,03%
49,05%
49,05%
49,42%
49,84%
50,24%
50,60%
50,88%
51,07%
52,57%
53,11%
53,82%
54,16%
56,49%
19 (71%)
16 (65%)
4 (69%)
1 (65%)
12 (73%)
27 (73%)
13 (87%)
28 (87%)
8 (93%)
14 (75%)
23 (93%)
29 (78%)
7 (88%)
22 (88%)
5 (85%)
3 (79%)
6 (84%)
20 (86%)
21 (83%)
2 (83%)
10 (93%)
18 (79%)
11 (97%)
17 (83%)
26 (97%)
25 (94%)
15 (98%)
30 (98%)
9 (92%)
24 (93%)
F1-Measure
67
Anhang B
In diesem Anhang sind die Ergebnisse der Erfolgsmessung der Dublettenbestimmung mittels
der Methoden des maschinellen Lernens in tabellarischer Form zusammengefasst. Zu jeder
Konfiguration der Ähnlichkeitsfunktion können die ermittelten Werte von precision, recall und
F1-Measure den Tabellen entnommen werden. Die Spalte „F1-Measure Durschnitt“ enthält
den Wert des F1-Measures, der als Mittelwert einer dreifachen Kreuzvalidierung ermittelt
wurde. Näheres dazu siehe Kapitel 5.3.2. Die Werte sind nach der Spalte „F1-Measure
Durschnitt“ absteigend sortiert.
Ähnlichkeit precision recall F1-Measure F1-Measure Durschnitt
9 48,32% 68,14% 56,54% 56,54%
24 46,66% 68,11% 55,38% 55,38%
15 44,99% 56,31% 50,02% 50,01%
5 42,33% 58,82% 49,23% 49,25%
20 42,06% 58,66% 48,99% 49,01%
28 58,09% 38,15% 46,05% 46,04%
13 57,76% 37,93% 45,79% 45,79%
6 34,83% 61,36% 44,44% 44,44%
21 34,74% 61,26% 44,34% 44,35%
7 44,21% 42,45% 43,31% 43,31%
22 41,49% 42,61% 42,04% 42,04%
2 36,45% 48,84% 41,75% 41,95%
17 35,94% 49,21% 41,54% 41,55%
14 32,40% 57,05% 41,33% 41,36%
29 32,32% 56,80% 41,20% 41,22%
30 41,52% 46,58% 43,90% 41,08%
3 36,13% 47,16% 40,91% 40,91%
18 35,72% 47,38% 40,73% 40,75%
8 42,13% 38,92% 40,46% 40,46%
23 41,03% 39,32% 40,16% 40,16%
4 30,73% 52,37% 38,73% 38,75%
19 30,69% 52,31% 38,68% 38,70%
12 31,47% 36,57% 33,83% 33,82%
27 31,40% 36,50% 33,76% 33,76%
1 28,47% 32,83% 30,49% 30,41%
16 28,58% 32,48% 30,41% 30,41%
11 9,61% 4,34% 5,98% 5,99%
26 9,44% 4,21% 5,82% 5,82%
10 12,33% 3,72% 5,72% 5,71%
25 11,18% 3,75% 5,62% 5,62% Tabelle 11 Ergebnisse der Methode naive Bayes.
68
Ähnlichkeit precision recall F1-Measure F1-Measure Durschnitt
24 58,11% 62,41% 60,18% 60,18%
9 57,77% 62,47% 60,03% 60,02%
10 52,25% 57,58% 54,79% 54,77%
25 51,72% 58,23% 54,78% 54,75%
26 54,11% 55,04% 54,57% 54,35%
11 53,05% 55,47% 54,23% 54,18%
13 51,17% 48,13% 49,60% 49,58%
17 78,16% 35,48% 48,81% 48,77%
18 78,85% 32,82% 46,35% 46,28%
22 81,92% 31,73% 45,74% 45,69%
2 80,30% 31,45% 45,20% 45,00%
7 79,79% 31,33% 44,99% 44,94%
23 83,30% 28,60% 42,58% 42,53%
8 81,76% 28,76% 42,55% 42,50%
3 84,60% 27,92% 41,98% 41,94%
28 50,66% 37,90% 43,36% 39,23%
1 85,55% 15,77% 26,63% 26,61%
16 85,55% 15,77% 26,63% 26,61%
27 79,63% 4,00% 7,62% 7,61%
12 79,38% 3,94% 7,51% 7,50%
4 83,33% 2,48% 4,82% 4,81%
19 83,33% 2,48% 4,82% 4,81%
14 52,17% 1,49% 2,90% 2,89%
29 51,61% 1,49% 2,90% 2,89%
5 0,00% 0,00% 0,00% 0,00%
6 0,00% 0,00% 0,00% 0,00%
15 0,00% 0,00% 0,00% 0,00%
20 0,00% 0,00% 0,00% 0,00%
21 0,00% 0,00% 0,00% 0,00%
30 0,00% 0,00% 0,00% 0,00% Tabelle 12 Ergebnisse der Methode Entscheidungsbäume.
69
Ähnlichkeit precision recall F1-Measure
F1-Measure Durschnitt
17 79,56% 35,82% 49,40% 49,35%
2 78,32% 35,05% 48,43% 48,39%
18 81,99% 31,45% 45,46% 45,42%
3 80,84% 31,52% 45,36% 45,31%
6 70,66% 3,66% 6,96% 6,95%
21 75,33% 3,50% 6,69% 6,69%
1 0,00% 0,00% 0,00% 0,00%
4 0,00% 0,00% 0,00% 0,00%
5 0,00% 0,00% 0,00% 0,00%
7 0,00% 0,00% 0,00% 0,00%
8 0,00% 0,00% 0,00% 0,00%
9 0,00% 0,00% 0,00% 0,00%
10 0,00% 0,00% 0,00% 0,00%
11 0,00% 0,00% 0,00% 0,00%
12 0,00% 0,00% 0,00% 0,00%
13 0,00% 0,00% 0,00% 0,00%
14 0,00% 0,00% 0,00% 0,00%
15 0,00% 0,00% 0,00% 0,00%
16 0,00% 0,00% 0,00% 0,00%
19 0,00% 0,00% 0,00% 0,00%
20 0,00% 0,00% 0,00% 0,00%
22 0,00% 0,00% 0,00% 0,00%
23 0,00% 0,00% 0,00% 0,00%
24 0,00% 0,00% 0,00% 0,00%
25 0,00% 0,00% 0,00% 0,00%
26 0,00% 0,00% 0,00% 0,00%
27 0,00% 0,00% 0,00% 0,00%
28 0,00% 0,00% 0,00% 0,00%
29 0,00% 0,00% 0,00% 0,00%
30 0,00% 0,00% 0,00% 0,00% Tabelle 13 Ergebnisse der Methode SVM.
70
Ähnlichkeit precision recall F1-Measure
F1-Measure Durschnitt
30 53,38% 57,95% 55,57% 55,56%
24 60,83% 50,57% 55,23% 55,19%
9 60,96% 48,68% 54,13% 54,12%
17 67,69% 40,25% 50,48% 50,47%
25 64,97% 39,94% 49,47% 49,44%
2 67,33% 38,83% 49,25% 49,23%
18 65,97% 39,17% 49,15% 49,12%
3 66,31% 38,92% 49,05% 49,01%
26 64,51% 38,64% 48,33% 48,33%
11 65,24% 38,27% 48,24% 48,23%
10 63,91% 38,02% 47,68% 47,67%
22 73,10% 33,44% 45,89% 45,83%
20 61,41% 36,44% 45,74% 45,72%
7 74,38% 32,29% 45,03% 44,98%
5 59,75% 36,07% 44,98% 44,97%
21 58,43% 36,41% 44,86% 44,84%
6 57,33% 36,35% 44,49% 44,48%
28 59,82% 34,55% 43,80% 43,78%
13 59,40% 33,81% 43,09% 43,12%
23 77,05% 29,75% 42,93% 42,89%
8 77,48% 29,01% 42,21% 42,16%
12 60,32% 30,80% 40,78% 40,78%
27 62,03% 28,91% 39,44% 39,43%
14 53,57% 29,10% 37,71% 37,65%
29 53,66% 28,85% 37,52% 37,50%
4 56,38% 27,24% 36,73% 36,72%
19 55,86% 27,33% 36,70% 36,69%
1 58,00% 26,84% 36,70% 36,64%
16 57,93% 26,71% 36,56% 36,50%
15 56,03% 31,08% 39,98% 35,44% Tabelle 14 Ergebnisse der Methode nächster-Nachbar-Klassifikation.
71
Ähnlichkeit precision recall F1-Measure
F1-Measure Durschnitt
24 58,62% 59,41% 59,01% 58,98%
9 58,87% 58,85% 58,86% 58,77%
30 53,32% 58,54% 55,81% 55,77%
26 58,98% 52,31% 55,45% 55,45%
25 61,65% 48,28% 54,15% 54,02%
3 64,39% 45,83% 53,55% 53,54%
10 57,38% 46,64% 51,46% 50,04%
20 61,10% 39,64% 48,08% 47,51%
11 66,57% 36,91% 47,49% 47,13%
2 82,07% 32,63% 46,69% 46,66%
22 79,65% 32,51% 46,17% 46,17%
17 82,53% 31,92% 46,04% 46,01%
18 82,33% 30,46% 44,47% 44,45%
13 62,81% 34,12% 44,22% 44,19%
6 59,73% 36,04% 44,95% 44,11%
28 63,55% 33,06% 43,49% 43,48%
5 59,14% 36,69% 45,29% 43,43%
7 82,18% 29,44% 43,35% 43,33%
14 47,87% 44,56% 46,16% 43,15%
8 76,08% 30,15% 43,19% 43,14%
23 78,64% 29,44% 42,84% 42,81%
21 69,25% 28,48% 40,36% 40,11%
12 68,07% 27,55% 39,22% 38,87%
1 50,74% 29,87% 37,60% 35,53%
27 73,52% 22,71% 34,70% 34,60%
4 60,96% 24,88% 35,34% 34,20%
19 60,69% 24,54% 34,95% 33,60%
16 76,54% 18,81% 30,20% 30,17%
29 82,83% 17,04% 28,27% 28,27%
15 55,39% 18,62% 27,87% 27,88% Tabelle 15 Ergebnisse der Methode künstliche neuronale Netze.
72
Anhang C
Auf der als Anhang C beschrifteten CD befindet sich zum einen die komplette Implementierung
der im Kapitel 5.3.1 beschriebenen Software für die Ähnlichkeitsbestimmung. Zum anderen ist
auch die komplette Repository der Software RapidMiner enthalten, die im Rahmen dieser
Arbeit implementierten Prozesse für die Validierung der Methoden des maschinellen Lernens
enthält. Auch alle für die Evaluierung verwendeten Entscheidungsvektoren, die ermittelten
Modelle und die dazugehörigen Ergebnisse sind enthalten. Um eine einfache
Nachvollziehbarkeit zu gewährleisten, enthält die CD auch Installationsdateien zu den
verwendeten Versionen der Software SpringSource Tool Suite (Entwicklungsplatform) und
RapidMiner.
Des Weiteren enthält die CD Paper, die aus dem Web heruntergeladen wurden und als
Literatur im Rahmen dieser Arbeit Verwendung fanden.
Die Struktur der Verzeichnisse kann der Tabelle 16 entnommen werden.
Verzeichnis Inhaltsbeschreibung
Aenlichkeitsbestimmung Die Quelltexte der Implementierung der Ähnlichkeitsbestimmung als ein Projekt für die SpringSource Tool Suite (komplett als zip Datei).
Installationsdateien Installationsdateien für die Software SpringSource Tool Suite und RapidMiner.
Literatur Die aus dem Web stammende Papers, die als Literatur verwendet wurden.
RapidMinerRepository Die Repository der Software RapidMiner, beinhaltet die Evaluationsdaten (Entscheidungsvektoren), Modelle der Methoden des maschinellen Lernens und Ergebnisse der Evaluation.
Tabelle 16 Die Beschreibung der Verzeichnisstruktur der CD zum Anhang C.
73
Anhang D
Die als Anhang D beschriebene CD enthält die bei der Evaluation verwendeten Originaldaten
als CSV (Comma-Separated Values) Dateien. Die ursprüngliche Aufteilung der Relationen
wurde beibehalten.
Diese CD steht nur den Gutachtern der Arbeit im Rahmen der Beurteilung zur Verfügung. Einer
Veröffentlichung der Daten, insbesondere der Geschäftsadressen, ist aus Gründen des
Betriebsgeheimnisses nicht möglich.
74
Literaturverzeichnis
[Ambl10] Ambler, Scott W.: Mapping Objects to Relational Databases: O/R Mapping In Detail. http://www.agiledata.org/essays/mappingObjects.html, 2010. Abruf: 15.08.2010.
[Anan02] Ananthakrishna, R.; Chaudhuri, S.; Ganti, V.: Eliminating Fuzzy Duplicates in Data Warehouses. In: Proceedings of the 28th Conference on Very Large Databases, 2002, S. 586-597.
[Apac11] Apache Software Foundation: Apache POI - the Java API for Microsoft Documents. http://poi.apache.org/, 2001. Abruf: 15.08.2011.
[Bile03] Bilenko, M.; Mooney, R.; Cohen, W.; Ravikumar, P.; Fienberg, S.: Adaptive Name Matching in Information Integration. In: IEEE Intelligent Systems, 18 (50), 2003, S. 16-23.
[Borg98] Christian Borgelt and Rudolf Kruse. Attributauswahlmaße für die Induktion von Entscheidungsbäumen: Ein Überblick. In: Data Mining: Theorie und Anwendungen. Heidelberg: Physica-Verlag, 1998, S. 77-98.
[Brau95] Brause, Rüdiger W.: Neuronale Netze. Stuttgart: B.G. Teubner, 1995.
[Brei84] Breiman, L.; Friedman, J.H.; Olshen R.A.; Stone C.J.: Classification and Regression Trees. Belmont Calif.: Wadsworth International Group, 1984.
[Chri08] Christen, Peter: Automatic record linkage using seeded nearest neighbour and support vector machine classification. In: Proceeding of the 14th ACM SIGKDD international conference on Knowledge discovery and data mining (KDD '08), 2008.
[Coch01] Cochinwala, M.; Kurien, V.; Lalk, G.; Shasha, D.: Efficient Data Reconciliation. In: Information Sciences, 137, 2001, S. 1-15.
[Cohe98] Cohen, William W.: Integration of Heterogeneous Databases without Common Domains Using Queries Based on Textual Similarity. In: Proceedings of the 1998 ACM SIGMOD international conference on Management of data, 1998.
[Cohe03] Cohen, William W.; Ravikumar, Pradeep; Fienberg, Stephen E.: A comparison of string distance metrics for name-matching tasks. In: Proc. IJCAI-03 Workshop on Information Integration on the Web (IIWeb-03), S. 73–78, 2003.
[Drai10] Draisbach, Uwe; Naumann, Felix: DuDe: The Duplicate Detection Toolkit. In: Proceedings of the International Workshop on Quality in Databases (QDB) 2010, Singapore, 2010.
[DGIQ07] DGIQ e.V. 15. IQ Dimensionen. http://www.dgiq.de, 2007. Abruf: 15.08.2011.
[Elma07] Elmagarmid, Ahmed K.; Ipeirotis, Panagiotis G. ; Verykios, Vassilios S.: Duplicate Record Detection: A Survey. In: IEEE Transactions Knowledge and Data Engineering, 19(1), 2007, S. 1-16.
75
[Fahr98] Fahrmeir, F.; Häußler, W.; Tutz, G.: Diskriminanzanalyse. In: Fahrmeir, L.; Hamerle, A.; Tutz, G. [Hrsg.]: Multivariate statistische Verfahren. 2. Auflage, Berlin / New York: de Gruyter, 1996, S. 357–425.
[Fell69] Fellegi, Ivan; Sunter, Alan: A Theory for Record Linkage. In: Journal of the American Statistical Association, 64(328), 1969, S. 1183-1210.
[Fix51] Fix, E.; Hodges, J.: Discriminatory analysis, nonparametric discrimination: Consistency properties. In: Technical Report 4, U.S. Air Force, School of Aviation Medicine, Randolph Field, TX, 1951.
[Fowl04] Fowler, Martin: Inversion of Control Containers and the Dependency Injection pattern. http://martinfowler.com/articles/injection.html, 2004. Abruf: 15.08.2011.
[Goog11] Google: Google Chart Tools. http://code.google.com/intl/de-DE/apis/chart/, 2011.
Abruf: 15.08.2011
[Goto82] Gotoh, Osamu: An Improved Algorithm for Matching Biological Sequences. In: Journal of Molecular Biology, 162, 1982, S.705-708.
[Grau92] Grauel, Adolf: Neuronale Netze: Grundlagen und mathematische Modellierung. Mannheim, Leipzig, Wien, Zürich: BI-Wissenschaftlicher-Verlag, 1992.
[Grav01] Gravano, Luis; Ipeirotis, P. G.; Jagadish, H.;Koudas, N.; Muthukrishnan, S.; Srivastava, D.: Approximate string joins in a database (almost) for free. In: Proceedings of the 27th International Conference on Very Large Databases, 2001. S. 491–500.
[Gülc11] Gülcü, Ceki; Pennec, Sébastien: The logback manual. http://logback.qos.ch/manual/index.html, 2011. Abruf 15.08.2011.
[Hall08] Hall, P.; Park, B.U.; Samworth R.J.: Choice of neighbor order in nearest-neighbor classification. In: Annals of Statistics. 36 (5), S. 2135–2152.
[Jaro89] Jaro, Matthew A.:, Advances in Record-Linkage Methodology as Applied to Matching the 1985 Census of Tampa, Florida. In: Journal of the American Statistical Association, 89, 1989, S. 414-420.
[Jura91] Juran, Josef M.: Handbuch der Qualitätsplanung. 3. Auflage, Landsberg: Verlag Moderne Industrie, 1991.
[Krie07] Kriesel, David: Ein kleiner Überblick über Neuronale Netze. http://www.dkriesel.com, 2007. Abruf: 15.08.2011.
[Leve66] Levenshtein, V. I.: Binary codes capable of correcting deletions, insertions, and reversals. In: Soviet Physics Doklady, 10(8), 1966, S. 707-710.
[Mann08] Manning, Christopher D.; Raghavan, Prabhakar; Schütze, Hinrich: Introduction to Information Retrieval. Cambridge: Cambridge University Press, 2009.
76
[Mier09] Mierswa, Ingo: Open Source Data Mining mit RapidMiner. In: 18. Wissenschaftliches Kolloquium des statistischen Bundesamtes, 2009, http://www.destatis.de/jetspeed/portal/cms/Sites/destatis/Internet/DE/Content/ Wissenschaftsforum/Kolloquien/OpenSourceDataMiningRapidMiner__Beitrag,property=file.pdf, Abruf: 15.08.2011.
[Mong96] Monge, Alvaro C.; Elkan, Charles P.: The field-matching problem: algorithm and applications. In: Proceedings of the Second International Conference on Knowledge Discovery and Data Mining, 1996, S. 267-270.
[Naum10] Naumann, Felix; Herschel, Melanie: An Introduction to Duplicate Detection. San Rafael (u.a.) : Morgan and Claypool Publishers, 2010.
[Nava01] Navarro, G.: A Guided Tour of Approximate String Matching. In: Association of Computing Machinery Computing Surveys, 33, 2001, S. 31-88.
[Need70] Needleman, Saul B.; Wunsch, Christian D.: A General Method Applicable to the Search for Similarities in the Amino Acid Sequence of Two Proteins. In: Journal of Molecular Biology, 48, 1970, S. 443–453
[Newc59] Newcombe, H. B.; Kennedy, J. M.; Axford, S. J.; James, A. P.: Automatic linkage of vital records. In: Science Vol. 130, No. 3381, 1959, S. 954-959.
[Obri11] O'Brien, Tim; van Zyl, Jason; Fox, Brian; Casey, John; Xu, Juven; Locher, Thomas; Sonatype (Hrsg.): Maven: The Complete Reference. http://www.sonatype.com/books/mvnref-book/reference/, 2011. Abruf: 15.08.2011.
[Orac11] Oracle: JDBC. http://download.oracle.com/javase/6/docs/technotes/guides/jdbc/, 2011. Abruf: 15.08.2011.
[Orac10] Oracle: MySQL 5.1 Referenzhandbuch. http://dev.mysql.com/doc/refman/5.1/de/index.html, 2010. Abruf: 15.08.2011.
[Pras09] Prasetya, Wishnu: JUnit 4.x Quick Tutorial. http://code.google.com/p/t2framework/wiki/JUnitQuickTutorial, 2009. Abruf: 15.08.2011.
[Rose58] Rosenblatt, Frank: The perceptron: a probabilistic model for information storage and organization in the brain. In: Psychological Review, 65, 1958, S. 386-408.
[Samm11] Sammut, Claude [Hrsg.]; Webb, Geoffrey I. [Hrsg.]: Encyclopedia of Machine Learning. 1. Auflage, Berlin: Springer, 2011.
[Schi02] Schierenbeck, Henner (2003): Grundzüge der Betriebswirtschaftslehre. 16. Auflage, München: Oldenbourg Wissenschafts-Verlag, 2002.
[Shaf10] Shafait, Faisal; Reif, Matthias; Kofler, Christian; Breuel, Thomas: Pattern Recognition Engineering. In: RapidMiner Community Meeting and Conference, 09/2010. http://madm.dfki.de/publication&pubid=4947. Abruf: 15.08.2011.
77
[Smit81] Smith, Temple F.; Waterman, Michael S.: Identification of common molecular subsequences. In: Journal of Molecular Biology, 147, 1981, S. 195-197.
[Sonq64] Sonquist, J.A.; Morgan, J.N.: The Detection of Interaction Effects. Ann Arbor: University of Michigan, Institute for Social Research, Survey Research Center, 1964.
[Sour11] Sourceforge: http://sourceforge.net/projects/simmetrics/, 2011. Abruf: 15.08.2011.
[Sun01] Sun Microsystems: Core J2EE Patterns - Data Access Object. http://java.sun.com/blueprints/corej2eepatterns/Patterns/DataAccessObject.html, 2001-2002. Abruf: 15.08.2011.
[Ukko92] Ukkonen, E.: Approximate string matching with q-grams and maximal matches. In: Theoretical Computer Science (TCS), 92(1), 1992, S. 191–211.
[Ullm77] Ullmann, J.R.: A Binary n-Gram Technique for Automatic Correction of Substitution, Deletion, Insertion, and Reversal Errors in Words. In: The Computer Journal, Vol. 20, No. 2, 1977, S. 141-147.
[Very03] Verykios, Vassilios S.; Moustakides, George V.; Elfeky, Mohamed G.: A Bayesian decision model for cost optimal record matching. In: The International Journal on Very Large Data Bases, 12(1), 2003, S. 28-40.
[Wang96] Wang, Richard Y.; Strong, Diane M.: Beyond Accuracy: What data quality means to data consumers. In: J. Manage. Information Syst., 12(4), 1996, S. 5-34.
[Wapn95] Wapnik, Wladimir: The Nature of Statistical Learning Theory. New York, NY, USA: Springer Verlag, 1995.
[Wate76] Waterman, Michael S.; Smith, Temple F.; Beyer, W.A.: Some Biological Sequence Metrics. In: Advances in Math., 20(4), 1976, S. 367-387.
[Weis05] Weis, Melanie; Naumann, Felix: DogmatiX tracks down duplicates in XML. In: Proc. ACM SIG-MOD Int. Conf on Management of Data, 2005, S. 431-442.
[Weis08] Weis, Melanie; Naumann, Felix; Jehle, Ulrich; Lufter, Jens; Schuster, Holger: Industry-scale duplicate detection. In: Proceedings of the VLDB Endowment, 1(2), 2008, S. 1253-1264.
[Werb74] Werbos, Paul J.: Beyond Regression: New Tools for Prediction and Analysis in the Behavioral Sciences. PhD thesis, Harvard University, 1974.
[Wink91] Winkler, William E.; Thibaudeau, Yves: An Application of the Fellegi-Sunter Model of Record Linkage to the 1990 U.S. Census. Technical report, US Bureau of the Census, 1991.
[Wolf10] Wolff, Eberhard: Spring 3 – Framework für die Java Entwicklung. 3. Auflage, Heidelberg: dpunkt.verlag, 2010.
78
[Züll04] Züllighoven, Heinz: Object-Oriented Construction Handbook: Developing Application-Oriented Software with the Tools & Materials Approach. Heidelberg: dpunkt.verlag, 2004.
79
Eidesstattliche Erklärung
Ich versichere, dass ich die vorstehende Arbeit selbstständig und ohne fremde Hilfe angefertigt
und mich anderer als der im beigefügten Verzeichnis angegebenen Hilfsmittel nicht bedient
habe. Alle Stellen, die wörtlich oder sinngemäß aus Veröffentlichungen entnommen wurden,
sind als solche kenntlich gemacht. Alle Quellen, die dem World Wide Web entnommen oder in
einer sonstigen digitalen Form verwendet wurden, sind der Arbeit beigefügt.
![Low-Cost Smith-Waterman Acceleration · 3.3 Di erential Smith-Waterman ... are built from cells [6]. In the following sections, ... Chapter 1 Introduction 3 1.2.3 DNA,](https://img.pdfslide.net/doc/110x75/5b38a5517f8b9a1a678ba400/low-cost-smith-waterman-acceleration-33-di-erential-smith-waterman-are.jpg)
