Labor für digitale Nachrichtentechnik - Entwicklung eines...

Entwicklung eines Moduls zur Interpretation der von einemSpracherkennungssystem generierten Wortfolge für eine

Gerätesteuerung

Development of a module to interpret the word sequence generated by aspeech recognition system for a device control system

Masterarbeitzur Erlangung des Grades Master of Science

an derHochschule Niederrhein

Fachbereich Elektrotechnik und InformatikStudiengang Informatik

vorgelegt vonChristoph Leusmann

919204

Datum: 19. Dezember 2018

Prüfer: Prof. Dr.–Ing. Hans–Günter HirschZweitprüfer: M. Eng. Michael Gref

Zusammenfassung

Das Ziel der vorliegenden Masterarbeit war es, ein Interpretationsmodul für die Hausautomati-sierung zu entwickeln. Dieses wertet ein Kommando, welches in Wortfolgen dem Modul über-geben wird, aus und liefert die interpretierte Aktion. Dazu wurden drei Modelle entwickelt.Für ein viertes Model wurde die MATLAB–Toolbox „Text Analytics“ verwendet. Alle vierVarianten wurden ausgeführt, miteinander verglichen und bewertet. Die entwickelten Modellebasieren auf dem Themengebiet des Information Retrievals. Die Arbeit beschreibt die einzelnenModelle, deren Methoden und Algorithmen, und erläutert dessen Realisierung.

Abstract

The main aim of this master thesis was to develop an interpretation module for home automati-on. This evaluates a command, which is passed to the module in word sequences, and deliversthe interpreted action. Three models were developed for this purpose. For a fourth model, theMATLAB toolbox “Text Analytics“ was used. All four variants were executed, compared andevaluated. The developed models are based on the topic of information retrieval. This thesisdescribes the individual models, their methods and algorithms, and explains their realization.

2

Eidesstattliche Erklärung

Name: Christoph LeusmannMatrikelnr.: 919204Titel: Entwicklung eines Moduls zur Interpretation der von einem Spracherkennungs-

system generierten Wortfolge für eine Gerätesteuerung

Ich versichere durch meine Unterschrift, dass die vorliegende Arbeit ausschließlich von mirverfasst wurde. Es wurden keine anderen als die von mir angegebenen Quellen und Hilfsmittelbenutzt.

Die Arbeit besteht aus 112 Seiten.

Ort, Datum Unterschrift

3

Widmung

An dieser Stelle möchte ich mich bei allen bedanken, die mich während der Masterarbeit unter-stützt und motiviert haben. Ich bedanke mich bei Herrn Prof. Dr.–Ing. Hans–Günter Hirsch fürdie freundliche Betreuung und Unterstützung. Ich bedanke mich außerdem bei Herrn M. Eng.Michael Gref, der so freundlich war sich als Zweitbetreuer für meine Arbeit zur Verfügung zustellen und mich ebenfalls während der Masterarbeit unterstützte. Zuletzt möchte ich mich beimeiner Familie bedanken, die immer für mich da ist, mir mein Studium ermöglichen und michin all meinen Entscheidungen unterstützen.

4

INHALTSVERZEICHNIS

Inhaltsverzeichnis1 Einleitung 11

1.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111.2 Aufgabenstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121.3 Aufbau der Arbeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

2 Sprachassistent – Amazons Alexa 142.1 Sprachsteuerung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142.2 Skills . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152.3 Funktionsweise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

3 Architektur der Kommandos 19

4 System zur Interpretation von Kommandos 214.1 Boolean Retrieval Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

4.1.1 Erstellen eines inverted indexes . . . . . . . . . . . . . . . . . . . . . 254.1.2 Verarbeitung Boolescher Abfragen . . . . . . . . . . . . . . . . . . . . 264.1.3 Effizienterer Intersection-Algorithmus durch skip pointer . . . . . . . . 294.1.4 Initialisierung beim Erstellen eines inverted index . . . . . . . . . . . . 314.1.5 Abrufen der Zeichenfolge aus Kommandos . . . . . . . . . . . . . . . 314.1.6 Tokenisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324.1.7 Token-Normalisierung . . . . . . . . . . . . . . . . . . . . . . . . . . 334.1.8 Position Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

4.2 Fuzzy Logik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384.2.1 Term frequency and weighting . . . . . . . . . . . . . . . . . . . . . . 434.2.2 Inverse document frequency . . . . . . . . . . . . . . . . . . . . . . . 444.2.3 Tf-idf Gewichtung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

4.3 Vektorraum Model – Word2Vec . . . . . . . . . . . . . . . . . . . . . . . . . 454.3.1 Continuous Bag-of-Word Model (CBOW) . . . . . . . . . . . . . . . . 494.3.2 Skip-Gram Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . 544.3.3 Hierarchisches Softmax . . . . . . . . . . . . . . . . . . . . . . . . . 574.3.4 Negative Sampling . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

5 Realisierung vom Boolean Retrieval–, Fuzzy Logic– und Alexa–Äquivalentes–Model 615.1 Entwurfsmuster MVC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 615.2 Struktur der Datenbasis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 625.3 Datenbank–Schicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 635.4 Initialisierung der Daten aus der Datenbank . . . . . . . . . . . . . . . . . . . 675.5 Initialisierung des Retrieval Systems . . . . . . . . . . . . . . . . . . . . . . . 68

5.5.1 Inverted Index erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . 685.5.2 Implementierung des German Stemming Algorithmus . . . . . . . . . 705.5.3 Initialisierung des Fuzzy–Logic–Models . . . . . . . . . . . . . . . . . 795.5.4 Fuzzy Logic – Berechnung von Jaccard und Ogawa . . . . . . . . . . . 795.5.5 Erstellen eines umgekehrten inverted indexes . . . . . . . . . . . . . . 82

5.6 Kommando–Interpretation mit dem Boolean Retrieval Model . . . . . . . . . . 83

5

INHALTSVERZEICHNIS

5.6.1 Intersection–Algorithmus für zwei posting lists . . . . . . . . . . . . . 845.6.2 Rückgabewert der Interpretation . . . . . . . . . . . . . . . . . . . . . 85

5.7 Kommando–Interpretation mit dem Fuzzy Logic Model . . . . . . . . . . . . . 865.7.1 Rückgabewert der Interpretation . . . . . . . . . . . . . . . . . . . . . 87

5.8 Kommando–Interpretation mit dem Alexa–Äquivalentes Model . . . . . . . . . 885.8.1 Rückgabewert der Interpretation . . . . . . . . . . . . . . . . . . . . . 95

5.9 Aufruf der Anwendung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

6 Realisierung vom Vektorraum–Model 986.1 Word embedding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

7 Evaluation 1057.1 UnitTest – German Stemming Algorithmus . . . . . . . . . . . . . . . . . . . 1057.2 Boolean Retrieval Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1067.3 Fuzzy Logic Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1077.4 Alexa–Äquivalentes Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1077.5 Vektorraum – Word2Vec Model . . . . . . . . . . . . . . . . . . . . . . . . . 108

8 Zusammenfassung & Ausblick 109

Literatur 110

Begleit–CD 112

6

ABBILDUNGSVERZEICHNIS

Abbildungsverzeichnis1 Funktionsweise Alexa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172 Die beiden Teile eines Inverted Index. Eine einfach verkettete Liste wird als

bevorzugte Datenstruktur verwendet. [1, Seite 6] . . . . . . . . . . . . . . . . 243 Schritte einer Indexierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264 Schnittmenge aus den Posting-Listen aus den Termen: Licht, in, der, Küche

und ein. Der Inverted Index stammt aus Abbildung 3 „Schritte einer

Indexierung“ [Seite 26]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275 Intersect-Algorithmus mit beliebiger Reihenfolge der Abarbeitung der Posting-

Listen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286 Intersect-Algorithmus mit der Reihenfolge nach der Heuristik . . . . . . . . . 287 Zwei Posting-Listen mit skip pointer . . . . . . . . . . . . . . . . . . . . . . . 298 Das Wort „auf“ hat eine document frequency von 993427 und ist sechs mal im

Dokument 1 an den Positionen 7, 18, 33, 72, 86 und 231 vorhanden. . . . . . . 389 Beispiel – Fuzzy-Logik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3910 Beispiel eines Vector Space Models . . . . . . . . . . . . . . . . . . . . . . . 4511 Kosinusähnlichkeit zwischen den Dokumenten d1 und d2 . . . . . . . . . . . . 4612 Clustered document space . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4813 Ein einfaches CBOW Modell mit nur einem Wort im Kontext . . . . . . . . . . 4914 CBOW-Modell mit einer Mehrwort-Kontexteinstellung . . . . . . . . . . . . . 5315 Das Skip-Gram Modell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5416 Ein exemplarischer Binärbaum für das hierachische softmax-Model. . . . . . . 5717 Model–View–Controller–Konzept . . . . . . . . . . . . . . . . . . . . . . . . 6118 Struktur der Datenbanktabellen . . . . . . . . . . . . . . . . . . . . . . . . . . 6219 UML Diagramm der Klasse ConnectionDataProviderBase . . . . . . . . . . . 6420 UML Diagramm der Klasse JaccardWertItem . . . . . . . . . . . . . . . . . . 8021 UML Diagramm der Klasse OgawaItem . . . . . . . . . . . . . . . . . . . . . 8322 UML Diagramm der Klasse BooleanRetrievalResult . . . . . . . . . . . . . . . 8523 UML Diagramm der Klasse FuzzyLogicResult . . . . . . . . . . . . . . . . . 8724 Datenbanktabellen für die Behandlung von Synonymen . . . . . . . . . . . . . 8825 Eingabe, ob die Terme mit dem German Stemming Alorithmus normalisiert

werden sollen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9726 Abfrage der Model–Variante . . . . . . . . . . . . . . . . . . . . . . . . . . . 9727 Eingabe eines Kommandos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9728 Erstellen eines WordEmbedding–Objekts . . . . . . . . . . . . . . . . . . . . 10029 Grafische Darstellung des Ergebnisses aus Tabelle 6 . . . . . . . . . . . . . . . 10230 Verzeichnisstruktur der beigefügten CD . . . . . . . . . . . . . . . . . . . . . 112

7

TABELLENVERZEICHNIS

Tabellenverzeichnis2 Eine Term-Kommando-Matrix – Matrixelement (t,d) ist 1, wenn das Komman-

do in Spalte d den Term (Wort) in Zeile t enthält, ansonsten ist es 0. . . . . . . 223 Bitweise UND-Verknüpfung zum Beispiel Kommando. . . . . . . . . . . . . . 234 Jaccard-Maß Berechnung des Beispiel-Datensatzes . . . . . . . . . . . . . . . 405 Beispiel zu idf-Werten – Reuters-RCV1 Korpus . . . . . . . . . . . . . . . . . 446 Euklidischen Distanzen zwischen allen Term–Vektoren und des Jalousie–Vektors 102

Abkürzungsverzeichnis

IPA Intelligenter Persönlicher Assistent

CUI Conversational User Interfaces

VUI Voice User Interfaces

GUI Graphical User Interface

DRS Document Retrieval System

docID document identifier

8

TABELLENVERZEICHNIS

Glossar

Begriff Definition / ErklärungAktion In dieser Masterarbeit beschreibt der Begriff Aktion die Funktion, die eine

Gerätesteuerung nach erfolgreichem Erkennen eines Kommandos ausführt.BooleanRetrievalModel

Das Boolean Retrieval Model ist eine einfache Form des Information Retriev-al. Dabei werden die Wörter einer Suchanfrage mit Booleschen Operatoren(UND, ODER, NICHT) verknüpft.

Conversa-tional UserInterface(CUI)

Ein Conversational User Interface (CUI) kombiniert ein Voice User Interfacemit einem Graphical User Interface. Die Idee eines CUIs ist es eine Oberflächezu präsentieren, die bis auf die Steuerung einer GUI entspricht. Die Interaktionmit der Oberfläche und Teile der Navigation geschehen durch Spracheingaben.

Device Mit Device (Gerät) ist in dieser Masterarbeit eine Hardware von der Geräte-steuerung gemeint.

Dictionary Ein Dictionary (Wörterbuch) ist eine Liste mit allen Termen, die in dem Do-kumentenkorpus auftreten. Jeder Term ist im Dictionary nur einmal vertreten.Jedes Information Retrieval System definiert ein Dictionary.

DocumentRetrievalSystem

Ein Document Retrieval System bezeichnet ein System zum computerunter-stützten Rückgewinnen von Dokumenten (engl. to retrieve: zurückgewinnen,wiederauffinden). Es werden die Dokumente ermittelt, die für einen Anwen-der entsprechend seines Informationsbedürfnisses relevant sind. Sein Informa-tionsbedürfnis drückt der Anwender in Form einer Suchanfrage aus. Häufigwird Document Retrieval auch als Information Retrieval bezeichnet.

GraphicalUserInterface

Eine grafische Oberfläche (Abk. GUI vom englischen graphical user interface)ist eine Form der Benutzerschnittstelle zwischen dem Anwender und einemelektronischem Gerät. Durch grafische Symbole, Steuerelemente oder Widgetskann der Anwender die Oberfläche bedienen. Je nach elektronischem Gerätwird die Oberfläche mit einer Computermaus, –tastatur oder durch die Berüh-rung eines Sensorbildschirms bedient.

Hot Word Einige Intelligente Persönliche Assistenten (IPAs) werden durch einen speziel-len Begriff (Wort, Wortfolge) aktiviert. Erst nach erfolgreicher Erkennung desBegriffes vom System können weitere Funktionen des IPAs vom Anwender inAnspruch genommen werden. [2]

IntelligentePersön-licheAssistenten[MobilerAssistent]

Ein Intelligenter Persönlicher Assistent (IPA) bezeichnet eine Software, die dasMikrofon eines Geräts verwendet, um sprachliche Benutzeranfragen zu emp-fangen, während über dem Lautsprecher die Sprachausgabe erfolgt. Zwischenden beiden Aktionen werden mehrere verschiedene Technologien, insbesonde-re aus Spracherkennung, –analyse und –verarbeitung, durchgeführt.

Korpus Ein Korpus ist eine in der Anzahl begrenzte Sammlung. In dieser Masterarbeitbetitelt ein Korpus eine Sammlung von Kommandos, Termen und Aktionen.Meistens wird ein Korpus in einer Datenbank abgelegt.

Location Dadurch, dass ein Gerät öfters in einer Gerätesteuerung existieren kann, wirddurch den Zusatz eines Ortes (Location) das entsprechende Geräte spezifiziert.

9

TABELLENVERZEICHNIS

Naturallanguageprocessing(NLP)

Natural language processing (NLP) beschreibt Techniken und Algorithmen zurmaschinellen Verarbeitung natürlicher Sprache. Es soll eine direkte Kommu-nikation zwischen Mensch und Computer auf Basis der natürlichen Spracheentstehen. Im Deutschen ist diese Thematik unter den Begriffen Computerlin-guistik (CL) oder linguistische Datenverarbeitung (LDV) bekannt.

SmartSpeaker

Ein kabelloser Lautsprecher und Sprachempfangsgerät mit integriertem virtu-ellen Assistenten (künstliche Intelligenz) wird als Smart Speacker betitelt. MitHilfe eines oder mehrerer „hot words“ ermöglicht dieser interaktive Aktionenund Freisprechaktivierungen. Ferner dienen Smart Speaker zur Nutzung vonMusikstreaming–, Nachrichten–, Podcast– oder sonstigen Audiodiensten ausdem Internet. [3]

Term Ein Term ist ein (möglicherweise normalisierter) Token. Auf den Termen bau-en die meisten Algorithmen eines Information Retrieval System auf.

Term–Dokument–Matrix

Eine Term–Dokument–Matrix, oder auch Dokument–Term–Matrix, ist ei-ne mathematische Matrix, welche die Häufigkeit von Termen in einemDokumenten–Korpus beschreibt. In einer Term–Dokument–Matrix sind dieZeilen den Termen des Korpus und die Spalten den Dokumenten zugeordnet.In einer Dokument–Term–Matrix werden die Spalten und Zeilen vertauscht.Diese Matrix wird in Bereichen der natürlichen Sprachverarbeitung (NLP [Na-tural language processing]) eingesetzt. Es gibt verschiedene Schemata zur Be-stimmung des Wertes der Einträge in der Matrix.

Token Als Token wird das einzelne Stück einer Dokumenteneinheit bezeichnet, dasbei der Tokenisierung entsteht.

Voice UserInterface

Ein Voice User Interface (VUI) ist die Benutzerschnittstelle von Sprachdialog-systemen. Die Ein– und Ausgabe erfolgt dabei ausschließlich über die gespro-chene Sprache. Somit werden weder die Hände, noch ein Display benötigt.Haupteinsatzgebiete sind heutzutage Smartphones mit ihren persönlichen As-sistenzsystemen wie Siri oder Google Now.

Zustands-änderung

Unter Zustandsänderung wird in dieser Masterarbeit die Tätigkeit verstanden,die ein Gerät der Gerätesteuerung durchführen kann.

10

1 EINLEITUNG

1 Einleitung

1.1 Motivation

In der heutigen Zeit gehört es zum Alltag, dass sich Menschen mit Maschinen unterhalten. Essind die sogenannten intelligenten persönlichen Assistenten, die in den letzten Jahren ein kaumwegzudenkender Teil der allgegenwärtigen Digitalisierung geworden sind. So lassen sich die-se virtuellen Assistenten in sämtlichen Gadgets wie Smartphones, Tablets und Smart Watchesfinden. Die Sprachassistenten in Smartphones werden vom Benutzer zur Hilfe genommen, umSiri, S-Voice, Cortana und Co. zum Beispiel nach dem Wetter zu fragen. Der immer stärkerwerdende Wettbewerb in diesem Bereich hat zu vielen Verbesserungen geführt. Große Anbie-ter, allen voran Amazon, Google, Apple und Microsoft, bieten eine digitale Infrastruktur, diemit Hilfe von Sprachassistenten Fragen beantwortet oder Geräte steuert. Häufig geschieht diesmit mehreren Geräten im Netzverbund. Besonders die Begriffe Voice User Interface (VUI) be-ziehungsweise Conversational User Interface (CUI) gewinnen zunehmend an Bedeutung. Dochwas genau beschreiben die beiden Begriffe und warum wird Sprachsteuerung immer beliebter?Damit diese Systeme auf die unterschiedlichsten Fragen und Formulierungen vom Anwenderreagieren können, muss der Nutzungskontext entsprechend verknüpft werden. Genau das ist ei-ner der grundlegenden Unterschiede eines VUIs zu einer grafischen Oberfläche (Graphical UserInterface, kurz GUI).

Bei einem VUI stellt der Anwender seine Fragen und erhält die entsprechenden Antworten. BeiVerwendung eines GUIs dagegen, muss die Antwort vom Anwender gesucht werden. Natürlichspielt das Wort Konversation in einem VUI eine besondere Rolle. Durch das Verständnis vonnatürlicher Sprache kann bei der Interaktion der Eindruck einer echten Konversation entstehen.Im Idealfall sind VUIs Konversationsteilnehmer und haben Charakter. Das Ziel der Herstellersolcher Systeme ist es, ein technischen Assistenten zu entwickeln, welcher dem Anwender dasGefühl gibt, er würde sich mit einem menschlichem Wesen unterhalten.

Um den Unterschied zwischen VUIs und GUIs zu verdeutlichen folgt jetzt ein mögliches Bei-spiel. Ein Nutzer möchte wissen, ob er morgen einen Regenschirm benötigt. Bei einem GUIwürde der Anwender eine Webseite für Wettervorhersage oder eine ähnliche Applikation auf-rufen. Dort versucht er durch Eingaben zum gewünschten Ziel zu gelangen. Diese Informatio-nen muss der Anwender von der Webseite ablesen. D.h. der Anwender sucht die Antwort aufsein Bedürfnis selber. Anders ist es bei einem VUI. Hier stellt der Anwender dem Assisten-ten zum Beispiel die Frage: „Brauche ich morgen einen Regenschirm?“ Der Assistent könnteantworten: „Für morgen wird kein Regen erwartet.“ Aber damit diese Technologie von Nut-zern angenommen wird, müssen möglichst viele Informationsbedürfnisse vom Kunden vomAssistenten erfüllt werden. Neben den oben erwähnten Geräten werden mittlerweile in vie-len alltäglichen Maschinen intelligente persönliche Assistenten implementiert. Besonders imHaushalt können immer mehr Maschinen per Sprachbefehl gesteuert werden. Die Anwendun-gen dabei sind vielfältig und die Möglichkeiten für den Nutzer werden immer individueller.Trotz unterschiedlicher Formulierungen und Redewendungen soll der Befehl richtig interpre-tiert und somit die gewünschte Aktion von der Gerätesteuerung ausgeführt werden. Aus diesenGründen wurde in dieser Masterarbeit ein Interpretationsmodul entwickelt, welches Komman-dos für eine Gerätesteuerung zur Hausautomatisierung interpretiert und die gewünschte Aktionan die Gerätesteuerung weitergibt.

11

1 EINLEITUNG

1.2 Aufgabenstellung

Aufgabe dieser Masterarbeit ist die Entwicklung eines Interpreters für eine Hausautomatisie-rung. Das Spracherkennungssystem übergibt diesem System ein verstandenes Kommando alsWortfolge. Anschließend interpretiert dieses System die übergebene Wortfolge und gibt dierichtige Aktion als Ergebnis an das Steuerungssystem weiter. Es wird erwartet, dass das inter-pretierte Ergebnis die vom Anwender gewünschte Aktion ist. Das Interpretationsmodul ist Teilder Gerätesteuerung, welche in dieser Masterarbeit eine Hausautomatisierung darstellt. Somitwerden als mögliche Kommandos Wortfolgen erwartet, die eine Hausautomatisierung ermögli-chen.

Für die Interpretation der Wortfolge werden in dieser Masterarbeit vier unterschiedlicheModelle vorgestellt. Zwei dieser Modelle (Boolean Retrieval Model und Fuzzy Logic Mo-del) stammen aus dem Themengebiet des Information Retrievals. Für die Interpretation derHausautomatisierung–Kommandos wurden diese beiden Modelle vom Information Retrievalabgeleitet.

Ein anderes Model ist das Alexa–Äquivalente Model. Dieses basiert auf den Erkenntnissen, diesich während der Recherche ergaben. Zum Alexa–Äquivalente Model und den beiden Infor-mation Retrieval Modellen wurden eine Konsolenanwendung namens SPRInterpretationToolentwickelt, die alle drei Modelle zwecks Gegenüberstellung enthält.

Das vierte Model ist das Vektorraum–Model Word2Vec. Dieses System wird in dieser Ma-sterarbeit theoretisch erläutert. Für den Vergleich mit den drei anderen Modellen wurde eineBibliothek von MATLAB verwendet.

1.3 Aufbau der Arbeit

Im folgenden Kapitel 2 „Sprachassistent - Amazons Alexa“ [Seite 14] wird der Intel-ligente Persönliche Assistent Alexa vom Unternehmen Amazon.com, Inc. vorgestellt. In denUnterkapiteln wird der Aufbau des Systems, die Funktionsweise nach der Eingabe eines Kom-mandos und der Aufbau eines Skills erläutert.

In Kapitel 3 „Architektur der Kommandos“ [Seite 19] wird eine Grammatik für dieHausautomatisierung–Kommandos erforscht. Ziel dieses Kapitels ist die Reduzierung allermöglichen Kommandos auf eine einheitliche Struktur. Dieses Schema ist die Grundbasis desInterpretationsmoduls.

Im Anschluss daran folgen in Kapitel 4 „System zur Interpretation von Kommandos“[Seite 21] die Techniken, Algorithmen und Initialisierungen der Information Retrieval Modelleund des Vektorraum–Models. In diesem Kapitel werden diese drei Modelle theoretisch vorge-stellt.

Das nächste Kapitel 5 „Realisierung vom Boolean Retrieval-, Fuzzy Logic-

und Alexa-Äquivalentes-Model“ [Seite 61] enthält die Entwicklung des BooleanRetrieval–, des Fuzzy Logic– und des Alexa–Äquivalenten Models. Im ersten Unterkapitel wirddas Entwurfsmuster beschrieben, welches für die Realisierung der Modelle verwendet wurde.Darauf werden die verwendete Datenbank und deren Tabellen vorgestellt. Anschließend wird

12

1 EINLEITUNG

die Schnittstelle zwischen der Datenbank und der entwickelten Konsolenanwendung beschrie-ben. Danach werden die Initialisierungsschritte der entwickelten Anwendung dargestellt. Wei-terhin legt dieses Kapitel die Realisierung der drei Modelle – Boolean Retrieval, Fuzzy–Logicund Alexa–Äquivalenten – dar. Im letzten Unterkapitel werden die unterschiedlichen Aufrufva-rianten, mit denen die Anwendung SPRInterpretationsTool gestartet werden kann, vorgestellt.

Das Kapitel 6 „Realisierung vom Vektorraum-Model“ [Seite 98] beschäftigt sich mitdem Vektorraum–Model. Die Bibliothek, die das Word2Vec–Model zur Verfügung stellt, wirderläutert und dessen Bedienung für die Aufgabe dieser Masterarbeit wird gezeigt.

Im Kapitel 7 „Evaluation“ [Seite 105] werden Tests vorgestellt, welche die implementier-ten Algorithmen auf Richtigkeit prüfen. Weiterhin werden die vier Modelle ausgewertet undmiteinander verglichen.

13

2 SPRACHASSISTENT – AMAZONS ALEXA

2 Sprachassistent – Amazons Alexa

Im folgenden Kapitel wird der Intelligente Persönliche Assistent (IPA) Alexa vom Unterneh-men Amazon.com, Ink. vorgestellt. Ein solcher Assistent, auch Sprachassistent oder MobilerAssistent, ist eine Software, um eine sprachlich–intuitive Schnittstelle zwischen einem Benut-zer (Menschen) und einem technischen System zu ermöglichen. In dieser Software wird nebenModulen wie Spracherkennung und –analyse auch die Synthese von natürlichen Antwortenimplementiert. Alle genannten Module werden in dieser Arbeit später detailliert beschrieben.IPAs sind angewandte Technologien aus dem Bereich der Künstlichen Intelligenz. Dort vor al-lem in der maschinellen Sprachverarbeitung bzw. Computerlinguistik. Intelligente PersönlicheAssistenten funktionieren meist als Applikation auf einem Betriebssystemen oder sind in diesesintegriert.

Eine häufig angewendete Funktionsweise eines IPAs startet mit dem Erkennen und Verste-hen der sprachlichen Eingabe eines Nutzers. Dabei werden Spracherkennungs– und Parsing–Algorithmen eingesetzt. Ein erkannter Befehl wird anschließend an eine entsprechende Anwen-dung delegiert. Fortschrittliche Assistenten können bei unklaren Eingaben Rückfragen an denNutzer stellen oder ihn um Bestätigungen bitten. Das Ziel dieser Assistenten ist es, einen mög-lichst nahtlosen und vertrauenswürdigen Sprachdialog zwischen Mensch und Maschine her-zustellen. Um einen Computer sprachliche Zusammenhänge verständlich zu machen, werdensemantische Technologien eingesetzt. Dadurch werden relevante Schlüsselwörter als spezifi-sche Befehle erkannt. Um eine möglichst schnelle Reaktionszeit zwischen Anfrage des Nutzersund Antwort des Systems zu gewährleisten, werden die meisten Daten auf Servern der Anbieterverarbeitet.

Der Amazon Echo des amerikanischen Unternehmens Amazon.com, Inc. ist einer der bekann-teren IPAs. Er ist ein Smart Speaker1 und ein sprachgesteuerter, internetbasierter IntelligenterPersönlicher Assistent. Unter der Bezeichnung Amazon Echo Dot wird eine flachere Versionangeboten. Seit dem 23. Juni 2015 ist der Amazon Echo in den Vereinigten Staaten erhältlich.In Deutschland begann der Verkauf am 26. Oktober 2016. Alle Informationen zu AmazonsAlexa stammen aus [4].

2.1 Sprachsteuerung

Die Geräte sind so konzipiert, dass sie auf ein Signalwort warten. Im Bereitschaftsmodus wirddie aufgenommene Sprache zunächst geräteintern verarbeitet. Mittels gesprochener Aktivie-rungswörter wie Alexa, Echo, Amazon oder Computer oder durch Drücken der Aktionstaste aufder Oberseite des Geräts wird die eigentliche Sprachsteuerung eingeleitet. [5] Im Folgendenüberträgt das Gerät die im Raum gesprochenen Worte digital über das Internet zum Server desHerstellers. Das Gerät ist dazu lokal über ein WLAN-Netzwerk oder per Bluetooth mit dem In-ternet verbunden. Auf dem Server wird versucht die Befehle zu interpretieren und anschließenddarauf zu reagieren.

1Ein Smart Speaker ist eine Art kabelloser Lautsprecher und Sprachempfangsgerät mit integriertem virtuellenAssistenten (künstliche Intelligenz). Dieser ermöglicht interaktive Aktionen und Freisprechaktivierung mit Hilfeeines oder mehrerer „hot words“. Weitere Erläuterungen zu Smart Speaker und hot word siehe Glossar [Seite 9]

14


Über farbige Leuchten zeigt das Gerät die einzelnen Phasen zwischen Bereitschaft, Spracher-kennung und -verarbeitung an. Werden mehrere Geräte in akustischer Reichweite betrieben,erfolgt die Sprachübermittlung von dem Gerät, welches dem Nutzer am nächsten ist. DieseTechnik wird bei Amazon als Echo Spatial Perception bezeichnet. Über einen Knopf könnendie sieben eingebauten Mikrofone deaktiviert werden. Dieser abgeschaltete Zustand wird überrote Leuchten signalisiert. Dann ist keine Sprachsteuerung mehr möglich.

2.2 Skills

Amazon hat eine offene Plattform bereitgestellt, welche die Entwicklung von CUIs ermöglicht.Jeder Nutzer eines Amazon-Accounts hat die Möglichkeit, das System Amazon Alexa über An-wendungen, sogenannten Skills, zu erweitern. Ohne die Skill-Erweiterungen stellt Amazon sei-nen Kunden eine geringe Anzahl an Features zur Verfügung, wie beipielweise abspielen vonMusik, setzen eines Weckers oder Timers, erklären eines Begriffes, verwalten eines Kalenders.Amazon bietet seinen Kunden einen Store für die Skills an. Diese Skills können von Drittan-bietern erstellt werden. Skills werden vom Benutzer eines CUIs aktiviert und bieten zusätzlicheFunktionen wie steuern von Smart Home-Geräten, nutzen von Spielen, vorlesen von Nachrich-ten oder kommunizieren mit einer Bank. In den USA stehen mittlerweile über 50.000 Skillszur Kommunikation mit Webdiensten zur Verfügung. Skills lassen sich einzeln über die mitFire-OS-, Android- und iOS-Geräten kompatible Alexa-App oder per Sprachbefehl aktivieren.Webdienste lassen sich mit Alexa mit dem zur Verfügung gestellten Alexa Skills Kit (ASK)nutzen. Seit Januar 2017 stehen zirka 500 deutschsprachige Skills zur Verfügung. Die meistendavon in der Kategorie „Spiele“, gefolgt von „Quiz & Zubehör“, „Bildung & Nachschlagewer-ke“ und „Neuheiten & Humor“. Ein paar Beispielsätze, welche Amazon Echo interpretiert, sind„Alexa, setze Milch auf die Einkaufsliste“ oder „Alexa, welche Termine habe ich heute?“.

Es gibt mehrere Kooperationspartner, wie beispielsweise BMW, Spotify, TuneIn Radio, Deut-sche Bahn, Tagesschau, Spiegel Online oder TorAlarm, eine Fußball-App. Mit dem entspre-chenden Skill ist es möglich, seinen BMW mit Alexa abzuschließen, sich aktuelle Schlagzeilenvon Nachrichtenseiten wie Spiegel Online oder die Fußballergebnisse vorlesen zu lassen. DasGerät kann mit Hilfe der Hue Bridge und kompatiblen Leuchten (per App via WLAN steuer-bares System von LED-Leuchten) die Beleuchtung im gesamten Haus und im Garten steuern,wenn diese entsprechend vernetzt sind.[6] Über Alexa-Sprachbefehle können mit der Harmony-Fernbedienung von Logitech steuerbare Fernseher, AV-Receiver und Streaming-Boxen gesteu-ert werden, womit die indirekte Nutzung von Netflix oder Amazon Video möglich ist. In denUSA ist es möglich, den Kontostand durch Alexa abzurufen und Bestellungen bei Domino’sPizza abzusetzen. Amazon ermöglicht seinen Prime-Kunden auf Zuruf Musik und hundert-tausende Prime Artikel zu bestellen, die von Amazon verkauft oder versandt werden. DerSpracheinkauf unterstützt auch die erneute Bestellung von Prime-Produkten über die Amazon-Plattform. Genauso können Bestellungen nach der Aufgabe storniert und bereits versandte Be-stellungen nachverfolgt werden. Mit dem von Amazon bereitgestellten Alexa Skill Kit kön-nen benutzerdefinierte Interaktionsmodelle erstellt werden. Dabei wird die Logik für ein Skillimplementiert. Die Sprachschnittstelle wird ebenfalls definiert, über die ein Benutzer mit derQualifikation interagiert. Um die Sprachschnittstelle zu definieren, werden mögliche gespro-chene Eingaben der Benutzer mit der dazugehörigen Absicht, die ein Cloud-basierter Dienstverarbeitet, zugeordnet.

15


Bevor die grundlegende Funktionsweise von Alexa beschrieben wird, werden erst ein paar Be-grifflichkeiten erklärt. Ein Skill setzt sich aus diesen Begriffen zusammen. [7]

Ein Intent (Absicht) stellt eine Aktion dar, die die gesprochene Anforderung des Benutzerserfüllt. Technisch gesehen handelt es sich hierbei um eine Funktion. In dem Wetter-Beispielkönnte es ein Intent geben, der für alle Anfragen bezüglich des Niederschlags zuständig ist.

Utterance (Äußerung) bezeichnet eine erwartete Formulierung von Nutzer, über die ein Intentverwendet werden kann. Utterances werden immer explizit mit einem bestimmten Intent ver-knüpft. Es sollte so viele repräsentative Formulierungen wie möglich geben, damit möglichsteine große Menge an Sätzen vom System dem richtigem Intent zugeordnet werden kann. Mög-liche Utterances, die im Szenario den Niederschlag-Intent aufrufen, könnten lauten:

• „Brauche ich morgen einen Regenschirm?“

• „Wird es morgen regnen?“

• „Wie hoch ist morgen der Wahrscheinlichkeitswert für Niederschlag?“

Drei unterschiedliche Utterances, die den gleichen Intent ansprechen.

Slots (Einschub) sind Argumente, welche Intents optional hinzugefügt werden können. Nutzerhaben die Möglichkeit durch Angabe von Slots ihre Anfrage zu parametrisieren bzw. zu spezi-fizieren. In den oben angegebenen Utterances ist das Wort morgen ein Slot. Diesen Slot könntedurch eine andere Zeitangabe ersetzt werden. Weiterhin könnte eine Ortsangabe verwendet wer-den. Mögliche Beispiele wären:

• „Brauche ich am Freitag in Krefeld einen Regenschirm?“

• „Wird es in Krefeld morgen zwischen 10 und 14 Uhr regnen?“

Mit Custom slot types (Benutzerdefinierte Einschub-Typen) bezeichnet Amazon eine repräsen-tative Liste der möglichen Werte für einen Slot. Dadurch grenzt der Entwickler die möglichenWerte für eine Slot ein. Benutzerdefinierte Slot-Typen werden für Listen von Elementen ver-wendet, die nicht durch einen der integrierten Slot-Typen von Amazon abgedeckt sind.

Eine optionale Erweiterung für einen Skill ist ein Dialog model (Dialogmodel). Dies repräsen-tiert eine Struktur, welche die Schritte für ein Multi-Turn-Gespräch zwischen dem Skill unddem Benutzer identifiziert. Dadurch werden alle Informationen gesammelt, die zur Ausführungeines Skills erforderlich sind. Dadurch wird versucht, den Code des Entwicklers, um den Be-nutzer nach Informationen zu fragen, zu vereinfachen. Im Wetter-Szenario stellt der Anwenderdie Frage: „Wie wird morgen das Wetter hier?“ Der IPA kann das Wort „hier“ nicht in einen Ortinterpretieren. Deswegen fragt er den Anwender entweder nach einem Ort oder nach einer Post-leitzahl. Wichtig ist, dass dieses Multi-Turn-Gespräch zu dieser Thematik nur einmal geführtwird.

16


2.3 Funktionsweise

Jeder Skill besteht aus zwei Komponenten, die vom Entwickler selbst angelegt werden müssen.

Abbildung 1: Funktionsweise Alexa

Interaction-ModelZum einen das Interaction-Model, in dem hauptsächlich die Intents, Utterances und Slots festge-legt und verknüpft werden. Darüber bildet das Interaction-Model das eigentliche User-Interfaceab. Dieser Teil wird auch als „CUI-Frontend“ bezeichnet. Es befindet sich innerhalb der Alexa-Plattform und hilft dabei, eingegangene Sprachbefehle entsprechend auszuwerten und zuzuord-nen.

Gestartet wird jeder Vorgang durch eine Spracheingabe über das Echo-Gerät. Diese Eingabewird an die Alexa-Plattform gesandt. Auf dieser Plattform werden die aufgenommenen Wörtermit Hilfe von Natural language processing (NLP) in Text umgewandelt. Enthaltene Informatio-nen werden analysiert und über das Interaction-Model ausgewertet. Im Anschluss schickt dasCUI-Frontend (linker Bereich von der gestrichelten Linie in Abbildung 1) diese Informationenin Textform an die im Model hinterlegte Serveradresse. Dort befindet sich der zweite Teil ei-nes Skills, die eigentliche Logik beziehungsweise das „CUI-Backend“ (rechter Bereich von dergestrichelten Linie in Abbildung 1).

CUI-BackendMit Amazon-Web-Services (AWS) bietet Amazon eine komfortable und schnelle Möglichkeit,diese Logik für einen eigenen Skill zu entwickeln und bereit zu stellen. Natürlich können auchbenutzerdefinierte Server verwendet werden. Die ausgewerteten Daten der Spracheingabe (wiezum Beispiel angesprochener Intent und Werte der Slots) werden hier verarbeiten. Je nachdem,was der Skill tun soll, müssen die entsprechenden Daten aufbereitet und in Textform zurück andie Alexa-Plattform gesendet werden. Mit einem Sprachsynthese–System wird der Text in ei-ne menschliche Sprechstimme erzeugt und veranlasst das Alexa-Device, die Antwort über denLautsprecher auszugeben. Zusätzlich zur Sprachausgabe ist es auch möglich, visuelle Kompo-nenten, sogenannte Skill-Cards, über die Alexa-App auf das Smartphone des Users zu senden.Diese Cards sind jedoch statisch und die Möglichkeit, die vordefinierten Amazon-Layouts die-ser Cards zu ändern, ist nicht gegeben.

Amazon hat die genaue Implementierung der Interpretation im CUI–Backend nicht veröffent-licht. Durch die Möglichkeit, dass benutzerspezifische Skills angelegt werden können, mussdie Auswertung basierend auf dem Kommando und den hinterlegten Informationen zum Skillgeschehen. Ein solches Model wurde in dieser Masterarbeit entwickelt. Dabei wird der Fo-kus auf die Schlüsselwörter eines Kommandos gelegt. Durch Ermitteln der Überschneidun-

17


gen der im Kommando vorkommenden Schlüsselwörter und den in den Skills verwendetenWörtern kann die Interpretation zum gewünschten Sucherfolg führen. Die Realisierung desAlexa–Äquivalentem Models wird in Kapitel 5.8 „Kommando-Interpretation mit dem

Alexa-Äquivalentes Model“ [Seite 88] beschrieben.

18

3 ARCHITEKTUR DER KOMMANDOS

3 Architektur der Kommandos

Ein System zur Gerätesteuerung kann eine endliche Menge an Aktionen ausführen. Dabei istes egal, ob der Anwender die Eingaben per Tastatur, Bedienung einer Oberfläche oder perSpracheingabe tätigt. Durch die Eingabe wird die zugehörige Aktion von der Gerätesteuerungausgeführt.

Mögliche Kommandos für eine automatisierte Haussteuerung könnten lauten:

• Licht an / aus

• Fahre die Jalousie nach oben / nach unten

• Rolllade hoch / runter

• Das Licht in der Küche ausschalten / einschalten

• Fahre die Jalousie heute bei Sonnenuntergang herunter und schalte das Licht im Wohn-zimmer ein.

• Schließe die Haustüre

• Status Licht in der Küche

• Musik ein / aus

• Musik leiser / lauter

• Dimme das Licht im Esszimmer auf 40%.

Durch diese Kommando–Beispiele wird deutlich, dass die Kommandos in Gruppen eingeordnetwerden können. Es wird eine Struktur sichtbar, die je Kommando mindestens zwei relevanteInformationen enthält. Jedes Kommando muss mindestens aus einem Gerät , welches gesteuertwerden soll, und einer Zustandsänderung , die ausgeführt werden soll, bestehen.

• Licht an

• Licht aus

• Fahre die Jalousie nach oben

• Fahre die Jalousie nach unten

• Rollade hoch

• Rollade runter

• Schließe die Haustüre

• Musik ein

• Musik aus

• Musik leiser

• Musik lauter

19

3 ARCHITEKTUR DER KOMMANDOS

Ein Gerät kann mehrmals in der Gerätesteuerung vorkommen. Ein Beispiel in der Hausautoma-tisierung ist das „Licht“. Dieses wird es wahrscheinlich in mehreren Räumen geben oder sogarmehrmals in einem Raum. Damit das System genau spezifizieren kann, welches Gerät ausge-führt werden soll, muss das Kommando eine zusätzliche Information enthalten, den Ort desGerätes.

• Licht in der Küche ausschalten

• Licht in der Küche einschalten

• Status Licht in der Küche

Zusätzlich kann das Kommando weitere Informationen enthalten. Diese spezifizieren zum Bei-spiel die Zustandsänderung genauer. Im Beispiel der Hausautomatisierung geschieht diesesbeim Kommando „ Dimme das Licht im Esszimmer auf 40%.“ Bei diesem Kommando wirddie Zustandsänderung „dimmen“ mit 40% Lichtintensität spezifiziert.

Im Kommando „Fahre die Jalousie heute bei Sonnenuntergang herunter und schalte das Lichtim Wohnzimmer ein.“ wird deutlich, dass der Anwender auch mehrere Kommandos verknüp-fen kann. Im ersten Teil des Kommandos soll das System die Jalousie herunterfahren . DieAktion wird durch den Zusatz „heute bei Sonnenuntergang“ zeitlich konkretisiert. Der zweiteTeil des Kommandos sorgt für das einschalten des Licht es im Wohnzimmer . Durch das Wort„und“ wird das System aufgefordert, die beiden Kommandos entweder gleichzeitig oder direktnacheinander auszuführen.

Ein Kommando besteht somit mindestens aus dem Gerät, welches gesteuert werden soll, und derZustandsänderung, die ausgeführt werden soll. Wenn das Gerät mehr als einmal existiert, mussdas Kommando einen Ort zum Gerät enthalten. Durch weitere zusätzliche Parameter kann dieAktion noch feiner spezifiziert werden. Zusätzlich können mehrere Kommandos miteinanderverknüpft werden.

20

4 SYSTEM ZUR INTERPRETATION VON KOMMANDOS

4 System zur Interpretation von Kommandos

In dieser Arbeit wird ein System entwickelt, welches ein Kommando vom Anwender in die rich-tige Aktion einer Gerätesteuerung transformiert um diese Aktion zur Ausführung zu bringen.In diesem Kapitel wird der theoretische Hintergrund zu drei Modellen vorgestellt. Zu jedemdieser Modelle werden die benötigten Algorithmen, Datenstrukturen und die einzelnen Schritteder Transformation erklärt. Begonnen wird mit dem am einfachsten zu implementierenden Re-trieval Model, dem Boolean Retrieval Model. Anschließend wird die Erweiterung des BooleanRetrieval Models, das Fuzzy Logic Model, beschrieben. Das Vector Space Model – Word2Vecwird als drittes Model am Ende dieses Kapitels erläutert. In diesem Model werden die Termeanhand von Vektoren abgebildet und verglichen.

Damit das System das Kommando vom Anwender richtig interpretiert und den Anstoß zurAusführung der richtigen Aktion startet, werden im ersten Schritt alle möglichen Kommandosvordefiniert. Jede Aktion hat somit eine Liste von möglichen Kommandos, die der Anwenderbenutzen kann bzw. soll. Nun wird der Ablauf des Systems betrachtet, nachdem ein Anwen-der ein Kommando abgesetzt hat. Im ersten Schritt erhält das System das erkannte Kommando.Dies wird vom Spracherkennungssystem in einer Reihe von Wortfolgen zur Verfügung gestellt.Zu dieser Wortfolge, die technisch als String abgebildet wird, muss nun die richtige Aktion ge-funden werden. Das Ziel von diesem System ist es, aus diesen Informationen und der Wortfolgedie richtige Aktion zu finden.

Eine Variante zum Finden der richtigen Aktion ist jedes dieser Kommandos mit der Wortfolgezu vergleichen. Sollte ein Kommando zu 100% mit der Wortfolge übereinstimmen, hätte dasSystem die richtige Aktion gefunden. Diese Variante ist aber problematisch. Das Kommandomuss in der Reihenfolge und von den Worten identisch mit der Vorlage sein. Weiterhin ist dieserAnsatz ziemlich zeitaufwendig, da von allen Aktionen alle vordefinierten Kommandos kontrol-liert werden müssen. Zusätzlich muss dieser Vorgang bei jeder Anfrage erneut durchgeführtwerden.

Eine andere Variante ist ein Document Retrieval-System (DRS) aufzusetzen. Ein Anwenderdrückt in Form einer Suchanfrage sein Informationsbedürfnis aus. Ein Document Retrieval-System bezeichnet den computerunterstützten Prozess der Rückgewinnung von Dokumenten,die für diesen Anwender entsprechend seinem Informationsbedürfnis relevant sein könnten. Ei-nes der bekanntesten Beispiele eines DRS in der heutigen Praxis sind die Suchmaschinen imInternet. Wesentlich bei einem DRS ist das Zusammenspiel der Komponenten der Informati-onserschließung (Indexierung) und der Informationswiedergewinnung (Retrieval). Anstelle vonDokumenten wird dieses Document Retrieval System Kommandos zurückgeben. Mit anderenWorten in diesem Document Retrieval System repräsentiert ein Kommando ein Dokument. So-mit können die Techniken und Algorithmen eines DRS für die Kommando-Interpretation einesSprachassistenten verwendet werden. In den nächsten Kapiteln werden die Techniken und Al-gorithmen eines DRS genauer beschrieben. Diese Informationen stammen aus [1].

21


4.1 Boolean Retrieval Model

Um zu vermeiden, dass die Kommandos für jede Anfrage linear gescannt werden, müssen dieKommandos im Voraus indiziert werden. Das Ergebnis ist eine binäre Term-Dokument-Matrixoder Inzidenzmatrix. Dadurch, dass bei einer Gerätesteuerung keine Dokumente verwendetwerden, wird die Bezeichnung der Matrix in dieser Masterarbeit in Term-Kommando-Matrixgeändert. Eine solche Matrix ist in Abbildung 2 dargestellt. In den Zeilen der Matrix stehenalle Terme, welche von der Gerätesteuerung unterstützt werden. Alle Kommandos der Steue-rung sind in den Spalten angeordnet. In jeder Zelle steht entweder eine 1 oder eine 0. Dabeirepräsentiert eine 1, dass der Term dieser Zeile in dem Kommando aus der Spalte enthalten ist.Eine 0 dagegen beschreibt, dass dieser Term nicht in diesem Kommando auftritt. Ein Term isteine indizierte Einheit (näher erläutert in Abschnitt 4.1.6 „Tokenisierung“ [Seite 32]). Ter-me sind in der Regel Wörter. In der Literatur der Informationsbeschaffung wird normalerweisevon Begriffen gesprochen, weil einige von ihnen normalerweise nicht als Wörter betrachtetwerden. Als Kommando ist zum Beispiel „Licht in der Küche einschalten“ angegeben. DiesesKommando enthält insgesamt 5 Terme (Licht, in, der, Küche, einschalten).

Lichtin der Kücheeinschalten

Lichtin der Küche

ein

Lichtin der Kücheausschalten

Lichtin der Küche

aus

Lichtim Wohnzimmer

einschalten

Licht 1 1 1 1 1Küche 1 1 1 1 0Wohnzimmer 0 0 0 0 1einschalten 1 0 0 0 1ein 0 1 0 0 0ausschalten 0 0 1 0 0aus 0 0 0 1 0in 1 1 1 1 0im 0 0 0 0 1der 1 1 1 1 0...

......

......

...

Tabelle 2: Eine Term-Kommando-Matrix – Matrixelement (t,d) ist 1, wenn das Kommando inSpalte d den Term (Wort) in Zeile t enthält, ansonsten ist es 0.

22


Mit einer solchen Matrix kann das System schnell sehen in welchem Kommando ein Begriffvorkommt bzw. alle Begriffe, die in einem Kommando vorkommen. Dazu betrachtet das Systemdie Matrixzeilen bzw. -spalten. Um die Anfrage „Licht in der Küche einschalten“ zu beantwor-ten, werden die Vektoren von den einzelnen Termen mit einem bitweisen UND (Bitwise AND– &) verknüpft.

Beispiel Kommando: Licht in der Küche einschalten.

Term Vektor

Licht 11111UND in 11110UND der 11110UND Küche 11110UND einschalten 10001

= 10000

Tabelle 3: Bitweise UND-Verknüpfung zum Beispiel Kommando.

Das Ergebnis ist wieder ein Vektor. Eine 1 repräsentiert, dass dieses Kommando mit der An-frage übereinstimmt, ansonsten steht an der Stelle eine 0. Bei der Beispiel-Anfrage kommt alsErgebnis heraus, dass nur das erste Kommando „Licht in der Küche einschalten“ zutrifft.

Das Boolean Retrieval Model ist ein Modell für die Informationsbeschaffung, in dem die Begrif-fe mit den Operatoren AND, OR und NOT kombiniert werden. Die Term-Kommando-Matrixist als Datenstruktur für größere Dokument-Kollektionen ungeeignet. Ein realistisches Szenarioaus der Information Retrieval Thematik wäre, dass eine Kollektion von 1.000.000 Dokumentenexistiert. Im Durchschnitt hat jedes Dokument 1.000 Terme (Wörter). Zusätzlich wird angenom-men, dass insgesamt 500.000 unterschiedliche Terme in diesem Szenario vorhanden sind. DieTerm-Dokument-Matrix hätte in diesem Szenario 1.000.000 ·500.000 = 5.000.000.000 Matrix-elemente (Einsen und Nullen). Diese Matrix müsste im Arbeitsspeicher des Computer geladenwerden. Um eine Eins bzw. eine Null im Computer zu speichern, ist pro Ziffer ein Bit nötig.Dies würde in diesem Szenario 500 Gigabit = 62,5 GB ergeben. Diese Hauptspeichermengeist selbst für die aktuellen 64Bit Betriebssysteme unüblich. Bei einer Gerätesteuerung ist voneiner wesentlich kleineren Datenmenge auszugehen, da hierbei deutlich weniger Kommandosund Terme existieren. Aber die entscheidende Beobachtung ist, dass die Matrix extrem spär-lich besetzt ist. D. h. sie hat nur wenige Einträge ungleich Null. Da jedes Kommando 5 Wörterlang ist, hat die Matrix nicht mehr als fünf Millionen Einsen. Mit anderen Worten mindestens99,999% der Zellen sind mit einer Null gefüllt.

23


Eine viel bessere Darstellung ist daher das Speichern der Informationen, die tatsächlich vorkom-men, in diesem Fall die Einsen. Diese Idee ist zentral für das erste große Konzept im InformationRetrieval, der invertierte Index (inverted index).

Abbildung 2: Die beiden Teile eines Inverted Index. Eine einfach verkettete Liste wird als be-vorzugte Datenstruktur verwendet. [1, Seite 6]

Die Grundidee eines inverted index ist in Abbildung 2 dargestellt. Es wird ein Dictionary (Wör-terbuch) von allen Termen angelegt.2 Für jeden Term aus dem Dictionary wird eine Liste an-gelegt. In dieser Liste werden alle Dokumente gespeichert, in denen der Term enthalten ist.Diese Liste wird Posting-Liste oder Inverted-Liste genannt. Jedes Kommando innerhalb einerKommandosammlung erhält eine eindeutige Nummer, die als document identifier (docID) be-zeichnet wird. Während der Indexerstellung wird jedem neuen Kommando eine fortlaufendeGanzzahl zugewiesen. Aus Speicherplatzgründen wird in der Posting-Liste nur diese Nummergespeichert.

2In manchen Literaturen wird dieses Wörterbuch auch als Vokabular oder Lexikon bezeichnet; In dieser Ma-sterarbeit wird die Datenstruktur Dictionary und die Menge an Termen Vokabular genannt.

24


4.1.1 Erstellen eines inverted indexes

Um die Geschwindigkeitsvorteile der Indexierung zum Zeitpunkt des Abrufs zu nutzen, mussder Index im Voraus aufgebaut werden. Die wichtigsten Schritte dabei sind:

1. Die zu indexierenden Kommandos sammeln:

2. Den Text eines jeden Kommandos tokenisieren3 und jedes Kommando in eine Liste ausTokens verwandeln:

3. Eine linguistische Vorverarbeitung durchführen, die eine Liste der normalisierten Tokenerzeugt, welches die Indexbegriffe sind:

4. Die Dokumente indizieren, indem ein inverted index erstellt wird, der aus einem Dictio-nary und Posting-Listen besteht.

Die ersten drei Schritte werden näher im Kapitel 4.1.4 „Initialisierung beim

Erstellen eines inverted index“ [Seite 31] definiert und besprochen. Bis dahin sindToken und normalisierte Token etwas äquivalentes zu Wörter. In diesem Kapitel wird davonausgegangen, dass die ersten drei Schritte bereits durchgeführt wurden.

Abbildung 3 „Schritte einer Indexierung“ [Seite 26] beschreibt die Indexierung. Eswird eine Variante beschrieben, welche die einzelnen Schritte der Indexierung verdeutlichensoll. Diese Variante wurde wegen ihrer einfachen Nachvollziehbarkeit gewählt, sollte aber inder Praxis wegen der Laufzeit und dem Speicherbedarf nicht verwendet werden. Im erstenSchritt wird jedes Token des Kommando-Korpus, mit der dazugehörigen docID, aufgezählt.Dieser Schritt ist wie eine Erstellung einer Liste mit den normierten Tokens und den dazuge-hörigem docID des Tokens vorstellen. Eine solche Liste ist in Abbildung 3 auf der linken Seitesichtbar. Diese Liste wird im nächsten Schritt alphabetisch nach den Tokens sortiert. Tokensdesselben Begriffs werden nach dem Wort und dann nach docID gruppiert. Der letzte Teil derIndexierung ist in der Abbildung 3 auf der rechten Seite abgebildet. Die Tokens und docIDswerden in unterschiedlichen Listen gespeichert. Die Tokens werden im Dictionary gespeichert.Wichtig dabei ist, dass jedes Token nur einmal im Dictionary gespeichert wird. Neben den To-kens werden auch andere zusammenfassende Informationen gespeichert. Diese Informationen

3In der Computerlinguistik bezeichnet Tokenisierung die Segmentierung eines Textes in Einheiten der Wortebe-ne. Beispiel-Algorithmen zu diesem Thema werden in Kapitel 4.1.6 „Tokenisierung“ [Seite 32] beschrieben

25


dienen der Verbesserung der Abfragezeit und zum Verbessern des Ergebnisses. In Abbildung 3wird die Anzahl der Kommandos notiert, in denen der Token enthalten ist. Mit anderen Wortendie Häufigkeit der Kommandos (Dokumente) für jeden Token (deshalb die Abkürzung docu-ment frequency (dft)). Jeder Eintrag des Dictionarys hat weiterhin einen Zeiger auf seine eigenePosting-Liste. Diese repräsentiert eine Liste der Dokumente, in denen ein Token vorkommt.Weitere Informationen wie die Häufigkeit des Tokens (die Häufigkeit jedes Tokens in jedemKommando) oder die Position(en) des Tokens in jedem Kommando können zusätzlich in dieserListe gespeichert werden.

Abbildung 3: Schritte einer Indexierung

4.1.2 Verarbeitung Boolescher Abfragen

In diesem Kapitel wird die Frage beantwortet, wie eine Abfrage mit dem inverted index und demgrundlegenden booleschen Abfragemodell beantwortet wird. Als Beispiel wird angenommen,dass das System das Kommando „Licht in der Küche ein“ vom Anwender zur Verarbeitungerhalten hat. Aus diesem Kommando ergibt sich folgende konjunktive Abfrage für das System:

Licht AND in AND der AND Küche AND ein

Zur Verarbeitung dieser Anfrage wird der teilweise aufgebaute inverted index aus Abbil-dung 3 „Schritte einer Indexierung“ [Seite 26] verwendet. Folgender Pseudo–Codebeschreibt den Algorithmus:

for term in [Licht, in, der, Küche, ein]{

Dictionary–Eintrag zu term findenEntsprechende posting list abfragen und zwischenspeichern

}Die Schnittmenge zwischen allen posting lists bilden

Abbildung 4 stellt den Algorithmus grafisch dar.

26


Abbildung 4: Schnittmenge aus den Posting-Listen aus den Termen: Licht, in, der, Kücheund ein. Der Inverted Index stammt aus Abbildung 3 „Schritte einer Indexierung“[Seite 26].

1 public PostingList Intersect(PostingList p1, PostingList p2) {2 PostingList answer = new PostingList();3 while(p1 != null and p2 != null) {4 if(p1.docID == p2.docID) {5 answer.Add(p1.docID);6 p1.nextDocID();7 p2.nextDocID();8 }9 else if(p1.docID < p2.docID) {

10 p1.nextDocID();11 }12 else {13 p2.nextDocID();14 }15 }16 return answer;17 }

Listing 1: Algorithmus zum Zusammenführen von zwei Posting-Listen

Der kritischste und zeitaufwendigste Teil bei der Verarbeitung einer derartigen Anfrage ist dieBildung der Schnittmenge (Intersection). Benötigt wird ein Algorithmus, der alle Komman-dos findet, in denen alle in der Anfrage enthaltenen Begriffe enthalten sind. Dabei sollte derAlgorithmus effizient die vollständige Liste berechnen. Die dabei angewendete Operation wirdhäufig als Zusammenführen von Posting-Listen bezeichnet. Der Quellcode 1 repräsentiert einensolch einfachen und effektiven Algorithmus. Dabei werden die Listen mit einer logischen UND-Verknüpfung zusammengeführt. Der Algorithmus geht davon aus, dass alle Posting-Listen imVorhinein numerisch sortiert sind. Die beiden Posting-Listen zeigen zu Beginn des Algorith-mus auf ihren ersten docID-Eintrag. Bei jedem Iterationsschritt werden beide docIDs der Listenverglichen. Zeigen beide Listen auf die selbe docID, wird diese in der Ergebnisliste answeraufgenommen. Zusätzlich werden beide Zeiger der Posting-Listen p1 und p2 inkrementiert.Sodass bei der nächsten Iteration zwei neue docIDs verglichen werden. Andernfalls wird derZeiger inkrementiert, der auf die kleinere docID zeigt. Nachdem einer der Posting-Listen ab-gearbeitet ist, und somit auf den Wert null zeigt, wird als letzter Schritt des Algorithmus dieErgebnisliste zurückgegeben. Sei die Länge der Posting-Listen von p1 n und die von p2 k,dann muss der Intersect-Algorithmus O(n + k) Operationen durchführen. Die Komplexität desAlgorithmus ist O(N), wobei N die Anzahl der Kommandos im Korpus ist. Dadurch, dass ein

27


System für Gerätesteuerung nur Kommandos entgegen nimmt, können Anfragen mit den rest-lichen Booleschen Operationen (OR, NOT) ausgeschlossen werden. Bei allgemeinen Anfragenmüssen in der Regel, wie auch bei der Beispielanfrage von oben, mehr als zwei Posting−Listenzusammengeführt werden. In diesem Fall wird der Intersect-Algorithmus zwischen je zweiPosting-Listen ausgeführt. Die daraus resultierende Ergebnisliste ersetzt die beiden behandel-ten Posting-Listen. Dies wird solange auf der neuen Menge weitergeführt, bis nur noch eineErgebnisliste als Ergebnis gegeben ist.

Abbildung 5: Intersect-Algorithmus mit beliebiger Reihenfolge der Abarbeitung der Posting-Listen

Abbildung 6: Intersect-Algorithmus mit der Reihenfolge nach der Heuristik

Dabei stellt sich die Frage, ob die Reihenfolge, wie die einzelnen Posting-Listen abgearbei-tet werden, egal ist. Die Abbildungen 5 und 6 zeigen deutlich, dass dies nicht der Fall ist.Allein in dem beschriebenen Beispiel aus den Abbildungen 5 und 6 werden 22 Operationen(106 − 84 = 22) gespart. Als Standardheuristik wird die Bearbeitung in der Reihenfolge nachdem aufsteigenden Vorkommenshäufigkeiten des Terms im Korpus vorgeschlagen. Mit anderenWorten startet der Algorithmus mit den beiden kleinsten Posting-Listen und führt die nächstenIterationen mit der Ergebnisliste und der nächst kleineren Posting-Liste fort. Somit dürften alleZwischenergebnisse nicht größer sein als die kleinste Posting-Liste, und werden daher meistensden geringsten Aufwand haben.

In diesem Kapitel wurde die Struktur und der Aufbau eines grundlegenden inverted index be-schrieben, der aus einem Dictionary und mehreren Posting-Listen besteht. Das Boolean Re-trieval Model wurde vorgestellt. Weiterhin wurde untersucht wie über lineare Zusammenfüh-rungen und einfache Abfrageoptimierung effizient Anfragen durchgeführt werden können. Inden folgenden Kapiteln werden umfangreichere Abfragemodelle und Modelle vorgestellt, dieeine sortierte Ergebnismenge präsentieren. Denn boolesche Abfragen rufen nur eine Reihe vonübereinstimmenden Kommandos ab. Gewünscht ist aber normalerweise eine effektive Metho-de, um die zurückgegebenen Ergebnisse zu ordnen (oder zu „bewerten“). Dies erfordert einenMechanismus zum Bestimmen einer Kommandobewertung.

28


4.1.3 Effizienterer Intersection-Algorithmus durch skip pointer

Eine Möglichkeit, wie die Effizienz des Intersection-Algorithmus aus Abbildung 1„Algorithmus zum Zusammenführen von zwei Posting-Listen“ [Seite 27] gestei-gert werden kann, wird in diesem Kapitel beschrieben. Bis zum jetzigen Zeitpunkt wurden diebeiden Posting-Listen gleichzeitig linear durchlaufen. Wenn die Listenlängen n und k sind, wer-den durch den Algorithmus O(n + k) Operationen durchgeführt. Kann man die Schnittmengeder Posting− Listen in sublinearer Zeit bilden?

Eine Möglichkeit wären skip pointer. Skip pointer sind effektive Abkürzungen, die es ermögli-chen, die Verarbeitung von Teilen der Posting-Liste zu überspringen. Die übersprungenen Ein-träge sind definitiv nicht in der Ergebnismenge enthalten. Dazu müsste jede Posting-Liste mitskip pointer zur Indizierungszeit erweitert werden, wie in Abbildung 7 dargestellt. Betrach-tet wird nun wie sich der Intersection-Algorithmus durch skip pointer ändert und wie sich dieAbarbeitung nun darstellt.

Abbildung 7: Zwei Posting-Listen mit skip pointer

Angenommen der Algorithmus hat beide Listen bereits bis zur docID 8 bearbeitet. Die docID 8wurde der Ergebnisliste hinzugefügt. Als nächstes werden beide Zeiger der Posting-Listen einElement weitergeschoben. Somit zeigt die obere Liste auf die docID 16 und die untere Liste aufdie docID 41. Dadurch, dass 16 kleiner als 41 ist, wird der Zeiger von der oberen Liste um einElement erhöht. Bisher hatte jeder Posting-Listen Eintrag nur einen Verweis (Zeiger) auf dennächsten Eintrag. Mit den skip pointer haben einige Einträge mehrere Verweise (Zeiger) aufmehrere unterschiedliche Einträge aus der Posting-Liste. Dadurch kann zur docID 19 oder überden skip pointer direkt auf die docID 28 gesprungen werden. Der Algorithmus kann in der obe-ren Liste die Abkürzung über den skip pointer nehmen, da die docID 28 immer noch kleiner alsdie docID 41 ist. Keine der übersprungenen docIDs würde mit der docID 41 matchen und somitauch nicht in der Ergebnisliste aufgenommen werden. Somit werden durch diesen Sprung ins-gesamt zwei docIDs (19 und 23) übersprungen. Sollte der skip pointer auf eine docID zeigen,die größer ist als die docID von der anderen Liste, wird die Abkürzung nicht verwendet undder Algorithmus wählt den direkten Nachfolger wie ohne skip pointer. Quellcode 2 zeigt dengeänderten Intersect-Algorithmus, sodass skip pointer verwendet werden können. skip poin-

29


ter können nur bei Anfragen, die durch das logische UND verknüpft sind, verwendet werden.Dadurch, dass bei Gerätesteuerungen keine anderen logischen Operationen verwendet werden,sind skip pointer eine Möglichkeit um die Laufzeit des Intersect-Algorithmus zu verbessern.

1 public PostingList IntersectWithSkipPointers(PostingList p1, PostingList p2)2 {3 PostingList answer = new PostingList();4 while (p1 != null && p2 != null)5 {6 if (p1.docID == p2.docID)7 {8 answer.Add(p1.docID);9 p1.nextDocID();

10 p2.nextDocID();11 }12 else if (p1.docID < p2.docID)13 {14 if (p1.hasSkip() && (p1.getDocIDOfSkip() <= p2.docID))15 {16 while (p1.hasSkip() && (p1.getDocIDOfSkip() <= p2.docID))17 {18 p1.doSkipping();19 }20 }21 else22 {23 p1.nextDocID();24 }25 }26 else27 {28 if (p2.hasSkip() && (p2.getDocIDOfSkip() <= p1.docID))29 {30 while (p2.hasSkip() && (p2.getDocIDOfSkip() <= p1.docID)) {31 p2.doSkipping();32 }33 }34 else35 {36 p2.nextDocID();37 }38 }39 return answer;40 }41 }

Listing 2: Intersection Algorithmus mit skip pointer

skip pointer sind nur für die ursprünglichen Posting-Liste sinnvoll, da der Aufwand sich für dieZwischenergebnislisten nicht rechnet. Doch wie viele skip pointer und wo werden diese in derPosting-Liste sinnvoll eingefügt?

• Je mehr skip pointer gesetzt werden, desto öfters können Einträge übersprungen werden.Aber es bedeutet auch, dass viele Vergleiche mit skip pointer ausgeführt werden müssen.Zusätzlich müssen die skip pointer gespeichert werden, was Speicherplatz im Arbeits-speicher bedeutet.

• Je weniger skip pointer gesetzt werden, desto weniger Vergleiche werden benötigt. Aberdann ist die Sprungweite länger, was bedeutet, dass es weniger Möglichkeiten zum Über-springen gibt.

30


Eine einfache Heuristik für das Platzieren von skip pointer ist, dass für eine Posting-Liste derLänge N eine Verteilung der skip pointer mit einer Sprungweite von

√N optimal ist. Wichtig

bei der Verwendung von skip pointer ist außerdem, dass die Posting-Listen möglichst statischbleiben. Ein permanentes Einfügen und Löschen der Einträge kann dazu führen, dass die skippointer ins leere zeigen bzw. die Belegung der skip pointer für die komplette Posting-Listeerneuert werden muss.

4.1.4 Initialisierung beim Erstellen eines inverted index

In Kapitel 4.1.1 „Erstellen eines inverted indexes“ [Seite 25] wurden die Schritteder Konstruktion eines inverted index aufgezählt:

1. Die zu indexierenden Kommandos sammeln.

2. Den Text tokenisieren.

3. Linguistische Vorverarbeitungen auf den Token durchführen.

4. Kommandos indizieren und inverted index erstellen.

In diesem Kapitel wird beschrieben, wie die Grundeinheit eines Kommandos definiert ist undwie die Zeichenfolge, aus der die Einheit besteht, bestimmt wird (Abschnitt 4.1.5 „Abrufender Zeichenfolge aus Kommandos“ [Seite 31]). Im Detail werden dann einige der we-sentlichen linguistischen Fragen der Tokenisierung und der sprachlichen Vorverarbeitung desTerm-Vokabulars beschrieben (Abschnitt 4.1.6 „Tokenisierung“ [Seite 32]). Die Tokenisie-rung ist der Prozess des Zerlegens von Zeichenströmen in Token. Dagegen beschäftigt sich dielinguistische Vorverarbeitung mit dem Aufbau von Äquivalenzklassen.

4.1.5 Abrufen der Zeichenfolge aus Kommandos

Jedes Information Retrieval System benötigt einen bestimmten Input, damit es das Vokabularvon Termen und alles was zu einem Information Retrieval System gehört generieren kann. Inder Regel bildet dieser Input eine Sammlung von digitalen Dokumenten, die sich in Form vonDateien auf Webservern befinden. Die Frage was überhaupt ein Dokument ist, stellt sich beieiner Gerätesteuerung nicht. Jedes einzelne Kommando kann als Dokument aufgefasst werden,welches in dieser Arbeit vorausgesetzt wird.

Der erste Verarbeitungsschritt vom Indizierungsprozess ist die Umwandlung dieser Bytefolge ineine lineare Zeichenfolge. Trivial ist dieser Schritt, wenn der gegebene Text in einer vorher demSystem bekannten Sprache geschrieben und in einer eindeutigen einheitlichen Codierung vor-liegt. Dies ist in der Praxis der Ausnahmefall. Die Zeichenfolge kann durch eines von verschie-denen Einzelbyte- oder Multibyte-Kodierungsschemata kodiert sein, wie z.B. Unicode UTF-8,oder durch verschiedene nationale oder herstellerbezogene spezifische Standards. Sobald dieKodierung bestimmt ist, wird die Bytefolge zu einer Zeichenfolge dekodiert.

Die Zeichen müssen möglicherweise aus einer binären Darstellung, wie einer Microsoft WordDOC Datei und/oder einem komprimierten Format wie ZIP, dekodiert werden. Auch hier mussdas Dokumentenformat festlegt werden bzw. dem System bekannt sein. Anschließend muss ein

31


geeigneter Decoder verwendet werden. Auch bei reinen Textdokumenten kann eine zusätzli-che Dekodierung erforderlich sein. In XML-Dokumenten müssen Zeicheneinheiten wie &dekodiert werden, um das richtige Zeichen zu erhalten.

In dieser Masterarbeit wird davon ausgegangen, dass die Dokumente (Kommandos) eine Listevon Zeichen sind. Weiterhin wird vorausgesetzt, dass das in dieser Arbeit entwickelte RetrievalSystem Deutsch als einzige Sprache unterstützt. Somit sind Probleme, welche z.B. in der Spra-che Arabisch auftreten würden, für uns uninteressant. Ein arabischer Text wird von rechts nachlinks geschrieben. Weiterhin wird angenommen, dass alle Texte UTF-8 kodiert sind.

4.1.6 Tokenisierung

Unter Tokenisierung wird die Zerkleinerung einer Zeichenfolge einer Dokumenteneinheit ineinzelne Stücke verstanden. Diese einzelnen Stücke werden Token genannt. Gleichzeitig kön-nen bestimmte Zeichen, wie z.B. Interpunktion, entfernt werden.

Input: Bitte das Licht in der Küche ausschalten.Output: bitte das Licht in der Küche ausschalten

Diese Token werden oft als Terme oder Wörter bezeichnet. Trotzdem sollte eine Unterscheidungzwischen dem Typ und dem Token vorgenommen werden. Eine Instanz von einer Zeichenfolgeaus einem bestimmten Dokument wird als Token bezeichnet. Für die Verarbeitung werden dieseals nützliche semantische Einheit zusammengefasst. Die Klasse aller Token, welche die gleicheZeichenfolge enthalten, ist ein Typ. Ein Term ist ein (möglicherweise normalisierter) Typ, derim Dictionary des IR-Systems enthalten ist. In Abschnitt 4.1.7 „Token-Normalisierung“[Seite 33] werden verschiedene Normierungsprozesse vorgestellt. Die Hauptfrage der Toke-nisierungsphase ist, welche Tokens sollen zur Verarbeitung verwendet werden. Eine einfacheMethode der Tokenisierung ist das Zerlegen der Zeichenfolge nach jedem Leerzeichen. Der Al-gorithmus, der für die Tokenisierung zuständig ist, durchläuft die Zeichenfolge. Sobald er einLeerzeichen erreicht, wird das bis dorthin gelesene Wort als Token definiert. Der Token wirdnur dem Dictionary hinzugefügt, wenn es dort noch nicht existiert. Wie bereits oben erwähntkann der Algorithmus beim Durchlaufen der Zeichenfolge bestimmte Zeichen entfernen. Sinn-voll ist hier, die zu entfernenden Zeichen in einer externen Liste zu speichern. Problematisch istdiese Variante bei Punkten im Programmcode (java.io.InputStream), Zahlen bzw. Datumsanga-ben (94.12.255.255, 3/12/94, 12. März 1994) und Eigennamen (M*A*S*H, C++). Jedoch istdas Aufnehmen jeder dieser Wörter als Ganzes unpraktisch, da dadurch das Vokabular enormvergrößert wird. Eine Möglichkeit wäre diese Zeichen als Metadaten zu speichern.

In Information Retrieval Systemen werden in der Tokenisierungsphase ganze Wörter entfernt,die keine inhaltliche Bedeutung haben und somit keine Hilfe beim Suchen nach relevantenDokumenten darstellen. Diese Wörter werden Stoppwörter genannt. Darunter fallen vor allemArtikel und Präpositionen, die extrem häufig in Dokumenten auftreten und dadurch die Posting-Listen deutlich vergrößern. Die Verwendung von Stoppwörtern sollte für ein System für Geräte-steuerung ausgelassen werden. Wörter wie ein, aus, hoch, runter sind extrem wichtig und habeneine inhaltliche Bedeutung.

32


4.1.7 Token-Normalisierung

Durch die Tokenisierung werden die Wörter aus einem Dokument in einzelne Token unterteilt.Dabei entstehen syntaktisch unterschiedliche Token, die das Gleiche meinen. Sollte ein An-wender eines Information Retrieval Systems nach dem Begriff „USA“ suchen, sollten ebenfallsDokumente mit dem Term „U.S.A.“ in der Ergebnismenge erscheinen. Damit der Anwendernicht alle möglichen syntaktischen Varianten eines Suchterms angeben muss, sollte das Sy-stem dies durch einen Algorithmus lösen. Dieser führt die Token auf eine kanonische Formzurück, sodass Tokens mit unterschiedlicher Zeichenfolge, aber gleicher Bedeutung, als äqui-valent betrachtet werden. Durch diesen Algorithmus werden Äquivalenzklassen gebildet, diedurch den am häufigsten auftretenden Token repräsentiert werden. Dieser Algorithmus mussauf den Kommandos (Dokumenten) und auch auf jede Anfrage ausgeführt werden. Durch An-geben von einfachen Regeln können Varianten auf einen ausgezeichneten Vertreter der Äqui-valenzklasse gebildet werden. Zum Beispiel durch das Entfernen des Bindestriches innerhalbeines Wortes. Diese Variante ist nur einfach, wenn durch die Regel Zeichen weggelassen oderumgeformt werden. Ein Hinzufügen stellt sich als komplizierter heraus. Grundsätzlich solltedas System Case-Folding4 implementiert haben. Es sollte alle Buchstaben in Kleinbuchstabenumwandeln. Durch weitere Regeln können Nomen herausgefiltert werden. Das Case-Foldingsollte für ein Wort nicht durchgeführt werden, wenn dieses Wort großgeschrieben ist und sichmitten im Satz befindet. Außerdem sollten Wörter ignoriert werden, die mehr als ein Großbuch-staben besitzen. Natürlich werden durch solche Regeln nicht alle Nomen ignoriert. Weiterhinsollte das System eine Vereinheitlichung von Schreibweisen (z.B. Datums- und Zeitangaben)implementiert haben.

Zusätzlich ist ein Umgang mit grammatikalischen Varianten des Token vorteilhaft. In einemDokument tauchen häufig grammatikalische Varianten eines Wortes auf. Sie können in gebeug-ter oder abgeleiteter Form auftreten. Wenn nach einer Form eines Wortes gesucht wird, solltedas System auch Wörter in anderer Form zurückliefern. Algorithmen, die dies behandeln wer-den Stemming und Lemmatisierung genannt. Unter beiden Verfahren werden morphologisch-linguistische Analysen durchgeführt, um die Grundform des Wortes zu finden. Einer der be-kanntesten Algorithmen für die deutsche Sprache ist der Porter-Stemmer-Algorithmus[8]. Die-ser wendet eine Menge von Verkürzungsregeln an. Diese werden solange angewendet, bis dasWort eine Minimalanzahl von Silben aufweist. Ursprünglich wurde der Algorithmus für Wörterder englischen Sprache entwickelt. Durch relativ leichte Änderungen der Regeln kann dieser inandere Sprachen portiert werden. Das in dieser Arbeit vorgestellte System soll nur auf Kom-mandos in der deutschen Sprache reagieren. Deshalb wird in den nächsten Abschnitten nur derStemming-Algorithmus für die deutsche Sprache erläutert.[9]

Der Algorithmus setzt voraus, dass alle Wörter in Kleinbuchstaben vorliegen. Im Vergleich zurenglischen Sprache enthält die deutsche Sprache zusätzlich folgende Buchstaben:

ä ö ü ß

Für den Stemming-Algorithmus werden folgende Buchstaben als Vokale definiert:

a e i o u y ä ö ü

4Case-Folding ist ein Prozess, bei dem alle Zeichen in einem Dokument in die gleiche Groß- oder Kleinschrei-bung konvertiert werden.

33


Der German-Stemmer-Algorithmus beginnt mit folgenden Regeln in angegebener Reihenfolge:

1. Die Buchstaben u und y werden in Großbuchstaben geändert, wenn diese zwischen zweiVokalen stehen.

2. Den Buchstaben ß durch ss ersetzen.

3. Die Buchstaben ae durch ä ersetzen.

4. Die Buchstaben oe durch ö ersetzen.

5. Die Buchstaben ue durch ü ersetzen, außer vor dem ue steht der Buchstabe q.

Für das Wort quelle wird Regel 5 nicht ausgeführt, da vor dem ue der Buchstabe q steht.Für das Wort feuer wird ebenfalls die Regel 5 nicht ausgeführt, da durch die zweite Regel dasWort zu feUer geändert wurde. Dadurch trifft der Vergleich mit ue nicht zu.

Die meisten Stemmer-Anweisungen verwenden mindestens eine der Bereichsdefinitionen R1

und R2. Diese sind wie folgt definiert: [10]

Bereichsdefinition R1Um die Bereichsdefinition R1 zu bilden, wird das erste Vorkommen eines Vokals imWort gesucht. Im Anschluss wird ab diesem Index der erste Buchstabe gesucht, derkein Vokal ist. R1 definiert den Bereich ab dem Buchstaben nach dem „Nicht-Vokal“bis zum Ende des Wortes. Sollte der Anfang von R1 nicht im Wort gefunden werden,wird R1 auf den Nullbereich am Ende des Wortes gesetzt.

Bereichsdefinition R2Die Bereichsdefinition R2 wird wie R1 gebildet. Der einzige Unterschied ist, dass derersten Vokal in R1 gesucht wird. Dadurch ist R2 immer eine Teilmenge von R1. Kannder Bereich nicht gesetzt werden, wird R2 auf den Nullbereich am Ende des Wortesgesetzt.

Definition VokaleDie Definition von Vokalen variiert von Sprache zu Sprache. Im Französischen zumBeispiel ist der Buchstabe é ein Vokal, und im Italienischen ist ein i zwischen zweianderen Vokalen kein Vokal. Die Klasse der Buchstaben, die Vokale bilden, muss injedem Stemmer-Algorithmus definiert sein.

34


Nachfolgend zwei Beispiele für die Initialisierung der Bereichsdefinitionen R1 undR2.

Beispiel 1

e i n s c h a l t e n| < – – – – – – – – – – – – – – > | R1

| < – – – – > | R2

Der erste Buchstabe (e) des Wortes einschalten ist als Vokal definiert. Somit istdas n der erste Buchstabe, welcher kein Vokal ist. Somit ergibt sich die Bereichsde-finition R1 für das Wort einschalten vom 4. Buchstabe bis zum Ende des Wortes.D.h. R1 repräsentiert den Bereich schalten. In diesem Bereich ist der erste Vokal derBuchstabe a. Das darauf folgende l ist der erste Nicht-Vokal-Buchstabe, sodass R2den Bereich ten beschreibt.

Beispiel 2

e i n–> | <– R1–> | <– R2

Im Wort ein ist der Buchstabe e der erste Vokal. Der Buchstabe n ist der erste Buch-stabe, welcher nicht als Vokal definiert ist. Dadurch dass der Buchstabe n der letzteBuchstabe des Wortes ein ist, wird R1 für dieses Wort auf den Nullbereich des Wor-tes gesetzt. Anschließend wird auch die Bereichsdefinition R2 auf diesen Nullbereichgesetzt.

Nachjustierung R1Nachdem R1 und R2 standardmäßig, wie gerade beschrieben, eingerichtet sind, wird R1 soeingestellt, dass der Bereich vor R1 mindestens drei Buchstaben enthält. Mit anderen Worten,sollte der Bereich von R1 innerhalb der ersten drei Buchstaben beginnen, wird der Beginn desBeriechs von R1 auf den vierten Buchstaben verlegt. Dabei spielt es keine Rolle, ob dieserBuchstabe ein Vokal oder kein Vokal ist. Die Bereichsdefinition R2 bleibt unverändert.

WortendungslistenAls nächstes werden zwei Listen definiert. Die erste Liste repräsentiert Buchstaben, die vor derWortendung -s stehen dürfen. In [9] wurde die Liste mit folgenden Buchstaben definiert: b, d,

f, g, h, k, l, m, n, r, t.

Die zweite Liste repräsentiert Buchstaben, die vor der Wortendung -st stehen dürfen. Es sinddie selben Buchstaben wie in der erste Liste, außer das der Buchstabe r nicht enthalten ist.

35


Wortstamm durch Suffixstreichung bildenIn den folgenden drei Schritten wird nach Suffixen gesucht. Der gefundene Suffix wird ausdem Wort und aus den Wortbereichen R1 und R2 entfernt. Die drei Schritte werden einzeln undnacheinander ausgeführt.

Schritt 1:Das Suffix von R1 wird mit den folgenden Suffixen in der vorgegebenen Reihenfolgeder Gruppen verglichen.

• em ern er

• e en es

• s (mit vorangestelltem gültigen s-ending im Wort. D.h. vor dem s darf imWort nur ein Buchstabe aus der oben definierten Liste stehen. Denn dergültige Buchstabe aus der s-Endung-Liste muss nicht zwingenderweise inR1 enthalten sein.)

Sollte ein Wort auf die Suffixe der 2. Gruppe (e en es) passen und nach dem Ent-fernen mit -niss enden, wird das letzte s entfernt.

(Beispiele für Schritt 1: äckern→ äck, ackers→ acker, armes→ arm, bedürfnissen→ bedürfnis)

Schritt 2:Die aus Schritt 1 neu entstandenen Wortteile werden mit den folgenden Suffixen ver-glichen. Auch in diesem Schritt wird der Suffix gewählt, welcher von der Anzahl amBesten mit dem Wortbereich R1 übereinstimmt.

• en er est

• st (mit vorangestelltem gültigen st-Ende, d.h. vor dem st darf nur ein Buch-stabe aus der oben definierten Liste stehen. Zusätzlich muss vor diesemgültigem Buchstabe mindestens drei Buchstaben stehen. Ansonsten trifftdiese Regel nicht zu.)

Auch in diesem Schritt wird der gefundene Suffix vom Wort und den Bereichsdefini-tionen entfernt.

(Beispiel: Das Wort derbsten wird durch Schritt 1 zu derbst verändert. Schritt 2verändert das Wort zu derb, da b ein gültiger Buchstabe für eine st-Endung ist und 3Buchstaben vorausgehen).

36


Schritt 3: d-Suffix5

In diesem Schritt werden folgende Suffixe mit dem Bereich verglichen, welcher durchR2 repräsentiert wird.

• end ungSollte nach dem Entfernen des Suffix der Bereich R2 auf ig enden und vordieser Endung steht nicht der Buchstabe e, wird auch der Suffix ig entfernt.

• ig ik ischDiese Suffixe werden nur gelöscht, wenn davor nicht der Buchstabe e steht.

• lich heitWenn nach dem Löschen des Suffixes der Bereich von R1 mit er oder enaufhört, werden diese beiden Endungen ebenfalls entfernt.

• keitWenn vor dem keit die Endung lich oder ig in R2 steht, werden auchdiese mit entfernt.

AbschlussZum Schluss werden die großgeschriebenen Buchstaben U und Y wieder in lower case umge-wandelt. Zusätzlich werden die Umlautepunkte entfernt (ä→ a, ö→ o, ü→ u).

Der umgesetzte Quellcode in C# zu diesem Algorithmus wird in Kapitel 5.5.2„Implementierung des German Stemming Algorithmus“ [Seite 70] erläutert. Eine Li-ste mit Beispielbegriffen und deren gebildeten Grundform entsprechend des Porter-Stemmer-Algorithmus befindet sich auf der beigelegten CD.

5Ein d-Suffix oder abgeleitetes Suffix (derivational suffix) ermöglicht es, ein neues Wort aus einem anderenWort zu bilden. Oft hat dieses Wort eine andere grammatikalische Kategorie oder einen anderen Sinn. Ob ein d-Suffix angehängt werden kann, ergibt sich nicht aus den Regeln der Grammatik, sondern aus einem Dictionary.So kann im Englischen zu bestimmten Adjektiven -ness hinzugefügt werden, um entsprechende Substantive zubilden (littleness, kindness, foolishness). Bei anderen Adjektiven funktioniert dies nicht (big, cruel, wise). d-Suffixekönnen verwendet werden, um die Bedeutung zu ändern, oft auf eher exotische Weise. [11]

37


4.1.8 Position Index

Neben den bisher gespeicherten Informationen kann die Position des Terms im Dokument ge-speichert werden. Dieser Eintrag wird positional index genannt. Zu jedem Term wird eine Da-tenstruktur, wie in Abbildung 8, persistiert.

auf, 993427:{

1: 7,18,33,72,86,231;2: 1,17,74,222,255;4: 8,16,190,429,433;5: 363,367;7: 13,23,191;. . .

}

Abbildung 8: Das Wort „auf“ hat eine document frequency von 993427 und ist sechs mal imDokument 1 an den Positionen 7, 18, 33, 72, 86 und 231 vorhanden.

4.2 Fuzzy Logik

Bei Kommandos zur Gerätesteuerung kommen sehr häufig Synonyme vor. Jeder Anwender ver-wendet unterschiedliche Begriffe bzw. Formulierungen. Mit den bisher erläuterten Technikenist eine Behandlung von Synonymen sehr speicher- bzw. zeitaufwendig. Denn bisher musstenalle möglichen Kommandos, welche die Gerätesteuerung behandelt, dem System bekannt sein.Das ergibt bei den Kommandos sehr viel Redundanz, bei denen sich nur ein Term mit der selbenBedeutung (Rolllade - Jalousie) ändert. Weiterhin sind nicht alle Terme in einem Kommandogleich wichtig oder charakteristisch. Auch die Häufigkeit eines Termes wird bisher nicht be-trachtet. Wörter wie der, die, das, im, in, . . . werden sehr häufig in Kommandos enthalten sein,sind aber für die Auswertung nicht relevant. Die Idee hinter der jetzt vorgestellten Technik ist dieBeschreibung der Menge der Indexterme eines Kommandos mithilfe von einer Fuzzy-Menge.Es wird keine binäre Zugehörigkeit (Term ist im Kommando enthalten = 1; nicht enthalten =0) eines Terms verwendet. Jeder Term hat einen bestimmten Grad der Zugehörigkeit zu einemKommando. Es wird somit eine graduelle Zugehörigkeit verwendet. Somit ändert sich die Da-tenmenge von {Licht, in, der, Küche, ein} in {Licht/0.3, in/0.1, der/0.12, Küche/0.9, ein/0.4}.

Die bisherige Vorgehensweise zum Lösen einer Anfrage mit booleschen Operatoren ist in derFuzzy-Logik nicht mehr möglich. Es werden dafür die Zadeh Operatoren verwendet:

Sei µ(A) der Fuzzy-Wahrheitswert der Aussage A• Konjunktion (AND): µ(A ∧ B) = min{µ(A), µ(B)}• Disjunktion (OR): µ(A ∨ B) = max{µ(A), µ(B)}• Negation (NOT): µ(¬A) = 1− µ(A)

38


Dokument d1 = { Licht/0.4, Küche/0.9, ein/0.8}Query Q = { (Licht AND NOT Küche) OR ein }⇒ Dokument d1 erfüllt zum Grad 0.8 die Anfrage Q}

Abbildung 9: Beispiel – Fuzzy-Logik

Es gibt noch einen weiteren Nachteil der Zadeh Operatoren. Als Beispiel wird ein Doku-ment verwendet, welches den Term Informatik mit dem Wert 0.4 beschreibt und mit demWert 0.9 den Term Java. Durch die min-Semantik wird dieses Dokument mit einer AnfrageInformatik AND Java immer als Ergebniswert den Wert 0.4 haben. Intuitiv sollte diesesDokument einen höheren Wert haben, da es den Term Java so deutlich beschreibt. Ein ande-res Dokument, welches beide Begriffe mit dem Wert 0.5 beschreibt, wird als Ergebniswert aufdie selbe Anfrage immer den Wert 0.5 zurückgeben. Mit anderen Worten beschreibt das zweiteDokument durch die Zadeh Operatoren die Anfrage besser als das erste Dokument und wird inder sortierten Ergebnisliste besser eingestuft.

Das selbe Problem tritt beim Zadeh Operator max, welcher für die Disjunktion verwendet wird,auf. Dokument 1 beschreibt den Term Informatik mit 0.3 und den Term Java mit dem Wert0.5. Mit den Werten 0.2 für Informatik und 0.7 für den Term Java ist Dokument 2 gegeben.Für die Anfrage Informatik OR Java liefert Dokument 1 den Wert 0.5 und Dokument 2den Wert 0.7. Auch in diesem Fall wird Dokument 2 höher in der Ergebnisliste eingestuft alsDokument 1. Intuitiv würde man Dokument 1 bevorzugen, da dieser beide Terme beschreibt.Dokument 2 beschreibt eher einen der beiden Termen.

Wie sich diese Problematik auf Kommandos auswirkt wird in Kapitel 7 erläutert. Wegen die-ser min/max-Semantik kann es vorkommen, dass weniger relevante Ergebnisse vom Systemzurückgeliefert werden. Ebenso liefert ein Boolean Retrieval System durch die starke Verknüp-fung der Anfrageterme mit booleschen Operatoren zu viele oder zu wenige relevante Ergebnis-se. Durch die Verknüpfung mit UND-Operatoren können zu wenige bis hin zu kein relevantesDokument zurückgeliefert werden. Mit den ODER-Verknüpfungen können zu viele, bis hin zuallen Dokumenten als Resultate geliefert werden. Dieses Problem wird in der Literatur Feast OrFamine Phänomen genannt.

Um den Wert der graduellen Zugehörigkeit zu berechnen, wird ein Ähnlichkeitsmaß benötigt.Das Jaccard-Maß ist ein solches Ähnlichkeitsmaß. Mit ihm soll herausgefunden werden, wel-che Terme häufig gemeinsam innerhalb einer Dokument-Kollektion vorkommen. Dieses Maßist auch unter der Bezeichnung Term-Term-Korrelationskoeffizient bekannt. Das Jaccard-Maßc(t, u), wobei t und u beides Indexterme sind, ist wie folgt definiert:

c(t, u) =Anzahl Dokumente, die t und u gemeinsam enthalten

Anzahl Dokument, die t oder u enthalten(1)

c(t, u) hat:

• den Wert 1, wenn t und u nur gemeinsam vorkommen

• den Wert 0, wenn t und u nur getrennt vorkommen

• einen Wert zwischen 0 und 1, sonst

39


Für die Beispiele zur Berechnung des Jaccard-Maß und des Ogawa-Wertes werden folgendeKommandos verwendet:

• Licht im Kinderzimmer ausschalten

• Rollladen im Wohnzimmer runter

• Jalousie im Wohnzimmer runter

• Garagentor runter

Beispiel Jaccard–Maß–Berechnung

c(t, u) =Anzahl Dokumente, die t und u gemeinsam enthalten

Anzahl Dokument, die t oder u enthalten(2)

c(im, runter) =Anzahl Kommandos, die den Term „im“ und „runter“ gemeinsam enthalten

Anzahl Kommandos, die den Term „im“ oder „runter“ enthalten(3)

c(im, runter) =2

3(4)

Eine Berechnung über alle Terme ergibt bei diesen Beispiel–Datensätzen folgende Matrix:

licht

im kind

erzi

mm

er

auss

chal

ten

rolll

aden

woh

nzim

mer

runt

er

jalo

usie

gara

gent

or

licht 11

13

11

11

02

03

02

04

02

im 33

13

13

13

23

23

13

02

kinderzimmer 11

11

02

03

04

02

02

ausschalten 11

02

03

04

02

02

rollladen 11

12

13

02

02

wohnzimmer 22

23

12

03

runter 33

13

13

jalousie 11

02

garagentor 11

Tabelle 4: Jaccard-Maß Berechnung des Beispiel-Datensatzes

40


Für die Ermittlung des Zugehörigkeitswertes eines Dokuments D und einem Term t, werdendessen Korrelationswerte (Jaccard–Werte) zu allen Dokumenten auftretenden Termen durch dieFunktion

W(D, t) = 1−∏u∈D

(1− c(u, t)) (5)

zu einem Zugehörigkeitswert (Ogawa–Wert) aggregiert. Mit anderen Worten muss für jedes Do-kument D und jedem Term der Anfrage t die oben stehende Formel ausgeführt werden. Nach-dem diese berechnet wurden, werden die Zadeh Operatoren auf den Werten des DokumentesD ausgeführt. Das Dokument, welches anschließend den maximalen Wert besitzt, ist dem An-frageterm am ähnlichsten. In dieser Masterarbeit wird nur der Maximal–Operator der Zadeh–Operatoren verwendet, weil die einzelnen Terme des Anfrageterms mit der UND–Operationverbunden sind.

41


Für das Anfrage–Kommando q, in diesem Beispiel „Jalousie im Kinderzimmer runter“, wirdfolgendes für das Kommando K1 „Rollladen im Wohnzimmer runter“ durchgeführt:

W(D, t) = 1−∏u∈D

(1− c(u, t)) , wobei q = {t1, t2, . . . tn} (6)

W(K1, jalousie) = 1−[[1− c(rollladen, jalousie)] · [1− c(im, jalousie)]

· [1− c(wohnzimmer, jalousie)] · [1− c(runter, jalousie)]]

(7)

W(K1, jalousie) = 1− [[1− 0

2] · [1− 1

3] · [1− 1

2]] (8)

W(K1, jalousie) = 1− [[1− 0] · [1− 1

3] · [1− 1

2]] (9)

W(K1, jalousie) = 1− [1 · 23· 12] (10)

W(K1, jalousie) = 1− 1

3(11)

W(K1, jalousie) =2

3(12)

Wird die Berechnung für alle Anfrageterme für das Kommando K1 durchgeführt, ergeben sichfolgende Werte:

W(K1, jalousie) =1

3(13)

W(K1, im) = 1 (14)W(K1,Kinderzimmer) = 1 (15)

W(K1, runter) =2

3(16)

W(K1, q) = Min(1

3, 1, 1,

2

3) =

1

3(17)

Dadurch, dass die Anfrageterme immer verundet werden, muss das Minimum aus den einzelnenOgawa–Werten aus Formel 13–16 ermittelt werden. Somit ergibt sich der Ogawa–Wert 1

3für das

Kommando K1 zur Anfrage q.

42


4.2.1 Term frequency and weighting

Bisher wurden Varianten beschrieben, die boolesche Abfragen unterstützen: Ein Dokumentstimmt entweder mit einer Abfrage überein oder nicht. Bei großen Dokumentsammlungen kanndie resultierende Anzahl der übereinstimmenden Dokumente die Anzahl der Dokumente, dieein menschlicher Benutzer möglicherweise durchsuchen könnte, bei weitem übersteigen. Vielschlimmer trifft es hierbei ein System für die Gerätesteuerung. Der Anwender erwartet, dass dasSystem die richtige Aktion ausführt. Was der Anwender nicht möchte ist, dass das System ihmmehrere Aktionen präsentiert, aus denen er die richtige Aktion wählen soll. Dementsprechendist es für eine Suchmaschine unerlässlich, die auf einer Suchanfrage entsprechenden Dokumen-te nach Rangfolge zu sortieren. Dazu berechnet die Suchmaschine in Bezug auf die vorliegendeAnfrage für jedes passende Kommando eine Punktzahl. In diesem Kapitel werden Variantenuntersucht, die eine solche Punktzahl für ein Anfrage-Kommando-Paar berechnen.

Bisher hängt die Bewertung davon ab, ob ein Suchbegriff innerhalb eines Kommandos vorhan-den ist oder nicht. Ein Unterschied zum Boolean Retrieval System ist die Abfrage selber. DerAnwender des Gerätesteuerungssystems formuliert seine Anfrage nicht in diesem Stil: „LichtUND Küche UND einschalten“. Die Kommandos werden vom Anwender nicht durch boolescheOperationen verbunden. Weiterhin können die Terme in beliebiger Reihenfolge auftreten. In derLiteratur wird bei solchen Abfragen von einer Freitextabfrage gesprochen: Eine Abfrage, beider die Begriffe der Abfrage frei in die Suchoberfläche eingegeben bzw. in diesem Fall dem Sy-stem akustisch mitgeteilt werden, ohne dass sie mit Suchoperatoren (wie boolesche Operatoren)verbunden sind. Dieser Abfragestil, der im Web sehr beliebt ist, betrachtet die Abfrage als eineeinfache Wortgruppe. Ein plausibler Bewertungsmechanismus besteht darin, eine Punktzahl zuberechnen, welche die Summe der Übereinstimmungen zwischen jedem Suchbegriff und demKommando angibt. Zu diesem Zweck wird jedem Term in einem Kommando eine Gewichtungzugewiesen, die von der Anzahl der Vorkommen des Terms im Kommando abhängt. Es wirdeine Punktzahl zwischen einem Suchterm t und einem Dokument d berechnet, basierend aufdem Gewicht von t in d. Der einfachste Ansatz besteht darin, das Gewicht der Anzahl der Vor-kommen von t in Dokument d zuzuordnen. Dieses Gewichtungsschema wird als Termfrequenzbezeichnet und wird mit tft,d bezeichnet. Für ein Dokument d kann der Satz von Gewichten, derdurch die obigen tf-Gewichte bestimmt wird (oder jede andere Gewichtungsfunktion, welchedie Anzahl der Vorkommen von t in d auf einen positiven realen Wert abbildet), als quantita-tive Abbildung dieses Kommandos angesehen werden. Diese Variante ist in der Literatur alsbag-of-words Modell bekannt. Bei diesem Modell wird die genaue Reihenfolge der Begriffein einem Dokument ignoriert. Die Anzahl der Vorkommen jedes Terms ist dagegen wesentlich(im Gegensatz zur booleschen Suche). D.h. es werden nur Informationen über die Anzahl derVorkommnisse pro Term gespeichert. So ist das Dokument „Maria ist schneller als Johannes“in diesem Modell identisch mit dem Dokument „Johannes ist schneller als Maria“. Dennochscheint es intuitiv, dass zwei Dokumente mit ähnlichen Wortdarstellungen inhaltlich ähnlichsind. Für das System sollte es egal sein, ob der Anwender das Kommando „Licht Küche ein-schalten“ sagt, oder das Kommando „Einschalten Licht Küche“. Wenn in einem bag-of-wordsModell nur die Anzahl der Vorkommen eines Terms wichtig ist, stellt sich die Frage, ob alleWörter in einem Kommando gleich wichtig sind.

43


4.2.2 Inverse document frequency

Die term frequency, wie oben beschrieben, hat ein kritisches Problem: Alle Begriffe werden alsgleich wichtig angesehen. Tatsächlich haben bestimmte Terme wenig oder keine diskriminie-rende Wirkung bei der Bestimmung der Relevanz. In einer Sammlung von Dokumenten überdie Automobilindustrie ist es sehr wahrscheinlich, dass der Term Auto in fast jedem Dokumententhalten ist. Aus diesem Grund muss ein Mechanismus verwendet werden, der die Wirkungvon Termen schwächt, welche oft im Korpus vorkommen. Nur so kann eine sinnvolle Relevanz-bestimmung durchgeführt werden. Ein solcher Mechanismus ist die Reduzierung der Termge-wichtung von Termen mit hoher Dokumentenhäufigkeit. Die Idee dabei ist, das tf-Gewicht einesTerms um einen Faktor zu reduzieren, der mit seiner document frequency wächst. D.h. Doku-mente, die ziemlich häufig bei Anfragen in der Ergebnismenge erscheinen, sollen ein niedrigesGewicht bekommen. Dagegen sollen Dokumente, die selten in der Ergebnismenge auftreten,ein hohes Gewicht erhalten. Die inverse document frequency (idf) von einem Term t ist wiefolgt definiert:

idft = logNdft

(18)

Dabei bezeichnet N die Gesamtanzahl der Dokumente im Korpus. Die idf eines seltenen Be-griffs ist somit hoch, während die idf eines häufigen Terms wahrscheinlich niedrig ist. Tabelle 5zeigt ein Beispiel für idfs in der Reuters-RCV1 Sammlung bestehend aus 806.791 Dokumenten.6

term dft idft

car 18165 1,65auto 6723 2.08insurance 19241 1,62best 25235 1,5

Tabelle 5: Beispiel zu idf-Werten – Reuters-RCV1 Korpus

4.2.3 Tf-idf Gewichtung

Um eine zusammengesetzte Gewichtung für jeden Term in jedem Dokument zu erhalten, werden dieDefintionen von term frequency und inverse document frequency kombiniert. Das tf -idf Gewichtungs-schema weist dem Term t in einem Dokument d eine Gewichtung zu, die durch

tf -idft,d = tft,d · idft (19)

gegeben ist. Mit anderen Worten, tf -idft,d weist dem Begriff t im Dokument d ein Gewicht zu, welches

• am höchsten ist, wenn t innerhalb einer kleinen Anzahl von Dokumenten mehrfach vorkommt.Dies verleiht diesen Dokumenten eine hohe Unterscheidungskraft.

• niedriger ist, wenn der Begriff in einem Dokument weniger häufig vorkommt oder in vielen Do-kumenten vorkommt. Dadurch entsteht ein weniger ausgeprägter Relevanzwert.

• am niedrigste ist, wenn der Begriff in praktisch allen Dokumenten vorkommt.

6In diesem Beispiel wurde der Logarithmus zur Basis 10 verwendet

44


4.3 Vektorraum Model – Word2Vec

Eine komplett andere Vorgehensweise ist die Betrachtung jedes Kommandos als Vektor. Dieser Vektorsetzt sich aus den Termen des Dictionarys zusammen. Diese Variante wird Vector Space Model (VSM)genannt. Bei diesem Model wird ein hochdimensionaler metrischer Vektorraum definiert. In diesemRaum wird jedes Kommando des Korpus als Vektor betrachtet. Für die Auswertung wird die Suchan-frage ebenfalls in diesen Vektorraum überführt. Anschließend wird die mathematische Distanz zwischendem Suchvektor und jedem Kommandovektor ausgewertet. Als Ergebnis liefert das VSM eine nach derberechneten Distanz sortierten Liste mit relevanten Kommandos. Je nach Information Retrieval Systemwird eine bestimmte Menge an relevanten Dokumenten aus dieser Ergebnisliste dem Anwender zurück-gegeben.

Abbildung 10: Beispiel eines Vector Space Models

Ein VSM-Beispiel ist in Abbildung 10 dargestellt. Jede Dimension des Vektorraums eines VSMs wirddurch einen Term des Dictionarys aufgespannt. In Abbildung 10 ist es ein dreidimensionaler Indexraum.Auch die Kommandovektoren werden durch diese Terme identifiziert. Das dreidimensionale Beispielkann auf k-Dimensionen erweitert werden. Dabei repräsentiert k die Anzahl der verschiedenen Indexter-me. Somit wird ein Kommando d durch einen k-dimensionalen Vektor ~V(d) = (ωt1,d, ωt2,d, . . . , ωtk,d)dargestellt, wobei ω das Gewicht des k-ten Terms darstellt und k die Anzahl der Termen im Dictionaryist. Wichtig ist, dass die Terme in jedem Vektor in der gleichen Reihenfolge definiert sind. Die Begrif-fe können mit Gewichten, die auf den Werten 0 (nicht enthalten) und 1 (enthalten) beschränkt sind,oder entsprechend ihrer Bedeutung gewichtet werden. In dieser Masterarbeit wird die Gewichtung nachder Bedeutung der Terme implementiert. Die Termgewichte werden nach dem tf-idf-Gewichtsschemaberechnet. Die Menge an Kommandos kann dann als eine Menge von Vektoren in einem Vektorraumbetrachtet werden, in dem es für jeden Term eine Dimension (Achse) gibt. Durch diese Darstellung ver-lieren die Begriffe in jedem Kommando die relative Reihenfolge. Wie bereits das Beispiel in Abschnitt4.2.1 „Term frequency and weighting“ [Seite 43] zeigte, sind Dokumente syntaktisch iden-tisch, obwohl die Reihenfolge der gleichen Termen unterschiedlich ist.

45


Es stellt sich die Frage: Wie wird die Ähnlichkeit zwischen zwei Kommandos in diesem Vektorraumquantifiziert? Ein erster Versuch könnte die Größe der Vektordifferenz zwischen zwei Kommandovekto-ren berücksichtigen. Diese Maßnahme hat einen Nachteil: Zwei Kommandos mit sehr ähnlichem Inhaltkönnen einen signifikanten Vektorunterschied aufweisen, nur weil der eine Kommandovektor länger istals der andere. So können die relativen Verteilungen der Terme in den beiden Kommandos identisch sein.Die absolute Häufigkeit eines Begriffs können aber viel größer sein. Um den Effekt der Kommandolängezu kompensieren kann zur Quantifizierung der Ähnlichkeit zwischen zwei Kommandos d1 und d2 dieCosinusähnlichkeit (cosine similarity) ihrer Vektordarstellungen ~V(d1) und ~V(d2) berechnet werden:

cos(d1, d2) =〈~V(d1), ~V(d2)〉|~V(d1)||~V(d2)|

(20)

Dabei stellt der Zähler das Skalarprodukt (inner product) der Vektoren ~V(d1) und ~V(d2) dar. Das Skalar-produkt zweier Vektoren 〈~x,~y〉 ist definiert als

M∑i=1

xiyi. (21)

Dabei beschreibt ~V(d) den Dokumentenvektor vom Dokument d mit M Vektorenelementen~V1(d) . . . ~VM(d). Der Nenner ist das Produkt ihrer euklidischen Längen. Die euklidische Länge vomDokument d ist definiert als √√√√ M∑

i=1

~V2i (d). (22)

Die Wirkung des Nenners aus der Gleichung 20 besteht also darin, die Länge der Vektoren ~V(d1) und~V(d2) solange auf die Einheitsvektoren v̂(d1) =

~V(d1)|~V(d1)|

und v̂(d2) =~V(d2)|~V(d2)|

zu normieren. Die Formel 20kann dann umgeschrieben werden in

cos(d1, d2) = v̂(d1) · v̂(d2). (23)

Somit kann die Gleichung 23 als das Skalarprodukt der normalisierten Versionen der beiden Dokumen-tenvektoren betrachtet werden. Dieses Maß ist der Kosinus des Winkels θ zwischen den beiden Vektoren,dargestellt in Abbildung 11.

00 1

1~v(d1)

~v(q)

~v(d2)

~v(d3)

θ

Abbildung 11: Kosinusähnlichkeit zwischen den Dokumenten d1 und d2

46


Anstatt jedes Dokument durch einen vollständigen Vektor zu identifizieren, der am Nullpunkt im Koordi-natensystem entsteht, wird der relative Abstand zwischen den Vektoren beibehalten. Dies wird erreicht,indem alle Vektorlängen auf eins normiert werden und die Projektion der Vektoren auf die Hülle desdurch die Einheitskugel dargestellten Raumes berücksichtigt wird. In diesem Fall kann jedes Dokumentdurch einen einzigen Punkt dargestellt werden, dessen Position durch den Bereich bestimmt wird, in demder entsprechende Dokumentenvektor die Hülle des Bereichs berührt. Zwei Dokumente mit ähnlichenTermen werden dann durch Punkte dargestellt, die im Raum sehr eng beieinander liegen. Im Allgemei-nen korreliert der Abstand zwischen zwei Dokumentenpunkten im Raum umgekehrt mit der Ähnlichkeitder entsprechenden Vektoren.

Wie bereits erwähnt kann auch die Anfrage als Vektor dargestellt werden. Mit anderen Worten kanndie Anfrage wie ein Dokument behandelt werden. Ziel des Systems ist es, den ähnlichsten Dokumen-tenvektor zum Anfragevektor zu finden. Da eine Gerätesteuerung das passende Kommando zu einerAnfrage finden soll, reduziert sich das Problem auf das Finden von einem Dokument, das der Anfrageam ähnlichsten ist. Infolgedessen kann die Kosinusähnlichkeit zwischen dem Abfragevektor und einemDokumentvektor als Maß für die Bewertung des Dokuments für diese Abfrage verwendet werden.

score(q, d) =〈v̂(q), v̂(d)〉|v̂(q)||v̂(d)|

(24)

Durch diese Gleichung kann ein Dokument einen hohen Kosinuswert für eine Anfrage haben, obwohles nicht alle Suchbegriffe enthält. Die Berechnung des Scores wird für jedes Dokument des Korpus aus-geführt. Die resultierenden Ergebnisse können dann verwendet werden, um das am besten bewerteteDokument für eine Abfrage auszuwählen. Die Berechnung der Kosinusähnlichkeiten zwischen dem Ab-fragevektor und jedem Dokumentvektor aus dem Korpus, die Sortierung der resultierenden Ergebnisseund die Auswahl des besten Dokumentes kann teuer sein. Denn eine einzige Ähnlichkeitsberechnungkann ein Skalarprodukt in Zehntausenden von Dimensionen nach sich ziehen, was wiederum Zehntau-sende von arithmetischen Operationen erfordert.

Da die Konfiguration des Vektorraums von der Art und Weise abhängt, wie Terme und Termgewichteden verschiedenen Dokumenten einer Sammlung zugeordnet werden, stellt sich die Frage, ob es eine op-timale Vektorraumkonfiguration gibt. D.h. eine, die eine bestmögliche Suchleistung liefert. Ein idealerVektorraum besteht darin, Dokumente, die für bestimmte Benutzerabfragen gemeinsam relevant sind, zubündeln. Dadurch wird sichergestellt, dass sie gemeinsam als Antwort auf die entsprechenden Anfragenabrufbar sind. Umgekehrt würden Dokumente, die nie gleichzeitig als Ergebnismenge gewünscht wer-den, im Dokumentenraum gut getrennt erscheinen. Eine solche Situation ist in Abbildung 12 dargestellt.Der Abstand zwischen zwei x, die zwei Dokumente darstellen, hängt umgekehrt von der Ähnlichkeitzwischen den entsprechenden Indexvektoren ab.

Für eine Sammlung von n Dokumenten sollte die Funktion

F =

n∑i=1

score(Q,Di) (25)

minimiert werden, wobei score(Q,Di) die Ähnlichkeit zwischen Anfrage Q und Dokument i ist. JedesDokument kann abgerufen werden, wenn es sich in ausreichender Nähe zu einer Benutzeranfrage befin-det. Trotzdem ist die Anzahl der Vektorvergleiche bei einer Sammlung von n Dokumenten proportionalzu n. Somit muss die Anzahl an Dokumenten für den Vektorvergleich gering gehalten werden.

47


x

xx

x

xx

xx

x

x

x

x

xx x

xx

xx

x x

x x x

xxx

xx

xx

x x xxx

x

x

xx

x

xx

x

x

xx x

xx

x

x

x x x

x

xx x

xx

x

x

x x xx

xx x

xx

x

x

x x x

Abbildung 12: Clustered document space

Manche Kommandos einer Gerätesteuerung sind von den Termen unterschiedlich, führen aber zur sel-ben Aktion, die von der Steuerung ausgeführt werden soll. Aus diesem Grund ist ein gebündelter Vek-torraum am besten geeignet, in dem die Kommandos in Klassen gruppiert werden. Jeder dieser Klassenwird durch einen Klassenschwerpunkt (Centroid) repräsentiert. Dies reduziert die Vektorvergleiche aufdie Anzahl an Centroiden. Diese Anzahl an Centroiden sollte deutlich kleiner als n sein. Ein solcherVektorraum ist in Abbildung 12 dargestellt, wobei die verschiedenen Dokumentgruppen durch Ellip-sen dargestellt sind. Repräsentiert werden diese Gruppen durch einen Centroid, bezeichnet durch einenschwarzen Punkt. Der Centroid c einer Dokumentenklasse K definiert sich durch das durchschnittlicheGewicht der Dokumente, die in dieser Klasse vorhanden sind:

cj =1

m

m∑i=1,Di∈K

dij (26)

Dabei ist m die Anzahl der Dokumente, die zu der Klasse K gehören. Eine der bekanntesten Anwendun-gen um Wörter in einem Vektorraum zu transferieren ist Word2Vec. Wörtlich heißt Word2Vec Wort zuVektor. Das Word2Vec Model und die Anwendung wurden 2013 von Mikolov et al. entwickelt. Die Vek-torrepräsentation von Wörtern, die von Word2Vec Modellen gelernt wurden, haben sich in den letztenJahren als semantisch bedeutsam erwiesen und sind für verschiedene NLP-Aufgaben nützlich.

48


4.3.1 Continuous Bag-of-Word Model (CBOW)

x1x2x3

xk

xV

...

...

h1h2

hi

hN

...

...

y1y2y3

yj

yV

...

...WN×V = {wki} W’V×N = {w′ij}

Input layer Hidden layer Output layer

Abbildung 13: Ein einfaches CBOW Modell mit nur einem Wort im Kontext

In dieser Masterarbeit wird von der einfachsten Version des in Miklov et al. [12] vorgestellten Conti-nuous Bag-Of-Word Model (CBOW) ausgegangen. Es wird vorausgesetzt, dass nur ein Wort pro Kon-text betrachtet wird. Das bedeutet, dass das Modell ein Zielwort bei einem Kontextwort vorhersagt. Dasentspricht einem Bigram-Modell. Abbildung 13 zeigt das Netzwerkmodell unter der einfachen Kontext-definition. In diesem Kapitel beschreibt V die Vokabulargröße (Größe des Dictionarys) und N die Größeder hidden layer. Die Einheiten auf benachbarten Layer (Schichten) sind vollständig miteinander ver-bunden. Der Input (Eingabe) ist ein 1-of-N (oder ’one-hot’) kodierter Vektor. Die Kodierung bedeutet,dass für ein gegebenes Eingangskontextwort nur eine von V-Einheiten ({x1, x2, . . . , xV}) 1 ist und alleanderen Einheiten 0 sind. Angenommen das Dictionary hat nur fünf Wörter: König, Dame, Mann, Frauund Kind. Das Wort Königin wird in einer 1-of-n Kodierung folgendermaßen aussehen:

0 1 0 0 0

Königin

König Mann

Frau

Kind

Die Gewichte zwischen der Eingangsschicht (input layer) und der Ausgangsschicht (output layer) werdendurch eine V × N-Matrix W dargestellt. Jede Zeile von W ist die N-dimensionale Vektordarstellung vωvom dazugehörigen Wort der Eingangsschicht. In einem Kontext mit einem Wort und unter der Annahme,dass xk = 1 und xk′ = 0 für k′ 6= k ist

h = xTW = W(k,·) := vωI , (27)

was im wesentlichen das Kopieren der k-ten Zeile von W nach h entspricht. vωI ist die Vektordarstellungdes Eingangwortes ωI . Dies bedeutet, dass die Aktivierungsfunktion der hidden layer units (layerein-heiten) linear sind. D.h. die gewichteten Summen der Eingänge können direkt an die nächste Schichtweitergeleitet werden.

49


Von der hidden Schicht bis zur output Schicht existiert eine andere N × V-Gewichtsmatrix W ′ = {ω′ij}.Mit diesen Gewichten kann eine Punktzahl uj für jedes Wort im Dictionary (Vokabular) berechnet wer-den:

uj = v′ωjT · h (28)

v′ωj ist dabei die j-te Spalte der Matrix W ′. Um die posteriore Verteilung der Wörter zu erhalten, wirdsoftmax, ein log-lineares Klassifikationsmodell, verwendet. Die resultierende Verteilung ist multinomial.

p(ωj | ωI) = yj =exp(uj)

V∑j′=1

exp(uj′)

(29)

yj definiert die Ausgabe der j-ten Einheit der Ausgabeschicht. Wird die Formel (27) und (28) in (29)eingesetzt, kommt folgendes heraus:

p(ωj | ωI) = yj =exp(v′ωO

TvωI )V∑

j′=1

exp(v′ω′ jTvωI )

(30)

Zu beachten ist, dass vω und v′ω zwei Repräsentatoren des Wortes ω sind. vω stammt aus den Zeilenvon W, welche die input → hidden Gewichtsmatrix ist. v′ω stammt aus den Spalten von W ′, welchedie hidden → output Matrix ist. In der nachfolgenden Analyse wird vω als Eingangsvektor und v′ω alsAusgangsvektor des Wortes ω bezeichnet.

Das Trainingsziel für eine Trainingsprobe ist die Maximierung der bedingten Wahrscheinlichkeit (For-mel (30)) unter Beobachtung des tatsächlichen Ausgangswortes ωO unter Berücksichtigung des Ein-gangskontextwortes ωI in Bezug auf die Gewichte. Der Index von ωO wird in der Ausgabeschicht als j∗

bezeichnet.

max p(ωO | ωI) = max yj∗ (31)

= max log yj∗ (32)

= uj∗ − log

V∑j′=1

exp(uj′) := −E (33)

Dabei ist E = − log p(ωO | ωI) die Verlustfunktion, die es zu minimieren gilt. j∗ ist der Index desaktuellen Ausgabeworts in der Ausgabeschicht. Diese Verlustfunktion kann als Sonderfall der entropie-übergreifenden Messung zwischen zwei probabilistischen Verteilungen verstanden werden.Die Aktualisierungsgleichung der Gewichte zwischen hidden und output layer ist die Ableitung von Emit Bezug auf den j-ten Einheits-Netzeingang uj.

∂E∂uj

= yj − tj := ej (34)

wobei tj =

{1, wenn die j-te Einheit das eigentliche Ausgabewort ist0, sonst.

Diese Ableitung ist der Vorhersagefehler ej der Ausgabeschicht.

50


Mit der Ableitung nach ωij werden die Gradienten auf den hidden→ output Gewichten gebildet.

∂E∂ω′ij

=∂E∂uj·

uj

∂ω′ij= ej · hi (35)

Mit Hilfe des stochastischen Gradientenabfalls werden die Gewichtsaktualisierungsgleichung für hidden→ output Gewichte gebildet:

ω′ij(new)

= ω′ij(old) − η · ej · hi (36)

oderv′ωj

(new)= v′ωj

(old) − η · ej · h für j = 1, 2, . . . ,V (37)

η > 0 beschreibt die Lernrate, ej = yj − tj und hi ist die i-te Einheit im hidden layer. v′ωj ist derAusgangsvektor von ωj. Zu beachten ist, dass diese Aktualisierungsgleichung bedeutet, dass jedes mög-liche Wort im Dictionary (Vokabular) durchgegangen werden muss, seine Ausgabewahrscheinlichkeit yj

überprüft und yj mit seiner erwarteten Ausgabe tjj (entweder 0 oder 1) vergleichen muss. Wenn yj > tjist („überschätzend“), dann wird ein Teil des verborgenen Vektors h (d.h. vωI ) von v′ωO

subtrahiert. Da-durch entfernt sich v′ωO

weiter von vωI . Wenn yj < tj ist („unterschätzend“), wird etwas von h zu v′ωO

hinzugefügt, wodurch v′ωOnäher7 an vωI kommt. Wenn yj sehr nahe an tj liegt, dann wird nach der Aktua-

lisierungsgleichung nur eine sehr geringe Änderung der Gewichte vorgenommen. Weiterhin zu beachtenist, dass vω (input vector / Eingangsvektor) und v′ω (output vector / Ausgangsvektor) zwei verschiedeneVektordarstellungen des Wortes ω sind.

Nachdem die Aktualisierungsgleichungen für W ′ gegeben ist, kann W betrachtet werden. Eine Ableitungvon E auf der Ausgabe des hidden layer führt zu:

∂E∂hi

=V∑

j=1

∂E∂uj·∂uj

∂hi=

V∑j=1

ej · ω′ij := EHi (38)

Dabei ist hi die Ausgabe der i-ten Einheit des hidden layers. uj, die Netzeingabe der j-ten Einheit desouput layers, wurde bereits in Formel (28) definiert. ej = yj − tj ist der Vorhersagefehler des j-tenWortes in der Ausgabeschicht. EH, ein N-dimensionierter Vektor, ist die Summe der Ausgabe-Vektorenaller Wörter im Dictionary (Vokabular), gewichtet mit ihrem Vorhersagefehler. Wie bereits erwähnt führtdie hidden layer eine lineare Berechnung der Werte aus der Eingangsschicht (input layer) durch. EineErweiterung der Vektor-Notation aus Formel (27) ergibt:

hi =

V∑k=1

xk · ωki (39)

Nun kann die Ableitung von E mit Bezug auf W gebildet werden, sodass folgendes gilt:

∂E∂ωki

=∂E∂hi· ∂hi

∂ωki= EHi · xk (40)

∂E∂W

= x · EH (41)

Dadurch ergibt sich eine V × N-Matrix. Da nur eine Komponente von x ungleich Null ist, ist nur eineZeile von ∂E

∂W ungleich Null. Der Wert von dieser Zeile ist EH, ein N-dimensionaler Vektor.

7näher bedeutet in diesem Zusammenhang das innere Produkt anstelle von der euklidischen Distanz als Entfer-nungsmaß.

51


Die Aktualisierungsgleichung von W ist dann:

vωI(new) = vωI

(old) − η · EH, (42)

wobei vωI eine Zeile von W ist. Diese Zeile ist der Eingangsvektor des einzigen Kontextworts. Weiterhinist es die einzige Zeile von w, deren Ableitung ungleich Null ist. Alle anderen Zeilen von W bleibennach der Iteration unverändert, da ihre Derivate Null sind. D wird Derivation genannt, wenn D folgendeRegeln für a, b ∈ K, f , g ∈ K[X] erfüllt:

D(af + bg) = aD(f ) + bD(g), D(fg) = fD(g) + gD(f ).

Statt D(f ) wird meist f ′ geschrieben und nennt dies die erste Ableitung von f . [13, S. 66].

Dadurch, dass der Vektor EH die Summe der Ausgabevektoren aller Wörter im Dictionary (Vokabular)ist, die mit ihrem Vorhersagefehler ej = yj − tj gewichtet sind, kann die Formel (42) als Hinzufügeneines Teils jedes Ausgabevektors im Dictionary (Vokabular) zum Eingabevektor des Kontextworts ver-standen werden. Wenn in der Ausgabeschicht (output layer) die Wahrscheinlichkeit, dass ein Wort ωj dasAusgabewort ist, überschätzt wird (yj > tj), dann neigt der Eingabevektor des Kontextworts ωI dazu,sich weiter vom Ausgabevektor von ωj weg zu bewegen. Dagegen neigt der Eingabevektor dazu, sichnäher an den Ausgabevektor von ωj zu bewegen, wenn die Wahrscheinlichkeit, dass ωj das Ausgabewortist, unterschätzt wird (yj < tj). Bei genauer Vorhersage der Wahrscheinlichkeit von ωj hat das wenigEinfluss auf die Bewegung des Eingabevektors von ωI . Die Veränderung des Eingabevektors von ωI wirddurch den Vorhersagefehler im Dictionary (Vokabular) bestimmt. Je größer dieser Vorhersagefehler ist,desto bedeutender sind die Auswirkungen, die ein Wort auf die Bewegung auf den Eingabevektor desKontextworts ausübt.

Da die Modellparameter iterativ aktualisiert werden, indem kontextbezogene Wortpaare durchlaufenwerden, die aus einem Trainings-Korpus generiert werden, sammeln sich die Auswirkungen auf denVektoren an. Es wirkt so, als ob der Ausgangsvektor eines Wortes ω durch die Eingangsvektoren dermitlaufenden Nachbarn von ω hin und her „gezogen“ wird, als gäbe es physikalische Zeichenketten zwi-schen dem Vektor von ω und den Vektoren seiner Nachbarn. Ebenso kann am Eingangsvektor betrachtetwerden, dass dieser von vielen Ausgangsvektoren gezogen wird. Die Gleichgewichtslänge jeder ima-ginären Zeichenkette ist abhängig von der Stärke des Auftretens zwischen dem zugehörigen Wortpaarsowie der Lernrate. Nach vielen Iterationen werden sich die relativen Positionen der Ein- und Ausgangs-vektoren schließlich stabilisieren.

52


x1k...

...

...

...

x2k

xCk

hi...

...

...

...

x1k...

...

yj

Input layer

Hidden layerOutput layer

C×V-dim

N-dimV-dim

WV×N

WV×N

WV×N

...

Abbildung 14: CBOW-Modell mit einer Mehrwort-Kontexteinstellung

Abbildung 14 zeigt das CBOW-Modell mit einer Mehrwort-Kontexteinstellung (multi-word context set-ting). Bei der Berechnung der Ausgabe der versteckten Schicht (hidden layer) nimmt das CBOW-Modell,anstatt den Eingangsvektor des Eingangskontextworts direkt zu kopieren, den Mittelwert der Vektorender Eingangskontextwörter. Weiterhin verwendet das Modell das Produkt aus der input → hidden Ge-wichtsmatrix und den Durchschnittsvektor als Ausgabe.

h =1

CW · (x1 + x2 + . . .+ xC) (43)

=1

C· (vω1 + vω2 + . . .+ vωC) (44)

C ist die Anzahl der Wörter im Kontext, die Wörter im Kontext werden durch ω1, . . . , ωC dargestellt undvω ist der Eingangsvektor eines Wortes ω. Die Verlustfunktion ist definiert als:

E = − log p(ωO | ωI,1, . . . , ωI,C) (45)

= −uj∗ + log

V∑j′=1

exp(uj′) (46)

= −v′ωOT · h + log

V∑j′=1

exp(v′ωjT · h) (47)

Diese Verlustfunktion ist identisch zu der Formel (33), mit der Ausnahme, dass h wie in Formel (44)anstelle von (27) definiert ist.

53


Die Aktualisierungsgleichung für die Gewichte von hidden → output ist genauso wie beim Ein-Wort-Kontext-Modell (37):

v′ωj(new)

= v′ωj(old) − η · ej · h für j = 1, 2, . . .V (48)

Diese Formel muss auf jedes Element der Gewichtsmatrix hidden → output für jede Trainingsinstanzangewendet werden.

Die Aktualisierungsgleichung für input→ hidden Gewichte ist ähnlich wie die Formel (42), außer dassdie folgende Gleichung für jedes Wort ωI,c im Kontext anwendet werden muss:

vωI,c(new) = vωI,c

(old) − 1

C· η · EH für c = 1, 2, . . . ,C (49)

vωI,c ist der Eingangsvektor des c-ten Wortes im Eingangskontext, η ist eine positive Lernrate und EH =∂E∂hi

ist durch die Formel (38) gegeben. Das intuitive Verständnis dieser Aktualisierungsgleichung istidentisch zu Formel (42).

4.3.2 Skip-Gram Model

y1,j......

...

...

yC,j

hi ......

...

...

...

...

xk

Output layer

Hidden layerInput layer

C×V-dim

N-dimV-dim

W’N×V

W’N×V

W’N×V

...

WV×N

y2,j

Abbildung 15: Das Skip-Gram Modell

Das skip-gram Modell wird in Mikolov et al. [12, 14] vorgestellt. Abbildung 15 „Das Skip-GramModell“ [Seite 54] zeigt das skip-gram Modell. Es ist das Gegenteil des CBOW-Modells. Das Zielwortbefindet sich nun auf der Eingangsschicht und die Kontextwörter auf der Ausgangsschicht.

54


vωI bezeichnet immer noch den Eingangsvektor des einzigen Wortes auf der Eingangsschicht. Dadurchergibt sich die gleiche Definition der Ausgänge der versteckten Schicht (hidden layer) h wie in Formel(27). Das bedeutete, dass h die Zeile der input→ hidden Gewichtsmatrix W kopiert, die dem Eingangs-wort ωI zugeordnet ist.

h = W(k,·) := vωI (50)

Auf der Ausgabeschicht wird nicht eine multinomiale Verteilung ausgegeben, sondern C multinomialeVerteilungen. Jede Ausgabe wird mit der gleichen hidden→ output Matrix berechnet:

p(ωc,j = ωO,c | ωI) = yc,j =exp(uc,j)

V∑j′=1

exp(uj′)

(51)

Wobei ωc,j das j-te Wort auf dem c-ten panel der Ausgabeschicht ist. ωO,c ist das tatsächliche c-te Wortin den Ausgabekontextworten. ωI ist das einzige Eingabewort. yc,j ist die Ausgabe der j-ten Einheit aufdem c-ten panel der Ausgabeschicht. uc,j ist der Netzeingang der j-ten Einheit auf dem c-ten panel derAusgabeschicht. Weil die output-layer-panels die gleichen Gewichte haben, ist es wichtig, dass folgendesgilt:

uc,j = uj = v′ωjT · h für c = 1, 2, . . . ,C (52)

Wobei v′ωj der Ausgabe-Vektor des j-ten Wortes im Dictionary (Vokabular), ωj, ist. Weiterhin wird v′ωj

aus einer Spalte der hidden→ output Gewichtsmatrix W ′ entnommen.

Die Ableitung der Parameteraktualisierungsgleichungen unterscheidet sich nicht so sehr vom Ein-Wort-Kontext-Modell. Die Verlustfunktion wird geändert auf:

E = − log p(ωO,1, ωO,2, . . . , ωO,C | ωI) (53)

= − logC∏

c=1

exp(uc,j∗c)V∑

j′=1

exp(uj′)

(54)

= −C∑

c=1

uj∗c+ C · log

V∑j′=1

exp(uj′) (55)

j∗c ist der Index des aktuellen c-ten Kontextworts der Ausgabe im Dictionary (Vokabular).

Die Ableitung von E mit Bezug auf die Netzeingabe jeder Einheit auf jedem Feld der Ausgabeschichtuc,j ergibt:

∂E∂uc,j

= yc,j − tc,j := ec,j (56)

Dies ist der Vorhersagefehler von der Einheit, die identisch zu der aus Formel (34) ist. Zur Vereinfachungder Notation wird ein V-dimensionaler Vektor EI = {EI1, . . . ,EIV} als die Summe der Vorhersagefehlerüber alle Kontextwörter definiert:

EIj =

C∑c=1

ec,j (57)

Die Ableitung von E mit Bezug auf die hidden→ output Matrix WO ergibt:

∂E∂ω′ij

=C∑

c=1

∂E∂uc,j

·∂uc,j

∂ω′ij= EIj · hi (58)

55


Die Aktualisierungsgleichung für die hidden→ output Matrix W ′ ist das Ergebnis folgender Gleichung:

ω′ij(new)

= ω′ij(old) − η · EIj · hi (59)

oder

v′ωj(new)

= v′ωj(old) − η · EIj · h für j = 1, 2, . . . ,V (60)

Das intuitive Verständnis dieser Aktualisierungsgleichung ist das Gleiche wie in Formel (37). Der einzi-ge Unterschied ist, dass der Vorhersagefehler über alle Kontextwörter in der Ausgabeschicht summiertwird. Diese Aktualisierungsgleichung muss für jedes Element der hidden→ output Matrix für jede Trai-ningsinstanz angewendet werden. Die Ableitung der Aktualisierungsgleichung für die input → hiddenMatrix ist identisch zu den Formeln (38) bis (42). Die Ausnahme ist, dass der Vorhersagefehler ej durchEIj ersetzt wird. Die Aktualisierungsgleichung ist definiert durch:

vωj(new) = vωj

(old) − η · EH (61)

EH ist ein N-dimensionaler Vektor, von dem jede Komponente definiert ist als:

EHi =

V∑j=1

EIj · ω′ij (62)

Das intuitive Verständnis von Formel (61) ist identisch zu Formel (42). Bisher wurden die beiden vor-gestellten Modelle („Bigram“-Modelle CBOW und Skip-Gramm) ohne irgendwelche Tricks zur Effizi-enzoptimierung angewendet.Für alle dieser Modelle gibt es zwei Vektordarstellungen für jedes Wort des Dictionarys (Vokabulars): derEingangsvektor vω und der Ausgangsvektor v′ω. Das Lernen der Eingangsvektoren ist einfach. Dagegenist das Anlernen der Ausgangsvektoren sehr schwer.

Um v′ω zu aktualisieren kann aus den Aktualisierungsgleichungen (48) und (59) entnommen werden,dass für jede Trainingsinstanz jedes Wort ωj im Vokabular durchlaufen werden muss, ihre Netzeingabeuj, Wahrscheinlichkeitsvorhersage yj (oder yc,j für Skip-Gramm) und ihren Vorhersagefehler ej (oder EIj

für Skip-Gramm) berechnet werden müssen. Zum Schluss werden ihre Vorhersagefehler verwendet, umihren Ausgabevektor v′j zu aktualisieren.

Die Durchführung solche Berechnungen für alle Wörter für jede Trainingsinstanz ist sehr teuer, so dass esunpraktisch ist auf große Vokabulare oder große Trainingskorpusse zu wechseln. Um dieses Problem zulösen wird versucht die Anzahl der Ausgabevektoren zu begrenzen, die pro Trainingsinstanz aktualisiertwerden müssen. Ein eleganter Ansatz dies zu erreichen ist der hierarchische Softmax. Ein anderer An-satz ist das Sampling. Beide Vorschläge werden in den nächsten Abschnitten beschrieben. Beide Tricksoptimieren nur die Berechnung der Aktualisierungen für Output-Vektoren.

Im Paper [15] wurde auf folgenden Punkten Wert gelegt:

1. E, die neue Zielfunktion,

2. die neue Aktualisierungsgleichung für die Ausgangsvektoren ∂E∂v′ω und

3. ∂E∂h , die gewichtete Summe der Prognosefehler, die für die Aktualisierung der Eingangsvektorenrückpropagiert werden sollen.

56


4.3.3 Hierarchisches Softmax

Hierarchisches softmax ist eine effiziente Methode zur Berechnung von Softmax ([16, 17]). Um alleWörter im Vokabular darzustellen verwendet das Model einen binären Baum. Die V-Wörter sind dieBlatteinheiten (units of the tree) des Baumes. Somit gibt es V − 1 innere Einheiten (inner units). Fürjede Blatteinheit gibt es einen eindeutigen Pfad von der Wurzel zur Einheit. Dieser Pfad wird verwendetum die Wahrscheinlichkeit des durch die Blatteinheit dargestellten Wortes zu schätzen. Abbildung 16„Ein exemplarischer Binärbaum für das hierachische softmax-Model.“ [Sei-te 57] stellt einen solchen Baum dar.

n(w2, 1)

n(w2, 2)

n(w2, 3)

w1 w2 w3 w4 wV−1 wV. . .

Abbildung 16: Ein exemplarischer Binärbaum für das hierachische softmax-Model.

Die weißen Einheiten (units) sind Wörter in Vokabular (Dictionary). Die inneren Einheiten (inner units)werden durch dunkle Einheiten repräsentiert. Ein möglicher Pfad von der Wurzel des Baumes zu Wortω2 ist markiert. n(ω, j) steht für die j-te Einheit auf dem Pfad von der Wurzel zum Wort ω. Die Längedes Pfades L(ω2) ist in diesem Beispiel 4.

Im hierarchischen softmax-Model gibt es keine Ausgangsvektordarstellung für Wörter. Stattdessen wirdfür jede V − 1 inner unit ein Ausgangsvektor v′n(ω,j) aufgestellt. Die Wahrscheinlichtkeit, dass ein Wortdas Ausgangswort ist, ist definiert als:

p(ω = ωO) =

L(ω)−1∏j=1

σ([n(ω, j + 1) = ch(n(ω, j))] · v′n(ω,j)Th) (63)

Dabei beschreibt ch(n) das linke Kind der Einheit (unit) n. v′n(ω,j)) ist die Vektordarstellung (outputvector) der inneren Einheit (inner unit) n(ω, j). h ist der Ausgabewert des hidden layers (im skip gram-Model h = vωI und im CBOW h = 1

C

∑Cc=1 vωc). [x] ist eine spezielle Funktion, die folgendermaßen

definiert ist:

[x] =

{1, wenn x true ist−1 sonst

(64)

Mit Hilfe der Abbildung 16 soll die Wahrscheinlichkeit berechnet werden, ob ω2 das Ausgabewort ist.Dieser Wert wird durch ein zufälliges Durchlaufen des Baumes von der Wurzel (root) bis zur Blattein-heit berechnet. Bei jeder inneren Einheit (inner unit), einschließlich der Baumwurzel (root), muss dieWahrscheinlichkeit für nach links oder nach rechts gehen definiert werden.8

8Eine innere Einheit (inner unit) eines binären Baums hat nicht immer beide Kinder. Ein binärer Huffman Baumdagegen schon. Obwohl theoretisch viele unterschiedliche Baumtypen für hierarchisches Softmax verwenden wer-den können, verwendet [14] einen binären Huffman Baum für ein schnelleres Training.

57


Die Wahrscheinlichkeit für nach links gehen bei einem inner unit n ist definiert als:

p(n, left) = σ(v′nT · h) (65)

Diese Wahrscheinlichkeit wird sowohl durch die Vektordarstellung der inner unit als auch durch denAusgabewert der hidden layer bestimmt. Der Ausgabewert der hidden layer wird anschließend durch dieVektordarstellung des/der Eingangsworte(s) bestimmt. Die Wahrscheinlichkeit bei der unit n nach rechtszu gehen ist anscheinend gleich Null, denn:

p(n, right) = 1− σ(v′nT · h) = σ(−v′nT · h) (66)

Indem der Weg in Abbildung 16 von der Wurzel (root) bis zu ω2 durchlaufen wird, kann die Wahrschein-lichkeit berechnet werden, dass ω2 das Ausgabewort ist:

p(ω2 = ωO) = p(n(ω2, 1), left) · p(n(ω2, 2), left) · p(n(ω2, 3), right) (67)

= σ(v′n(ω2,1)Th) · σ(v′n(ω2,2)

Th) · σ(−v′n(ω2,3)Th) (68)

Die letzte Formel ist genau das gleiche, was in Formel (63) gegeben ist. Es ist nicht schwer zu überprüfen,ob:

V∑i=1

p(ωi = ωO) = 1 (69)

Das definiert den hierachischen softmax zu einer gut definierten multinomialen Verteilung auf allen Wör-tern. Nun wird die Parameteraktualisierungsgleichung für die Vektordarstellungen der inneren Einheiten(inner unit) abgeleitet. Der Einfachheit halber wird zunächst das Ein-Wort-Kontextmodel betrachtet. DieErweiterung der Aktualisierungsgleichungen auf CBOW- und skip gram-Modelle ist einfach. Zur Ver-einfachung der Notation werden folgende Abkürzungen definiert, ohne Mehrdeutigkeit einzuführen:

[·] := [n(ω, j + 1) = ch(n(ω, j))] (70)

v′j := v′nω,j (71)

Für eine Trainingsinstanz ist die Fehlerfunktion definiert als

E = − log p(ω = ωO | ωI) = −L(ω)−1∑

j=1

log σ([·]v′jTh) (72)

Das Derivat von E mit Bezug auf v′jh ist dann:

∂E∂v′jh

= (σ([·]v′jTh)− 1) · [·] (73)

=

{σ(v′j

Th)− 1 ,wenn[·] = 1

σ(v′jTh) ,wenn[·] = −1

(74)

= σ(v′jTh)− tj (75)

tj nimmt dabei den Wert 1 an, wenn [·] = 1 ist und ansonsten den Wert 0.

Mit der Ableitung von E mit dem Bezug auf die Vektordarstellung der inneren Einheit (inner unit) n(ω, j)kommt folgendes heraus:

∂E∂v′j

=∂E∂v′jh

·∂v′jh∂v′j

= (σ(v′jTh)− tj) · h (76)

58


Dies führt zu der folgenden Aktualisierungsgleichung:

v′j(new)

= v′j(old) − η(σ(v′jTh)− tj) · h (77)

Diese Formel wird auf j = 1, 2, . . . ,L(ω) − 1 angewendet. σ(v′jTh) − tj kann als Vorhersagefehler für

die Inneneinheit n(ω, j) verstanden werden. Die Aufgabe für jede innere Einheit ist es vorherzusagen, obsie dem linken Kind oder dem rechten Kind im zufälligen Durchlaufen des Baumes folgen soll. tj = 1bedeutet, dass die ground truth dem linken Kind folgt; tj = 0 bedeutet, dass sie dem rechten Kind folgensoll. σ(v′j

Th) repräsentiert das Vorhersageergebnis. Wenn die Vorhersage der inneren Einheit sehr nahean der ground truth liegt, dann bewegt sich ihre Vektordarstellung v′j nur sehr wenig. Andernfalls bewegtsich v′j in eine geeignete Richtung (entweder näher oder weiter weg9 von h), um den Vorhersagefehlerfür diesen Fall zu reduzieren. Diese Aktualisierungsgleichung kann sowohl für CBOW als auch für dasskip gram-Model verwendet werden. Bei Verwendung für das skip gram-Model muss dieser Aktualisie-rungsvorgang für jedes der C-Wörter im Ausgabekontext wiederholt werden.Um den Fehler, der beim Lernen der input→ hidden Gewichte entsteht, rückwärts zu propagieren (back-propagate), wird die Ableitung von E mit Bezug auf die Ausgabe der hidden layer genommen und manerhält:

∂E∂h

=

L(ω)−1∑j=1

∂E∂v′jh

·∂v′jh∂h

(78)

=

L(ω)−1∑j=1

(σ(v′jTh)− tj) · v′j (79)

:= EH (80)

Diese Formel kann direkt in Formel (49) substituiert werden, um die Aktualisierungsgleichung für dieEingangsvektoren von CBOW zu erhalten. Für das skip gram-Model muss für jedes Wort im Skip-Gramm-Kontext ein EH-Wert berechnet werden. Die Summe der EH-Werte muss dann in Formel (61)einfügt werden, um die Aktualisierungsgleichung für den Eingangsvektor zu erhalten.

Aus den Aktualisierungsgleichungen ist ersichtlich, dass die Rechenkomplexität pro Trainingsinstanzund Kontextwort von O(V) auf O(log(V)) reduziert wird. Dies bedeutet eine große Verbesserung derGeschwindigkeit. Die Anzahl an Parametern ist ungefähr gleich geblieben (V − 1 Vektoren für die In-neneinheiten im Vergleich zu den ursprünglichen V-Ausgabevektoren für Wörter).

4.3.4 Negative Sampling

Um die Anzahl der Ausgangsvektoren, die pro Iteration aktualisiert werden müssen, zu minimieren,wird beim negative sampling nur ein Abtastwert (sample) pro Iteration aktualisiert. Das Ausgabewort(entweder ein ground truth oder ein positive sample) sollte in der Probe aufbewahrt werden und aktuali-siert werden. Zusätzlich werden einige Wörter als negative samples („negative Probenahme“) benötigt.Für den Stichprobenprozess ist eine beliebig gewählte, probabilistische Verteilung erforderlich. DieseVerteilung wird in der Literatur [15] noise destribution (Rauschverteilung) genannt und wird zu Pn(ω)formalisiert. Die Autoren von [14] argumentieren, dass das folgende vereinfachte Trainingsziel in der La-ge ist, qualitativ hochwertige Worteinbettungen zu erzeugen, anstatt eine Form der negativen Abtastungzu verwenden, die eine gut definierte posteriore multinomiale Verteilung erzeugt:

E = − log σ(v′ωOTh)−

∑ωi∈Wneg

log σ(−v′ωiTh) (81)

9Auch hier ist die Abstandsmessung das innere Produkt.

59


In der Formel 81 steht ωO für das Ausgangswort (d.h. die positive Probe [positive sample]). v′ωO istdessen Ausgabevektor. h ist der Ausgabewert des hidden layers: h = 1

C

∑Cc=1 vωc im CBOW–Model und

h = vωI im skip gram Model.Wneg = {ωi | i = 1, . . . ,K} ist die Menge der Wörter, die basierend aufPn(ω) abgetastet werden und somit die negativen Samples sind.

Um die Aktualisierungsgleichungen der Wortvektoren unter negative sampling zu erhalten, wird dieAbleitung von E in Bezug auf den Netzeingang der Ausgabeeinheit ωj folgendermaßen verändert:

∂E∂v′ωj

Th=

{σ(v′ωj

Th)− 1 , wenn ωj = ωO

σ(v′ωjTh) , wenn ωj ∈ Wneg

(82)

= σ(v′ωjTh)− tj (83)

In der Formel 83 ist tj das „Label“ des Wortes ωj. t = 1, wenn ωj ein positiv sample ist und ansonsten istt = 0.

Als nächstes wird die Ableitung von E in Bezug auf den Ausgangsvektor des Wortes ωj verändert:

∂E∂v′ωj

=∂E

v′ωjTh·∂v′ωj

Th∂v′ωj

= (σ(v′ωjTh)− tj)h (84)

Dies führt zur folgenden Aktualisierungsgleichung für ihren Ausgangsvektor:

v′ωj(new)

= v′ωj(old) − η(σ(v′ωj

Th)− tj)h (85)

Diese Formel 85 muss nur auf ωj ∈ {ωO} ∪ Wneg anstelle von jedem Wort im Vokabular angewendetwerden. Um den Fehler auf dem hidden layer zurückzuverlagern und so die Eingabevektoren von Wör-tern zu aktualisieren, muss die Ableitung von E in Bezug auf die Ausgabe des hidden layers verwendetwerden, um folgendes zu erhalten:

∂E∂h

=∑

ωj∈{ωO}∪Wtextneg

∂E∂v′ωj

Th·∂v′ωj

Th∂h

(86)

.

=∑

ωj∈{ωO}∪Wtextneg

(σ(v′ωjTh)− tj)v′ωj := EH (87)

Die Aktualisierungsgleichung für die Eingangsvektoren des CBOW–Modells ist durch Einsetzen vonEH in die Formel 49 gegeben. Für das CBOW–Model muss für jedes Wort des skip gram Kontextes einEH–Wert berechnet werden. Um die Aktualisierungsgleichung für den Eingangsvektor zu erhalten mussanschließend die Summe der EH–Werte in die Formel 61 eingefügt werden.

60

5 REALISIERUNG VOM BOOLEAN RETRIEVAL–, FUZZY LOGIC– UNDALEXA–ÄQUIVALENTES–MODEL

5 Realisierung vom Boolean Retrieval–, Fuzzy Logic– undAlexa–Äquivalentes–Model

Die Module Boolean Retrieval System, Fuzzy Logic und Alexa–Model wurden als Konsolenanwendungin der Programmiersprache C# Version 7 entwickelt. Als Software-Plattform wurde das .NET Framework4.5.2 verwendet. Kompiliert und getestet wurde auf einem PC mit einem 3,5 GHz Quad-Core Intel Corei5-7600 mit 16 Gigabyte DDR4-2133 CL15 RAM unter Microsoft Windows 10 Education (64-bit).

5.1 Entwurfsmuster MVC

Die Anwendung SPRInterpretationTool wurde mit dem MVC–Pattern (Model–View–Controller) reali-siert. Die Ziele des MVC–Patterns ist eine lose Koppelung vom UI-Design (Benutzeroberfläche) und derUI-Logik (Event Handler & Co.). Ziel des Musters ist ein flexibler Programmentwurf, der eine späte-re Änderung oder Erweiterung erleichtert und eine Wiederverwendbarkeit der einzelnen Komponentenermöglicht. Das MVC-Pattern basiert auf drei Komponenten:

• Model

• View

• Controller

ModelDas Model enthält die gesamte Geschäftslogik und ist durch Unit Tests für sich alleine überprüfbar. Esbenachrichtigt den Controller über Datenänderungen und stellt die Daten für die View bereit.

ViewDie View ist für die Darstellung der Daten des Modells und die Realisierung der Benutzerinteraktionenzuständig. Sie kennt das Modell, dessen Daten sie präsentiert, ist aber nicht für die Verarbeitung dieserDaten zuständig. Des Weiteren ist sie vom Controller unabhängig.

ControllerDer Controller verwaltet die View und das Modell. Er wird von der View über Benutzerinteraktioneninformiert, wertet diese aus und nimmt daraufhin Anpassungen an der View sowie Änderungen an denDaten im Modell vor.

View

Controller

Model

Abbildung 17: Model–View–Controller–Konzept

In Abbildung 17 ist das Konzept des Entwurfsmusters MVC dargestellt. Die durchgezogene Linie sym-bolisiert eine direkte Assoziation. Eine indirekte Assoziation wird durch eine gestrichelte Linie darge-stellt (zum Beispiel über einen Beobachter [Observer]).

61


5.2 Struktur der Datenbasis

In dieser Masterarbeit wurden die Kommandos, die dem Interpretationssystem bekannt sind, in einerMicrosoft SQL Datenbank gespeichert. Ein relationales Datenbanksystem zur elektronischen Datenver-waltung hat den Vorteil des effizienten Speicherns von großen Datenmengen und des Zugreifens darauf.Durch die im letzten Kapitel beschriebenen Erkenntnisse ergibt sich folgende Struktur der Datenbankta-bellen:

Device

ID_Device int Nein

Description nvarchar(MAX) Nein

Spaltenname Datentyp NULL zulassen

Interaction

ID_Interaction int Nein



Location

ID_Location int Nein



Instruction

ID_Instruction int Nein

Device_ID int Nein

Location_ID int Ja

Interaction_ID int Nein


ExecutableInstruction

ID_ExecutableInstruction int Nein

Instruction_ID int Nein

Command ntext Nein


Abbildung 18: Struktur der Datenbanktabellen

Die wichtigste Tabelle ist Instruction. Jeder Datensatz dieser Tabelle steht für eine Aktion, diedas Gerätesteuerungssystem ausführen kann. Der Datensatz besteht minimal aus einem Gerät und einerZustandsänderung (Interaction). Optional kann ein Verweis auf einen Ort ergänzt werden. Geräte,die in der Steuerung nur einmal vorkommen und somit keinen Ort haben, werden mit NULL in der SpalteLocation_ID definiert. Durch diese Tabelle ist es möglich

• alle Aktionen, die das Gerätesteuerungssytems kann,

• alle Geräte des Gerätesteuerungssytems

• alle Geräte zu einem bestimmten Ort

• alle Geräte mit einer bestimmten Zustandsänderung

abzufragen.

Mit der Tabelle ExecutableInstruction können alle zu einer Instruction zugeordneten Komman-dos abgefragt werden. In der Tabelle Devicewerden alle Geräte persistiert. Location enthält die Orteund die Zustandsänderungen werden in der Tabelle Interaction gespeichert. Alle drei Tabellen sindnach dem gleichem Schema aufgebaut. Sie enthalten eine eindeutige Nummer und eine Beschreibung.

62


5.3 Datenbank–Schicht

Als elektronischen Datenverwaltung für die drei Modelle Boolean Retrieval, Fuzzy Logic und Alexa–Äquivalentem wurde bei dieser Masterarbeit eine Microsoft SQL Server Express (64–bit) DatenbankVersion 13.0.4224.16 verwendet. In Kapitel 5.2 „Struktur der Datenbasis“ [Seite 62] wurdebereits die Struktur der Datenbank beschrieben. In diesem Kapitel wird die Schnittstelle zwischen derAnwendung SPRInterpretationTool und der Datenbank erläutert. Alle Datenbankabfragen, –zugriffe und–einstellungen sind im Namespace DataProvider des SPRInterpretationTool–Projektes abgelegt.

1 public interface IConnectionString2 {3 string ConnectionString { get; }4 }5

6 public class ConnectionStringDBHome : IConnectionString7 {8 public string ConnectionString => "Data Source=localhost\\SQLLIVE;Initial

Catalog=SPRHome;Persist Security Info=True;User ID=spr;Password=spr";9 }

Listing 3: Klasse ConnectionStringDBHome und Interface IConnectionString

Die Klasse ConnectionStringDBHome muss die Propertie ConnectionString initialisieren,da sie vom Interface IConnectionString ableitet. In dieser Propertie steht der Verbindungsangabenzur Datenbank.

1 public static class DBConnection2 {3 public static ConnectionDataProviderBase ConnectionDB { get; }4

5 /// <summary>6 /// Setzt den entsprechenden Datenbank-Verbindung-String je nach Modus der

Preprozessor-Variable (RELEASE = PUBLISH && !DEBUG)7 /// </summary>8 static DBConnection()9 {

10 #if (!DEBUG)11

12 // LIVE13 ConnectionDB = new ConnectionDataProviderBase(new ConnectionStringSPRHome());14

15 #else16 // DEBUG17 ConnectionDB = new ConnectionDataProviderBase(new ConnectionStringDBHome());18 #endif19

20 }21 }

Listing 4: Klasse DBConnection

In der Klasse DBConnection wird die Propertie ConnectionDB mit der Datenbankverbindung ge-füllt, die verwendet werden soll. D.h. soll eine andere Datenbank verwendet werden, muss eine neueKlasse erstellt werden. Diese neue Klasse muss vom Interface IConnectionString ableiten. Zu-sätzlich muss in der Klasse DBConnection die Propertie ConnectionDB auf diese neue Klassegesetzt werden.

63


Alle Daten aus der Datenbank werden mit, in der Datenbank abgelegten, Store Procedures abgefragt. JedeStore–Procedure–Abfrage wird über die Klasse ConnectionDataProviderBase getätigt. Dieseenthält neben der aktuell aufgebauten Verbindung zur Datenbank auch alle Methoden zum Abfragen vonStore–Procedures.

ConnectionDataProviderBase

- SqlConnection: System.Data.SqlClient.SqlConnection

+ ConnectionDataProviderBase(connString: IConnectionString)+ ExecuteStoredProcedure(prozedur: string, parameters: Dictionary<string, object>, returnsID: bool): int+ ExecuteStoredProcedure(prozedur: string, parameter: string, paraValue: object): int+ GetRowFromStoredProcedure(prozedur: string, parameters: Dictionary<string, object>): System.Data.DataRow+ GetRowFromStoredProcedure(prozedur: string): System.Data.DataRow+ GetRowFromStoredProcedure(prozedur string, parameter: string, paraValue: object): System.Data.DataRow+ GetValueFromStoredProcedure(prozedur: string, parameters: Dictionary<string, object>): object+ GetValueFromStoredProcedure(prozedur: string, parameter: string, paraValue: object): object+ GetValueFromStoredProcedure(prozedur: string): object+ GetTableFromStoredProcedure(prozedur: string): System.Data.DataTable+ GetTableFromStoredProcedure(prozedur: string, parameter: string, paraValue:object): System.Data.DataTable+ GetTableFromStoredProcedure(prozedur: string, parameters: Dictionary<string, object>): System.Data.DataTable- GetDBParameter(parameterValue: object): object- SetDBParameterWithValue(com: System.Data.SqlClient.SqlCommand, key: string, value: object): void

- System.Data.DataRow ReturnDataRow(string prozedur, Dictionary<string, object> parameters, System.Data.DataTable dt)

Abbildung 19: UML Diagramm der Klasse ConnectionDataProviderBase

Wie das UML–Diagramm 19 zeigt, enthält diese Klasse Methoden zum Ausführen von Store–Procedures, die:

• ein SQL–Insert oder –Delete ausführen (ExecuteStoredProcedure)

• ein SQL–Get ausführen und einen Wert zurückgeben (GetValueFromStoreProcedure)

• ein SQL–Get ausführen und einen Datensatz (DataRow) zurückgeben (GetRowFromStoredPro-cedure)

• ein SQL–Get ausführen und mehrere Datensätze (DataTable) zurückgeben (GetTableFromStored-Procedure)

Da jede dieser Methoden unterschiedliche Parameter annehmen kann, können alle möglichen Arten vonStore–Procedures aufgerufen werden.

Neben diesen Hilfsklassen enthält die Datenbank–Schicht der Anwendung Database–Klassen, welchedie Store–Procedures zu einer Thematik bündeln. Jeder dieser Klassen ist statisch und enthält somit nuröffentliche statische Methoden.

64


1 public static class DeviceDatabase2 {3 public static List<Model.Device> GetAllDevices()4 {5 List<Model.Device> devices = new List<Model.Device>();6

7 DataTable dt =DBConnection.ConnectionDB.GetTableFromStoredProcedure("sp_GetDevices");

8 foreach (DataRow row in dt.Rows)9 {

10 devices.Add(new Model.Device(row));11 }12

13 return devices;14 }15 }

Listing 5: Klasse DeviceDatabase

Eine dieser Klassen ist DeviceDatabase. Diese enthält nur die statische Methode GetAllDevices,die alle Devices aus der Datenbank zurückgeben soll. Deswegen ist der Rückgabewert dieser Methodeeine Liste aus Devices. In Zeile 7 wird mit Hilfe der Methode GetTableFromStoredProcedureaus der Klasse ConnectionDataProviderBase die Store–Procedure sp_GetDevices aufgerufen.Die Procedure liefert mehrere Datensätze, weshalb die Methode GetTableFromStoredProcedureverwendet werden muss. In den Zeilen 8–11 wird aus den Datenbank–Datensätzen neue Device–Objekteerstellt und in der Rückgabeliste devices hinzugefügt. In Zeile 13 werden alle von der Datenbankgefundenen und in Device–Objekt verwandelte Datensätze zurückgegeben. In Zeile 10 wird der Kon-struktor von der Klasse Device aufgerufen, welcher einen Übergabeparameter des Types DataRowentgegennimmt, aufgerufen.

1 using DB = SPRInterpretationTool.DataProvider.Database.DatabaseColumnConverter;2

3 public class Device4 {5 public Device(DataRow dr)6 {7 ID = DB.GetDBColumnValueAsInt(dr, "ID_Device");8 Description = DB.GetDBColumnValueAsString(dr, "Description");9 }

10

11 public int ID { get; private set; }12 public string Description { get; private set; }13 }

Listing 6: Klasse Device

Die Klasse Device ist wie in Codeabbildung 6 aufgebaut. Der aus der Datenbank stammende Daten-satz dr wird dem Konstruktor übergeben (Zeile 3). Im Konstruktor werden die Properties der Klassemit den Werten aus diesem Datensatz gefüllt. Jeder Datensatz aus der Datenbank besteht aus min-destens einer Spalte. In diesem Beispiel wird die ID des Devices aus der Spalte ID_Device gelesen.Aus der Spalte Description wird die Propertie Description des Device–Objektes gefüllt. Die mei-sten Klassen, welche die Datensätze in C#–Objekte umwandeln, sind nach diesem Schema aufgebaut.Für die Konvertierung der Datenbank–Einträgen zu den Properties der Klassen wurde die HilfsklasseDatabaseColumnConverter implementiert.

65


1 public static class DatabaseColumnConverter2 {3 public static int GetDBColumnValueAsInt(DataRow dr, string spaltenName)4 {5 object value = GetDBColumnValue(dr, spaltenName);6 return value == null ? int.MinValue : Convert.ToInt32(value);7 }8

9 public static double GetDBColumnValueAsDouble(DataRow dr, string spaltenName)10 {11 object value = GetDBColumnValue(dr, spaltenName);12 return value == null ? double.NaN : Convert.ToDouble(value);13 }14

15 public static string GetDBColumnValueAsString(DataRow dr, string spaltenName)16 {17 object value = GetDBColumnValue(dr, spaltenName);18 return value == null ? string.Empty : value.ToString().Trim();19 }20

21 public static DateTime GetDBColumnValueAsDateTime(DataRow dr, string spaltenName)22 {23 object value = GetDBColumnValue(dr, spaltenName);24 return value == null ? new DateTime(0) : Convert.ToDateTime(value);25 }26

27 public static bool GetDBColumnValueAsBoolean(DataRow dr, string spaltenName)28 {29 object value = GetDBColumnValue(dr, spaltenName);30 return value == null ? false : Convert.ToBoolean(value);31 }32

33 private static object GetDBColumnValue(DataRow dr, string spaltenName)34 {35 if (dr.Table.Columns.Contains(spaltenName))36 {37 if (dr.IsNull(spaltenName) == false)38 {39 return dr[spaltenName];40 }41 else42 {43 return null;44 }45 }46 else47 {48 return null;49 }50 }51 }

Listing 7: Klasse DatabaseColumnConverter

Zu den üblichen Grunddatentypen, die in C# verwendet werden können, wurde eine statische Methodegeschrieben. Diese konvertieren den Wert in der übergebenen Spalte des Datensatzes in diesen Daten-typ um und geben diesen wieder. Dabei ist jeder dieser Methoden nach dem selben Schema aufgebaut.Es wird die Hilfsmethode GetDBColumnValue mit dem übergebenen Datensatz und dem Spalten-namen aufgerufen. In dieser Methode wird versucht, diesen Wert aus dieser Datenbank–Spalte auszu-lesen. Anschließend wird der Wert in den entsprechenden Datentyp zu konvertieren. Wurde die Spalteim Datensatz nicht gefunden oder die Konvertierung schlägt fehl, wird der Default–Wert des Datentypszurückgegeben. Ansonsten wird der Wert im gewünschten Datentyp returniert.

66


5.4 Initialisierung der Daten aus der Datenbank

Alle drei Modelle verwenden die selbe Datenbasis für ihre Algorithmen. Als Datenbasis benötigen dieModelle alle Aktionen der Gerätesteuerung. Zusätzlich wird der inverted index generiert und die Oga-wawerte für alle Dokumente berechnet. Durch die Initialisierung beim Start der Anwendung ist gewähr-leistet, dass diese Daten den Modellen zur Verfügung stehen. Ein wesentlicher Vorteil der Berechnungwährend der Initialisierung ist, dass die Generierung und Abfrage der Daten nur einmal statt findet. AlleInitialisierungsschritte werden durch die Klasse InitDataManager durchgeführt.

1 public class InitDataManager2 {3 public InitDataManager(bool doNormalize)4 {5 InitDatabaseData();6 InitRetrievalSystem(doNormalize);7 }8

9 #region Properties10 private List<Model.Instruction> Instructions;11 public Dictionary<string, List<int>> InvertedIndex { get; private set; }12 public List<Model.OgawaItem> OgawaListe { get; private set; }13 #endregion Properties14 }

Listing 8: Konstruktor und Properties der Klasse InitDataManager

In der Codeabbildung 8 ist der Konstruktor der Klasse InitDataManager zu sehen. Dieser führt alserstes eine Methode mit der Bezeichnung InitDatabaseData aus. Diese Methode ist in 9 abgebildet.

1 private List<Model.Instruction> Instructions;2

3 private void InitDatabaseData()4 {5 Instructions = DataProvider.Database.InstructionDatabase.GetInstructions();6 }

Listing 9: Methode InitDatabaseData

Die Methode InitDatabaseData fragt die Datenbank–Schicht nach allen Aktionen. Die von derDatenbank zurückgelieferte Liste wird in die private Propertie Instructions geschrieben. Die auf-gerufene Methode GetInstructions aus der Datenbank–Schicht ist in 10 dargestellt.

1 public static List<Instruction> GetInstructions()2 {3 DataTable dataTable = DBConnection.ConnectionDB.4 GetTableFromStoredProcedure("sp_GetInstructions");5

6 List<Model.Instruction> instructions = new List<Model.Instruction>();7 foreach (DataRow row in dataTable.Rows)8 {9 instructions.Add(new Model.Instruction(row));

10 }11

12 return instructions;13 }

Listing 10: Methode GetInstructions

67


Da alle Datenbankanfragen keine besonderen Properties benötigen, sind alle Klassen aus der Datenbank–Schicht und deren Methoden statisch. Die Methode GetInstructions ist in der Datenbank–Klasse InstructionDatabase implementiert. Mit Hilfe der aufgebauten DatenbankverbindungDBConnection.ConnectionDB wird die Store Procedure sp_GetInstructions aufgerufen. Die zu-rückgegebene Datenbanktabelle wird Datensatzweise durchlaufen. Zu jedem Datensatz wird ein neu-es Instruction–Objekt in die Liste instructions hinzugefügt. Somit liefert die MethodeGetInstructions am Ende eine Liste von allen in der Datenbank stehenden Instructions zurück.

5.5 Initialisierung des Retrieval Systems

Nachdem die Methode InitDatabaseData im Konstruktor ausgeführt wurde, wird die MethodeInitRetrievalSystem gestartet.

1 private void InitRetrievalSystem(bool doNormalize)2 {3 CreateInvertedIndex(doNormalize);4 Model.FuzzyLogicManager fuzzyLogicManager = new

Model.FuzzyLogicManager(this.InvertedIndex);5 OgawaListe = fuzzyLogicManager.CalcOgawa();6 }

Listing 11: Methode InitRetrievalSystem

5.5.1 Inverted Index erstellen

1 private void CreateInvertedIndex(bool doNormalize)2 {3 InvertedIndex = new Dictionary<string, List<int>>();4

5 foreach (Model.Instruction instruction in Instructions)6 {7 foreach (Model.ExecutableInstruction executableInstruction in

instruction.ExecutableInstructions)8 {9 string[] terms = executableInstruction.GetTerms();

10

11 if (doNormalize)12 {13 terms = Normalize(terms);14 }15

16 foreach (string term in terms)17 {18 AddItemToInvertedIndex(term, executableInstruction.ID);19 }20 }21 }22 }23

24 private string[] Normalize(string[] terms)25 {26 List<string> normalizedTerms = new List<string>();27 Model.GermanStemmingAlgorithm gsa = new Model.GermanStemmingAlgorithm();28

29 foreach (string term in terms)30 {31 normalizedTerms.Add(gsa.Stemming(term));32 }33

34 return normalizedTerms.ToArray();

68


35 }36

37 private void AddItemToInvertedIndex(string term, int id)38 {39 if (!InvertedIndex.ContainsKey(term))40 {41 InvertedIndex.Add(term, new List<int>() { id });42 }43 else44 {45 if (!InvertedIndex[term].Contains(id))46 {47 InvertedIndex[term].Add(id);48 }49 else50 {51 // do nothing -> ExecutableInstruction-ID bereits in der Liste enthalten52 }53 }54 }

Listing 12: Methoden zum Erstellen des inverted index

Theoretisch wurde der inverted index bereits auf Seite 24 erläutert. Implementiert wurde die Erstel-lung des inverted indexes in der Methode CreateInvertedIndex. Diese Methode wird von derMethode InitRetrievalSystem gestartet. Die Anwendung hat die Möglichkeit die Modelle aufeinem normalisierten Datensatz oder auf dem unveränderten Datensatz laufen zu lassen. Welche Vari-ante durchgeführt wird, wird durch den übergebenen booleschen Parameter doNormalize bestimmt.Dieser Parameter wird dem Konstruktor übergeben. Danach wird dieser Parameter bis zu dieser Methodedurchgereicht. Verwendet wird dieser Parameter in der Methode CreateInvertedIndex. In dieserMethode werden aus jedem möglichem Kommando (Zeile 5) alle Terme extrahiert (Zeile 7).

1 public string[] GetTerms()2 {3 string command = Command.ToLower();4 string[] terms = command.Split(’ ’);5 return terms;6 }

Listing 13: Methode GetTerms

Um die Terme zu extrahieren wird die Methode GetTerms von jeder ExecutableInstruction–Instanz aufgerufen. In dieser Methode wird das Kommando in Kleinbuchstaben konvertiert, damitgrammatikalische Veränderungen und unterschiedliche Anwendereingaben keine Auswirkungen ha-ben. Anschließend wird dieses Kommando nach Leerzeichen getrennt, sodass ein Array bestehend ausden einzelnen Wörtern entsteht. Dieses wird zum Schluss zurückgegeben. In Zeile 11 der MethodeCreateInvertedIndex findet die Prüfung statt, ob das gerade zurückgelieferte Wörter–Array nor-malisiert werden soll. Nur bei positiver Prüfung wird die Methode Normalize mit dem Wörter–Arrayausgeführt. In dieser Methode wird auf allen Wörtern aus dem Array der German Stemming Algorithmusausgeführt. In den letzten Zeilen der Methode CreateInvertedIndex (16–19) wird der inverted in-dex aufgebaut.

69


1 public Dictionary<string, List<int>> InvertedIndex { get; private set; }

Listing 14: Inverted Index

Der inverted index wurde als öffentliche Propertie der statischen Klasse InitDataManager deklariert.Das Setzen der Propertie ist auf die Klasse beschränkt. Als Datentyp wurde ein Dictionary verwendet. EinDictionary enthält mehrere Einträge. Jeder der Einträge besteht aus einem eindeutigem Key und einemValue. Beim inverted index repräsentiert der Term den Key. Die Liste der Kommandos, welche diesenTerm enthalten, werden durch den Value–Eintrag beschrieben. Zu jedem (möglicherweise normalisier-ten) Term des aktuellen Kommandos wird die Methode AddItemToInvertedIndex aufgerufen. Inder Methode AddItemToInvertedIndex 68 (Zeile 37–54) wird jeder Term dem InvertedIndex hinzu-gefügt, der noch nicht in diesem enthalten ist (Zeile 39–42). Ansonsten wird nur die eindeutige Nummerdes Kommandos (id) dem Inverted Index hinzugefügt, solange diese noch nicht für den aktuellenTerm gespeichert wurde. Nachdem die Methode CreateInvertedIndex durchlaufen wurde, ist diePropertie InvertedIndex gefüllt.

5.5.2 Implementierung des German Stemming Algorithmus

Wie bereits erwähnt wird zu jedem Term der German Stemming Algorithmus aufgerufen, wenn derParameter doNormalize auf true gesetzt wurde. Eine theoretische Beschreibung erfolgte be-reits in Kapitel 4.1.7 „Token-Normalisierung“ [Seite 33]. Der Algorithmus ist in der KlasseGermanStemmingAlgorithm implementiert. Diese Klasse ist nicht statisch. Aus diesem Grund wirdals erstes der Konstruktor der Klasse aufgerufen.

1 public GermanStemmingAlgorithm(List<char> vowels = null, List<char> valid_s_endings =null, List<char> valid_st_endings = null)

2 {3 Vowels = vowels ?? Vowels;4 Valid_s_endings = valid_s_endings ?? Valid_s_endings;5 Valid_st_endings = valid_st_endings ?? Valid_st_endings;6

7 R1Index = -1;8 R2Index = -1;9 }

10

11 #region Properties12 private readonly List<char> Vowels = new List<char>() { ’a’, ’e’, ’i’, ’o’, ’u’, ’y’,

’ä’, ’ö’, ’ü’ };13 private readonly List<char> Valid_s_endings = new List<char>() { ’b’, ’d’, ’f’, ’g’, ’h’,

’k’, ’l’, ’m’, ’n’, ’r’, ’t’ };14 private readonly List<char> Valid_st_endings = new List<char>() { ’b’, ’d’, ’f’, ’g’,

’h’, ’k’, ’l’, ’m’, ’n’, ’t’ };15 private string BaseTerm { get; set; }16 private string OrgTerm { get; set; }17 private int R1Index { get; set; }18 private int R2Index { get; set; }19 #endregion Properties

Listing 15: Konstruktor und Properties der Klasse GermanStemmingAlgorithm

Standardmäßig muss dem Konstruktor der Klasse GermanStemmingAlgorithm nichts übergebenwerden. In diesem Fall werden die vordefinierten Listen für Vokale, erlaubte–s–Endungen und erlaubte–st–Endungen verwendet. Diese sind als private Properties in der Klasse enthalten. Sollte der KonstruktorParameter erhalten, werden diese übergebenen Listen verwendet. Weiterhin wird im Konstruktor dieBereichsdefinition R1 und R2 mit Defaultwerten initialisiert.

70


1 public string Stemming(string term)2 {3 term = term.Replace("ß", "ss");4

5 term = ReplaceCharacterBetweenVowels(term, ’u’);6 term = ReplaceCharacterBetweenVowels(term, ’y’);7

8 OrgTerm = term;9 BaseTerm = term;

10

11 DefineR1AndR2(term);12

13 if (R1Index < 3 && R1Index >= 0)14 {15 R1Index = 3;16 }17

18 string r1Term = RefreshRTerm(R1Index);19 string termAfterStep1 = DoStep1(BaseTerm, r1Term);20

21 string r1TermS2 = RefreshRTerm(R1Index);22 string termAfterStep2 = DoStep2(termAfterStep1, r1TermS2);23

24 string termAfterStep3 = DoStep3(termAfterStep2);25

26 string stemmerTerm = DoFinallyStep(termAfterStep3);27

28 return stemmerTerm;29 }

Listing 16: Methode Stemming

Von der Klasse GermanStemmingAlgorithm ist nur die Methode Stemming von außen auf-rufbar. Als Parameter erhält die Methode den Term, auf den die Normalisierung ausgeführt wird. InZeile 3 wird die von C# mitgelieferte String–Methode Replace verwendet. Diese gibt eine neue Zei-chenfolge zurück, in der alle Vorkommen des ersten Parameters in der aktuellen Instanz durch denzweiten Parameter ersetzt wurden. In diesem Fall wird jedes „ß“ im term durch die Buchstabenfol-ge „ss“ ersetzt werden. Anschließend werden in Zeile 5 und 6 die Buchstaben „u“ und „y“ im termgroß geschrieben, wenn diese Buchstaben zwischen zwei Vokalen definiert sind. Dazu wird die Me-thode ReplaceCharacterBetweenVowels verwendet. In Zeile 11 wird mit Hilfe der MethodeDefineR1AndR2 die beiden Bereichsdefinitonen gesetzt. Die beiden Bereichsdefinitionen sind Pro-perties von der Klasse GermanStemmingAlgorithm. Gepeichert wird jeweils der Index, ab dem derBereich beginnt. Nachdem diese gesetzt wurden, wird in Zeile 13 überprüft, ob die BereichsdefinitionR1 auf einen der ersten drei Buchstaben steht. Wenn dies der Fall ist, wird R1 auf den vierten Buch-staben gesetzt. Nach Zeile 16 ist die Vorbereitung für den German Stemming Algorithmus abgearbeitetund die drei Schritte des Algorithmus werden ausgeführt. Um Schritt 1 auszuführen, wird vorher dieBereichsdefinition R1 bildet (Zeile 18). Der mögliche veränderte Term nach Schritt 1 wird in die Varia-ble termAfterStep1 gespeichert. In Zeile 21 wird der Teilstring auf den möglich veränderten Termaus Schritt 1 gebildet, den Bereichsdefinition R1 nun bildet. Nachdem Schritt 3 in Zeile 24 abgearbeitetwurde, werden in Zeile 26 die Nacharbeiten in der Methode DoFinallyStep ausgeführt. Als letzterSchritt wird der möglicherweise normalisierte Term zurückgegeben.

71


1 private string ReplaceCharacterBetweenVowels(string term, char c)2 {3 char[] resultString = new char[term.Length];4 resultString[0] = term[0];5 for (int i = 1; i < term.Length - 1; i++)6 {7 if (term[i] == c)8 {9 if (Vowels.Contains(term[i - 1]) && Vowels.Contains(term[i + 1]))

10 {11 resultString[i] = ToUpper(c);12 continue;13 }14 }15 resultString[i] = term[i];16 }17 resultString[term.Length - 1] = term[term.Length - 1];18 return new string(resultString);19 }

Listing 17: Methode ReplaceCharacterBetweenVowels

Die Methode ReplaceCharacterBetweenVowels soll in dem Term term den Buchstaben c inein Großbuchstaben konvertieren, wenn dieser zwischen zwei Vokalen steht. In C# sind Strings immuta-ble. D.h. ein initialisierter String kann nicht verändert werden. Aus diesem Grund wird eine temporäreVariable resultString definiert. Diese hat den Typ char–Array. Diese temporäre Variable ist ge-nauso lang wie der übergebene Term (Zeile 3). Dadurch, dass der erste Buchstabe niemals zwischenzwei Vokalen stehen kann, wird dieser immer dem Ergebnis resultString hinzugefügt (Zeile 4).Anschließend wird eine for–Schleife ab dem zweiten Buchstaben des Terms bis zum vorletzten Buchsta-ben durchlaufen. In dieser Schleife wird nach dem Buchstaben gesucht, der in der Variable c steht (Zeile7). Wenn die Bedingung zutrifft, wird kontrolliert, ob der Buchstabe vor und hinter dem aktuellen Buch-staben jeweils ein Vokal ist (Zeile 9). Mit Hilfe der Contains–Methode wird geprüft, ob der Buchstabe inder Liste der Vokale enthalten ist. Nur wenn beide Buchstaben in der Vokalenliste enthalten sind, wirdder aktuelle Buchstabe durch die ToUpper–Methode in einen Großbuchstaben konvertiert und an dierichtige Stelle im resultString geschrieben. Danach wird der Schleifendurchlauf für diesen Buch-staben beendet. Sollte der aktuelle Buchstabe nicht der Buchstabe sein, der in der Variable c steht, odereiner der beiden Nachbarbuchstaben befindet sich nicht in der Vokalenliste, wird dieser aktuelle Buchsta-be an die richtige Stelle des resultString geschrieben (Zeile 15). Nachdem der vorletzte Buchstabedes Terms durchlaufen wurde, wird der letzte Buchstabe dem resultString hinzugefügt (Zeile 17).Auch der letzte Buchstabe kann niemals zwischen zwei Vokalen stehen, sodass diese Sonderbedingungprogrammiert wurde. In Zeile 18 wird der resultString in den Datentyp string konvertiert undzurückgegeben.

1 public static char ToUpper(char c)2 {3 if ((int)’a’ <= (int)c && (int)’z’ >= (int)c)4 {5 return (char)(c - (’a’ - ’A’));6 }7 if (c == ’ä’) { return ’Ä’; }8 if (c == ’ö’) { return ’Ö’; }9 if (c == ’ü’) { return ’Ü’; }

10 return c;11 }

Listing 18: Methode ToUpper

72


Die Methode ToUpper konvertiert den Buchstaben, welcher als Parameter in der Variable c steht, in einGroßbuchstaben und gibt diesen zurück. Mit Hilfe des ASCII-Wertes der Buchstaben wird diese Kon-vertierung durchgeführt. In Zeile 3 wird überprüft, ob der übergebene Buchstabe ein Kleinbuchstabe ist.Jeder Buchstabe wird durch einen ASCII–Wert, welcher eine Zahl ist, dargestellt. Die Kleinbuchstabensind im Bereich von 97 (a) bis 122 (z) definiert. Somit wird in Zeile 3 kontrolliert, ob der ASCII–Wertvom übergebenen Buchstabe zwischen 96 und 123 liegt. Ist dies der Fall, wird der übergebene Buchstabein sein Großbuchstaben konvertiert und zurückgegeben. Die Großbuchstaben sind im Bereich von 65 (A)bis 90 (Z) angesiedelt. Soll ein Kleinbuchstabe in seinen Großbuchstaben konvertiert werden, muss nurdie Differenz zwischen den Klein– und Großbuchstaben vom Kleinbuchstaben abgezogen werden. DieKonvertierung der Umlaute findet einfachheitshalber hart kodiert im Programm statt (Zeile 27–29).

1 private void DefineR1AndR2(string term)2 {3 R1Index = DefineR(term, 0);4

5 if (R1Index == -1)6 {7 R2Index = -1;8 }9 else

10 {11 R2Index = DefineR(term, R1Index);12 }13

14 if (R1Index == -1) { R1Index = term.Length; }15 if (R2Index == -1) { R2Index = term.Length; }16 }17

18 private int DefineR(string term, int startIndex)19 {20 bool v = false;21 bool k = false;22 for (int i = startIndex; i < term.Length; i++)23 {24 if (v && k)25 {26 return i;27 }28

29 if (v && !Vowels.Contains(term[i]))30 {31 k = true;32 continue;33 }34

35 if (Vowels.Contains(term[i]))36 {37 v = true;38 continue;39 }40 }41 return -1;42 }

Listing 19: Methode DefineR1AndR2

Die Methode DefineR1AndR2 soll die beiden Bereichsdefinitionen R1 und R2 auf den übergebenenTerm setzen. In Zeile 3 wird R1 mit der Methode DefineR gesetzt. In Zeile 5 wird kontrolliert, obR1 auf den NULL-Bereich des Wortes gesetzt wurde. Mit anderen Worten, wenn R1Index den Wert-1 hat, konnte die Bereichsdefinition R1 zu diesem Term nicht gesetzt werden. In diesem Fall zeigtautomatisch die Bereichsdefinition R2 ebenfalls auf diesen NULL-Bereich. Dies wird durch Zeile 7erreicht. Sollte R1 einen anderen Wert haben, wird in Zeile 11 für R2 der Bereich definiert. Während

73


des Algorithmus werden die Bereichsdefinitionen aus dem Term gebildet. Ein solcher Bereich beginntimmer beim gespeicherten Index der Bereichsdefinition und umschließt den Term bis zum Ende. Sollteder Index den Wert -1 haben, d.h. für diesen Term konnte kein Bereich festgelegt werden, wird derIndex hinter den letzten Buchstaben des Terms gesetzt (Zeile 14 und 15). Somit wird beim bilden derBereichsdefinition ein leerer String verwendet.

Methode DefineRDie Methode DefineR wird von der Methode DefineR1AndR2 mindestens einmal aufgerufen. AlsÜbergabeparameter erhält die Methode DefineR den Term und einen Startindex. Die Methode soll abdem StartIndex für den übergebenen Term eine Bereichsdefinition durchführen und den daraus resultie-renden Startindex zurückliefern. Wie bereits in Kapitel 4.1.7 „Token-Normalisierung“ [Seite 33]erklärt, wird ein Bereich folgendermaßen gebildet: Als erstes wird das erste Vorkommen eines Vokalsgesucht. Durch eine Schleife, beginnend ab dem übergebenen Startindex, wird in Zeile 35 überprüft, obder aktuelle Buchstabe in der Liste der Vokale enthalten ist. Sollte dies der Fall sein, wird die boolescheVariable v auf true gesetzt. Als zweites beschreibt der Algorithmus, dass das erste Vorkommen einesBuchstaben gesucht wird, welches nach dem gefunden Vokal kein Buchstabe aus der Liste der Vokaleist. Nachdem ein Vokal in der Schleife gefunden wurde, wird mit dem nächsten Buchstaben fortgefahren.In Zeile 29 wird geprüft, ob bereits ein Vokal gefunden wurde (v == true) und ob der aktuelle Buch-stabe kein Vokal ist. Wenn dies der Fall ist, wird die boolesche Variable k auf true gesetzt. Als dritteswird der nächste Buchstabe nach dem aus dem zweiten Schritt gefundenen Buchstaben als Startindexdes Bereichs definiert. Dies geschieht im Code in Zeile 24. Durch die Abfrage v && k wird überprüft,ob ein Vokal und ein nicht Vokal gefunden wurde. Wenn dies der Fall ist, ist der aktuelle Buchstabe derStartindex und der aktuelle Index i wird als Startindex zurückgegeben. Die Bereichsdefinition R1 wirdüber den ganzen Term gebildet. Deshalb wird der Methode DefineR als Startindex eine 0 übergeben.Die Bereichsdefinition R2 wird im Bereich von R1 gebildet, weshalb der Startindex für dessen Bildungder Startindex von R1 ist (Zeile 11 in der Methode DefineR1AndR2).

1 private string DoStep1(string term, string r1Term)2 {3 string termAfterStep1 = term;4

5 // (a)6 if (r1Term.EndsWith("ern"))7 {8 termAfterStep1 = RemoveSuffix(termAfterStep1, "ern");9 }

10 else if (r1Term.EndsWith("em"))11 {12 termAfterStep1 = RemoveSuffix(termAfterStep1, "em");13 }14 else if (r1Term.EndsWith("er"))15 {16 termAfterStep1 = RemoveSuffix(termAfterStep1, "er");17 }18 // (b)19 else if (r1Term.EndsWith("en"))20 {21 termAfterStep1 = RemoveSuffix(termAfterStep1, "en");22 termAfterStep1 = DeleteNissEndingStep(termAfterStep1);23 }24 else if (r1Term.EndsWith("es"))25 {26 termAfterStep1 = RemoveSuffix(termAfterStep1, "es");27 termAfterStep1 = DeleteNissEndingStep(termAfterStep1);28 }29 else if (r1Term.EndsWith("e"))30 {31 termAfterStep1 = RemoveSuffix(termAfterStep1, "e");32 termAfterStep1 = DeleteNissEndingStep(termAfterStep1);33 }

74


34 // (c)35 else if (r1Term.EndsWith("s"))36 {37 if (termAfterStep1.Length - "s".Length - 1 >= 0)38 {39 if (Valid_s_endings.Contains(termAfterStep1[termAfterStep1.Length -

"s".Length - 1]))40 {41 termAfterStep1 = RemoveSuffix(termAfterStep1, "s");42 }43 }44 }45

46 return termAfterStep1;47 }

Listing 20: Methode DoStep1

Die Methode DoStep1 führt den Schritt 1 vom Kapitel 4.1.7 „Token-Normalisierung“ [Seite33] aus. Als Eingangsparameter erhält die Methode den vorbereiteten Term und die BereichsdefinitionR1. Der Rückgabewert termAfterStep1 der Methode ist ein möglicherweise veränderter Term. Inden Zeilen 6–17 werden die Endungen, mit denen die Bereichsdefinition R1 enden könnte, entfernt. Inden Zeilen 19–33 werden ebenfalls der Suffix entfernt, wenn dieser identisch zu der BereichsdefinitionR1 Endung ist. Zusätzlich wird die weitere Regel angewendet, wenn die neue Endung von R1 mit „niss“aufhört. In Zeile 35 wird überprüft, ob R1 auf den Buchstaben „s“ endet. Wenn dies der Fall wird in Zeile39 überprüft, ob vor diesem letzten Buchstaben eine gültige s–Endung steht. Die gültigen Endungen ste-hen in der Propertie Valid_s_endings der Klasse GermanStemmingAlgorithm. Diese gültigenEndungen bestehen aus einem Buchstaben. Die Anwendung könnte abstürzen, wenn diese Versucht aufeinen Index zuzugreifen, welcher nicht existiert. Aus diesem Grund wird in Zeile 37 überprüft, ob vordem letzten Buchstaben ein weiterer Buchstabe existiert. Der „s“–Suffix wird entfernt, wenn dieser nacheinem gültigen Buchstaben aus der Valid_s_endings–Liste steht. Der möglicherweise veränderteTerm termAfterStep1 wird anschließend zurückgegeben.

1 private string RemoveSuffix(string term, string suffix)2 {3 BaseTerm = BaseTerm.Substring(0, BaseTerm.Length - suffix.Length);4 return term.Substring(0, term.Length - suffix.Length);5 }

Listing 21: Methode RemoveSuffix

Die Methode RemoveSuffix wird von der Methode DoStep1 und, wie später zu sehen ist, in denMethoden DoStep2 und DoStep3 aufgerufen. RemoveSuffix soll den übergeben Suffix aus demübergebenen Term entfernen und den neuen Term zurückliefern (Zeile 4). In Zeile 3 wird die übergebeneEndung von der Propertie BaseTerm entfernt. Die Propertie BaseTerm repräsentiert den aktuellenTerm ohne den zutreffenden Suffixen.

1 private string DeleteNissEndingStep(string term)2 {3 if (term.EndsWith("niss"))4 {5 BaseTerm = BaseTerm.Substring(0, BaseTerm.Length - "s".Length);6 return term.Substring(0, term.Length - "s".Length);7 }8 return term;9 }

Listing 22: Methode DeleteNissEndingStep

75


Die Methode DeleteNissEndingStep wird in der Methode DoStep1 aufgerufen. Wenn der über-gebene Term mit „niss“ enden, wird der letzte Buchstabe („s“) entfernt. Die Prüfung auf Endung auf„niss“ geschieht in Zeile 3. In den Zeilen 5 wird der Teilstring vom Term ohne den letzten Buchstaben(„s“) der Propertie BaseTerm und in Zeile 6 dieser zurückgegeben. Sollte der Term nicht auf „niss“enden, wird der unveränderte übergebene Term zurückgegeben.

1 private string DoStep2(string term, string r1Term)2 {3 string termAfterStep2 = term;4

5 if (r1Term.EndsWith("est")) { termAfterStep2 = RemoveSuffix(term, "est"); }6 else if (r1Term.EndsWith("er")) { termAfterStep2 = RemoveSuffix(term, "er"); }7 else if (r1Term.EndsWith("en")) { termAfterStep2 = RemoveSuffix(term, "en"); }8 else if (r1Term.EndsWith("st") && Valid_st_endings.Contains(term[term.Length -

"st".Length - 1]))9 {

10 if (term.Length - "st".Length >= 4)11 {12 termAfterStep2 = RemoveSuffix(term, "st");13 }14 }15


Methode DoStep2 führt den Schritt 2 vom Kapitel 4.1.7 „Token-Normalisierung“ [Seite 33] aus.Den Term aus Schritt 1 erhält diese Methode als Übergabeparameter und zusätzlich die neu generierteBereichsdefinition R1. In den Zeilen 5–7 werden die Suffixe entfernt, wenn diese identisch zur Endungder Bereichsdefinition R1 sind. In Zeile 8 wird nur der Suffix „st“ entfernt, wenn vor dieser Endung eingültiger Buchstaben aus der Propertie–Liste Valid_st_endings steht (Zeile 8). Weiterhin müssenvor der „st“–Endung minimal 4 Buchstaben stehen (Zeile 10). Nur wenn alle drei Bedingungen zutreffenwird in Zeile 12 der Suffix entfernt.

1 private string DoStep3(string term)2 {3 string r2Term = RefreshRTerm(R2Index);4 if (String.IsNullOrEmpty(r2Term)) { return term; }5

6 string r1Term = RefreshRTerm(R1Index);7 if (String.IsNullOrEmpty(r1Term)) { return term; }8

9 string termAfterStep3 = term;10

11 // end, ung12 if (r2Term.EndsWith("end"))13 {14 termAfterStep3 = RemoveSuffix(termAfterStep3, "end");15 termAfterStep3 = DeleteIgEndingStep(termAfterStep3, r2Term, "end");16 }17 else if (r2Term.EndsWith("ung"))18 {19 termAfterStep3 = RemoveSuffix(termAfterStep3, "ung");20 termAfterStep3 = DeleteIgEndingStep(termAfterStep3, r2Term, "ung");21 }22 // ig, ik, isch23 else if (r2Term.EndsWith("ig"))24 {25 if (IsNotPrecededBy("ig", ’e’))26 {27 termAfterStep3 = RemoveSuffix(termAfterStep3, "ig");28 }29 }

76


30 else if (r2Term.EndsWith("ik") && IsNotPrecededBy("ik", ’e’))31 {32 termAfterStep3 = RemoveSuffix(termAfterStep3, "ik");33 }34 else if (r2Term.EndsWith("isch") && IsNotPrecededBy("isch", ’e’))35 {36 termAfterStep3 = RemoveSuffix(termAfterStep3, "isch");37 }38 // lich, heit39 else if (r2Term.EndsWith("lich") || r2Term.EndsWith("heit"))40 {41 if (r1Term.EndsWith("erlich"))42 {43 termAfterStep3 = RemoveSuffix(termAfterStep3, "erlich");44 }45 else if (r1Term.EndsWith("erheit"))46 {47 termAfterStep3 = RemoveSuffix(termAfterStep3, "erheit");48 }49 else if (r1Term.EndsWith("enlich"))50 {51 termAfterStep3 = RemoveSuffix(termAfterStep3, "enlich");52 }53 else if (r1Term.EndsWith("enheit"))54 {55 termAfterStep3 = RemoveSuffix(termAfterStep3, "enheit");56 }57 else58 {59 termAfterStep3 = RemoveSuffix(termAfterStep3, "lich"); // same length as heit60 }61 }62 // keit63 else if (r2Term.EndsWith("keit"))64 {65 if (r2Term.EndsWith("lichkeit"))66 {67 termAfterStep3 = RemoveSuffix(termAfterStep3, "lichkeit");68 }69 else if (r2Term.EndsWith("igkeit"))70 {71 termAfterStep3 = RemoveSuffix(termAfterStep3, "igkeit");72 }73 else74 {75 termAfterStep3 = RemoveSuffix(termAfterStep3, "keit");76 }77 }78


Listing 23: Methode DoStep3

Die Methode DoStep3 führt den Schritt 2 vom Kapitel 4.1.7 „Token-Normalisierung“ [Seite 33]aus. Der aus Schritt 2 zurückgegebene Term wird dieser Methode als Parameter übergeben. In Zeile 3wird die Bereichsdefinition R2 neu gebildet. Sollte diese nicht definiert werden können, programmier-technisch ist r2Term ein Leerstring, wird der unveränderte Übergabeterm zurückgegeben (Zeile 4). Dasselbe geschieht in den Zeilen 6 und 7 mit der Bereichsdefinition R1. Sollten beide Bereichsdefinitionengelingen, wird mit den Zeilen 11 bis 21 die Bereichsdefinition R2 auf den Suffix „end“ oder „ung“ über-prüft. Je nachdem, welcher Suffix übereinstimmt, wird zum einen dieser entfernt, zum anderen wird dieneue Endung überprüft, ob diese auf „ig“ endet. Sollte dies der Fall sein, wird auch diese Endung entfernt(Zeile 15 bzw. 20 mit Hilfe der Methode DeleteIgEndingStep). In den Zeilen 22 bis 37 wird dieBereichsdefinition R2 auf den Suffix „ig“, „ik“ oder „isch“ überprüft und gelöscht. In den Zeilen 39 bis61 wird die Endung von R2 auf „lich“ und „heit“ kontrolliert, da es für diese Endung einen Sonderfall

77


gibt. Wenn vor den beiden Suffixen die Buchstaben „er“ oder „en“ stehen, werden diese ebenfalls ent-fernt. Der Einfachheitshalber wird deswegen in den Zeilen 41, 45, 49, 53 auf den vollen Suffix überprüft.Zeile 59 wird ausgeführt, wenn R2 mit „lich“ oder „heit“ endet, davor aber nicht die Buchstaben „er“oder „en“ stehen. In diesem Fall soll trotzdem der Suffix „lich“ bzw. „heit“ entfernt werden. Die MethodeRemoveSuffix entfernt die Anzahl an Buchstaben, die mit dem übergebenen Suffixparameter ange-geben werden. Dadurch, dass die Endungen „lich“ und „heit“ die selbe Anzahl an Buchstaben besitzen,funktioniert die Zeile 59 für beide Endungen. In den Zeilen 63 bis 77 wird für die Endung „keit“ dieselbe Technik wie in den Zeilen davor angewendet.

1 private string RefreshRTerm(int rIndex)2 {3 if (BaseTerm.Length < rIndex) { return ""; }4 return BaseTerm.Substring(rIndex);5 }

Listing 24: RefreshRTerm

Die in Methode DoStep3 aufgerufene Methode RefreshRTerm liefert die neue Bereichsdefinition.Dabei wird in Zeile 3 überprüft, ob der Index der Bereichsdefinition im Bereich des aktuellen Termsliegt. Dadurch, dass der Term durch Suffix–Entfernungen kleiner wird, kann es passieren, dass der Be-reichsdefinitionindex außerhalb des möglichen Indexes liegt. Wenn dies zutrifft, wird der Leerstring zu-rückgegeben. In Zeile 4 wird die neu gebildete Bereichsdefinition zurückgegeben, wenn der Index nochim möglichen Bereich lag.

1 private bool IsNotPrecededBy(string suffix, char letter)2 {3 int idx = OrgTerm.LastIndexOf(suffix);4 if (idx - 1 < 0) { return false; }5

6 return OrgTerm[idx - 1] != letter;7 }

Listing 25: Methode IsNotPrecededBy

Die Methode IsNotPrecededBy soll überprüfen, ob vor dem übergebenen Suffix der übergebeneBuchstabe letter steht. In Zeile 3 wird der Index des zu überprüfenden Buchstabens des Terms ermit-telt. Sollte dieser nicht existieren, wird false zurückgegeben und die Methode beendet. Ansonsten wirdmit Zeile 6 das Ergebnis zurückgegeben, ob der zu überprüfende Buchstabe identisch zum übergebenenBuchstaben ist.

1 private string DeleteIgEndingStep(string term, string r2Term, string suffix)2 {3 if (r2Term.EndsWith("ig"+suffix))4 {5 if(IsNotPrecededBy("ig", ’e’))6 {7 return RemoveSuffix(term, "ig");8 }9 }

10 return term;11 }

Listing 26: Methode DeleteIgEndingStep

Die Methode DeleteIgEndingStep entfernt das Suffix „ig“, wenn dieses identisch zur Endung derBereichsdefinition R2 ist. Zusätzlich darf vor der Endung nicht der Buchstabe „e“ stehen (Zeile 5).

78


1 private static string DoFinallyStep(string term)2 {3 // turn U and Y into lower case4 string stemmerTerm = term.ToLower();5

6 // remove the umlaut accent from a, o and u7 stemmerTerm = stemmerTerm.Replace(’ä’, ’a’);8 stemmerTerm = stemmerTerm.Replace(’ö’, ’o’);9 stemmerTerm = stemmerTerm.Replace(’ü’, ’u’);

10

11 return stemmerTerm;12 }

Listing 27: Methode DoFinallyStep

Als vorletzten Schritt wird in der Methode Stemming die Methode DoFinallyStep aufgerufen. Indieser Methode sollen die möglicherweise am Anfang großgeschriebenen Buchstaben „u“ und „y“ wie-der in Kleinbuchstaben konvertiert werden. Anstatt nach Großbuchstaben zu suchen, wurde die String–Methode „ToLower“ verwendet (Zeile 4). In den Zeilen 7–9 werden die Umlautpunkte entfernt. Mitanderen Worten, werden die Buchstaben „ä“, „ö“ und „ü“ durch „a“, „o“ und „u“ ersetzt. Zurückgegebenwird der Term, welcher nach Durchlaufen des German Stemming Algorithmus entsteht.

5.5.3 Initialisierung des Fuzzy–Logic–Models

Wie bereits in Codeabbildung 11 „Methode InitRetrievalSystem“ [Seite 68] zu sehen war,wird in Zeile 4 eine Instanz des FuzzyLogicManagers erstellt. Anschließend wird die Berechnungdes Ogawas ausgeführt (Zeile 5). Die Ergebnisliste wird in die Propertie OrgawaListe gespeichert.

5.5.4 Fuzzy Logic – Berechnung von Jaccard und Ogawa

1 public class FuzzyLogicManager2 {3 public FuzzyLogicManager(Dictionary<string, List<int>> invertedIndex)4 {5 InvertedIndex = invertedIndex;6 JaccardListe = CalcJaccardWerte(this.InvertedIndex);7 }8

9 #region Properties10 private Dictionary<string, List<int>> InvertedIndex;11 private List<JaccardWertItem> JaccardListe;12 #endregion Properties13

14 [...]15 }

Listing 28: Konstruktor und Properties der Klasse FuzzyLogicManager

Dem Konstruktor der Klasse FuzzyLogicManager wird der, von der CreateInvertedIndex–Methode erstellte, inverted index übergeben. Dieser wird in die Propertie InvertedIndex gespei-chert. Danach werden die Jaccardwerte durch die Methode CalcJaccardWerte berechnet und in diePropertie JaccardListe persistiert.

79


1 public static List<JaccardWertItem> CalcJaccardWerte(Dictionary<string, List<int>>invertedIndex)

2 {3 List<string> termList = new List<string>(invertedIndex.Keys);4 List<JaccardWertItem> jm_liste = new List<JaccardWertItem>();5

6 foreach (var term1 in termList)7 {8 foreach (var term2 in termList)9 {

10 int anzIntersect =invertedIndex[term1].Intersect(invertedIndex[term2]).Count();

11 int anzUnion = invertedIndex[term1].Union(invertedIndex[term2]).Count();12

13 jm_liste.Add(new JaccardWertItem(term1, term2, anzIntersect, anzUnion));14 }15 }16

17 return jm_liste;18 }

Listing 29: Methode CalcJaccardWerte

Die Methode CalcJaccardWerte soll auf den übergebenen inverted index alle möglichen Jaccard-werte berechnen und zurückgeben. In Zeile 3 wird der termList alle Terme aus dem übergebeneninverted index zugewiesen. Dadurch, dass der inverted index vom Datentyp Dictionary ist und dieTerme als Key gespeichert wurden, kann mit dem Befehl invertedIndex.Keys auf alle Keys desDictionarys zugegriffen werden. Für die Berechnung der Jaccardwerte muss jeder Term mit jedem an-deren Term verglichen werden. Deshalb laufen die beiden Schleifen aus Zeile 6 und 8 über alle Terme.In der Schleife wird in Zeile 10 die von C# mitgelieferten Intersect–Methode aufgerufen. Das Ergebnisdieser Methode wird mit der Count–Methode gezählt und in die Variable anzIntersect gespeichert,was die Anzahl der Kommandos repräsentiert, die den Term term1 und term2 enthalten. In Zeile 11wird die von C# mitgelieferte Methode Union aufgerufen, um über Count die Anzahl der Kommandos zuermitteln, die einen der beiden Terme enthalten. Diese Zahl wird in die Variable anzUnion zwischen-gespeichert. In Zeile 13 wird mit den berechneten Werten ein JaccardWertItem–Objekt erstellt undanschließend in der Rückgabeliste der Methode CalcJaccardWerte hinzugefügt. Wenn Zeile 17 er-reicht wird, enthält die Variable jm_liste alle berechneten Jaccardwerte des übergebenen invertedindexes. Diese Liste an JaccardWertItem–Objekten wird zurückgegeben.

JaccardWertItem

+ Wort_t: string+ Wort_u: string+ AnzIntersection: int+ AnzUnion: int

+ JaccardWertItem(t: string, u: string, anzIntersection: int, anzUnion: int): JaccardWertItem

Abbildung 20: UML Diagramm der Klasse JaccardWertItem

80


1 public class JaccardWertItem2 {3 public JaccardWertItem(string t, string u, int anzIntersection, int anzUnion)4 {5 Word_t = t;6 Word_u = u;7 AnzIntersection = anzIntersection;8 AnzUnion = anzUnion;9 }

10

11 #region Properties12 public string Word_t { get; private set; }13 public string Word_u { get; private set; }14 public int AnzIntersection { get; private set; }15 public int AnzUnion { get; private set; }16 #endregion Properties17 }

Listing 30: Klasse JaccardWertItem

Wie das UML Diagramm von der Klasse JaccardWertItem zeigt besteht diese nur aus seinem Kon-struktor und seine Properties. Diese Realisierung dieser Klasse ist nach dem Entwurfsmuster Value Ob-ject implementiert. Es entstehen unveränderliche Objekte, die einen speziellen Wert repräsentieren. D.h.wenn ein Wert geändert werden soll, muss ein neues Objekt generiert werden. Dadurch, dass diese Ob-jekte keine Logik enthalten, werden diese meist als Datenobjekte zwischen den Methoden verwendet.

1 public List<OgawaItem> CalcOgawa()2 {3 Dictionary<int, List<string>> index = CreateIndex();4

5 List<OgawaItem> ogawaListe = new List<OgawaItem>();6

7 foreach (string term_t in InvertedIndex.Keys)8 {9 foreach (int docID in index.Keys)

10 {11 ogawaListe.Add(CalcOgawa(term_t, docID, index[docID]));12 }13 }14

15 return ogawaListe;16 }

Die einzige öffentlich von außen aufrufbare Methode der Klasse JaccardWertItem ist CalcOgawa.Dadurch, dass im Konstruktor der Klasse FuzzyLogicManager die Jaccardwerte berechnet wurden,muss diese Methode die Werte nicht nochmal berechnen. Weiterhin ist dieser Methode der inverted indexbekannt, der dem Konstruktor übergeben und in einer Propertie gespeichert wurde. Die Berechnung desOgawawertes wird für jedes Dokument mit jedem Term durchgeführt. Der Zugriff auf die Terme wurdebereits in der Methode CalcJaccard beschrieben. Die Methode CreateIndex gibt ein Dictionaryaus allen Dokumenten zurück (Zeile 3). Die Keys des Dictionarys enthalten die eindeutigen Nummernder Dokumente (docID) und die Values bestehen aus einer Liste von Termen, die im jeweiligen Doku-ment enthalten sind. Mit anderen Worten ein umgekehrter inverted index. In den Zeilen 6 und 8 werdenzwei Schleifen gestartet, die über jeden Term (term_t) zu jedem Dokument (docID) laufen. In derSchleife wird zum aktuellen Term term_t und zum aktuellen Dokument docID der Ogawawert be-rechnet. Für die Berechnung wird die Methode CalcOgawa verwendet.

81


5.5.5 Erstellen eines umgekehrten inverted indexes

1 private Dictionary<int, List<string>> CreateIndex()2 {3 Dictionary<int, List<string>> index = new Dictionary<int, List<string>>();4 foreach (string term in this.InvertedIndex.Keys)5 {6 foreach (int docID in this.InvertedIndex[term])7 {8 if (index.ContainsKey(docID))9 {

10 index[docID].Add(term);11 }12 else13 {14 index.Add(docID, new List<string>() { term });15 }16 }17 }18 return index;19 }

Listing 31: Methode CreateIndex

Wie bereits erwähnt soll die Methode CreateIndex ein Dictionary mit allen Dokumenten zurückge-ben. Als Datenbasis verwendet diese Methode den inverted index. Im inverted index wird zu jedem Termeine Liste mit allen Dokumenten gespeichert, die diesen Term enthalten. Das Ziel dieser Methode ist einDictionary mit allen Dokumenten und einer Liste mit den Termen, die in dem entsprechenden Dokumententhalten sind. Deshalb wird das Dictionary InvertedIndex durchlaufen. D.h. es wird eine Schleifeüber jeden Term (Zeile 4) und dann über dessen Dokumente (Zeile 6) ausgeführt. In den Zeilen 8–15wird das aktuelle Dokument (docID) in das Rückgabedictionary gespeichert, wenn dieses noch nichthinzugefügt wurde. Sollte es bereits im Dictionary enthalten sein, wird nur der aktuelle Term der Listeder Dokumenteneinträge hinzugefügt.

1 public OgawaItem CalcOgawa(string t, int docID, List<string> termOfDocID)2 {3 double jaccardProduct = 1.0;4 foreach (string term_u in termOfDocID)5 {6 JaccardWertItem jaccardItem = JaccardListe.Where(item => item.Word_u == term_u &&

item.Word_t == t).FirstOrDefault();7 if (jaccardItem == null) { continue; }8 jaccardProduct *= (double)1.0 - ((double)jaccardItem.AnzIntersection /

(double)jaccardItem.AnzUnion);9 }

10 double ogawaWert = (double)1.0 - jaccardProduct;11 return new OgawaItem(docID, t, ogawaWert);12 }

Listing 32: Methode CalcOgawa

Die Methode CalcOgawa berechnet für den übergebenen Term t und dem übergebenen DokumentdocID den Ogawawert. Zusätzlich erhält die Methode eine Liste an Termen, die im Dokument docIDenthalten sind. Der Produktterm der Ogawa–Formel wird in Zeile 4–9 berechnet. Es werden alle Termedes Dokuments docID durchlaufen. Ein einzelner Term dieser Menge ist in der Formel als u definiert. Inder Methode wurde dieser Term term_u genannt. In Zeile 6 wird der gespeicherte Jaccardwert ermittelt,der zum aktuellen term_u und dem übergebene Term t gehört. Sollte dieser Wert nicht existieren, wirdmit dem nächsten term_u fortgefahren. Andernfalls wird der Produktterm berechnet. Nach Beendigungder foreach–Schleife steht in jaccardProduct der berechnete Produktterm. Für die Berechnung des

82


Ogawawertes muss dieser Wert von 1 subtrahiert werden. Der Berechnete Ogawawert wird in einem neuerstellten OgawaItem–Objekt zurückgegeben (Zeile 11).

OgawaItem

+ DocID: int+ Termt: string+ OgawaWert: double

+ OgawaItem(docID: int, termt: string, ohawaWert: double)

Abbildung 21: UML Diagramm der Klasse OgawaItem

Wie das UML–Diagramm aus Abbildung 21 zeigt, ist auch das OgawaItem nach dem EntwurfsmusterValue Object realisiert. Es wird verwendet um eindeutige Ogawa–Objekte zu erstellen.

5.6 Kommando–Interpretation mit dem Boolean Retrieval Model

In diesem Kapitel wird die Implementierung des Programmteils erläutert, welches die Interpretation desvom Anwender gesprochenen Kommandos für das Boolean Retrieval Model übernimmt.

1 private List<BooleanRetrievalResult> DoBooleanRetrievalModel(string command)2 {3 string[] commandTerms = command.Split(’ ’);4

5 HashSet<int> resultPostingList = null;6 List<int> postingListe = new List<int>();7 foreach (string term in commandTerms)8 {9 if (!InvertedIndex.Keys.Contains(term))

10 {11 return new List<BooleanRetrievalResult>() {12 new BooleanRetrievalResult(BooleanRetrievalResult.FLAG13 .UnknownTermInInvertedIndex)14 };15 }16

17 if (resultPostingList == null)18 {19 resultPostingList = new HashSet<int>(InvertedIndex[term]);20 }21 else22 {23 HashSet<int> postinglist = new HashSet<int>(InvertedIndex[term]);24 resultPostingList = IntersectPostingLists(resultPostingList, postinglist);25 }26 }27

28 if (resultPostingList.Count == 0)29 {30 return new List<InterpretResult>() { new

InterpretResult(InterpretResult.FLAG.NoCommandFoundedInPostingList) };31 }32

33 List<BooleanRetrievalResult> interpretResults =GetInterpretResultsByDocID(resultPostingList);

34 return interpretResults;35 }

Listing 33: Methode DoBooleanRetrievalModel

83


Die Methode DoBooleanRetrievalModel interpretiert das Kommando für das Boolean RetrievalModel. Dazu erhält diese Methode das Kommando als Parameter. In Zeile 3 wird das Kommando in seineeinzelnen Wörter unterteilt, indem das Kommando nach den Leerzeichen unterteilt wird. In den Zeilen 7bis 26 wird für jeden dieser einzelnen Terme der entsprechende Eintrag im inverted index herausgefiltert.

Beim Boolean Retrieval Model werden die einzelnen posting lists der Terme miteinander ver-knüpft (Intersection). Diese Verknüpfung geschieht in jedem Schleifendurchlauf. In der VariableresultPostingList stehen in jedem Schleifendurchlauf die aktuell gültige posting list. In je-dem Schleifendurchlauf wird diese Liste mit der positing list des aktuellen Termeintrages verknüpft.Dieser Vorgang geschieht in der Methode IntersectPostingLists (Zeile 24). Die VariableresultPostingList ist beim ersten Term eine leere Liste. Eine Intersection mit einer beliebigbefüllten posting liste des ersten Terms und einer leeren posting list ergibt immer eine leere Li-ste. Deshalb wird in den Zeilen 17–20 dieser Fall abgefangen. In diesen Zeilen wird in die Varia-ble resultPostingList die posting list des ersten Terms hineingeschrieben. Nachdem alle po-sting lists aller Terme durchlaufen wurden, steht nach Zeile 26 in resultPostingList die re-sultierende posting list. In Zeile 28 wird kontrolliert, ob diese Liste keinen Eintrag hat. Dies wür-de bedeuten, dass das System das Kommando des Anwenders nicht kennt. In diesem Fall wird einBooleanRetrievalResult–Objekt zurückgegeben, welches ein Flag enthält, das diese Situationbeschreibt. Sollte die resultPostingList mindestens einen Eintrag haben, wird in Zeile 33 füralle Kommandos in der posting list ein BooleanRetrievalResult–Objekt erstellt und einer Listehinzugefügt. Diese Liste wird in Zeile 34 zurückgegeben.

5.6.1 Intersection–Algorithmus für zwei posting lists

1 private HashSet<int> IntersectPostingLists(HashSet<int> p1, HashSet<int> p2)2 {3 HashSet<int> answer = new HashSet<int>();4

5 List<int> orderP1 = p1.OrderBy(item => item).ToList();6 List<int> orderP2 = p2.OrderBy(item => item).ToList();7

8 int indexOfP1 = 0;9 int indexOfP2 = 0;

10

11 while (indexOfP1 != orderP1.Count && indexOfP2 != orderP2.Count)12 {13 int docIDP1 = orderP1[indexOfP1];14 int docIDP2 = orderP2[indexOfP2];15 if (docIDP1 == docIDP2)16 {17 answer.Add(docIDP1);18 indexOfP1++;19 indexOfP2++;20 }21 else if (docIDP1 < docIDP2)22 {23 indexOfP1++;24 }25 else26 {27 indexOfP2++;28 }29 }30

31 return answer;32 }

Listing 34: Methode IntersectPostingLists

84


Wie bereits oben erwähnt soll die Methode IntersectPostingLists zwei posting lists mitein-ander verknüpfen (Intersection). Für den Vergleich müssen die beiden posting lists nach dem gleichemSchlüssel sortiert sein. Dies geschieht in den Zeilen 5 und 6. Beide Listen werden aufsteigend nach ihrereindeutigen Nummer sortiert und in Variablen abgespeichert. Auf diesen sortierten Listen wird in denZeilen 11–29 die Verknüpfung ausgeführt. Jeder dieser Listen erhält einen Pointer, welcher am Anfangauf den Anfang der Liste zeigt (Zeilen 8 und 9). Als Pointer wurde bei dieser Implementierung in C#Indizes auf Listen verwendet. In der Zeile 13 wird pro Schleifendurchlauf die eindeutige Nummer des ak-tuellen Kommandos aus der ersten Liste in eine Zwischenvariable gespeichert. Das selbe geschieht eineZeile weiter mit der zweiten Liste. Diese beiden Werte werden dann verglichen. Sind beide Komman-donummern identisch, wird diese Nummer der Ergebnisliste answer hinzugefügt. Zusätzlich werdenbeide Indizes einen Eintrag weitergesetzt. Wenn die Werte unterschiedlich sind, wird der Index der Listeum einen Eintrag hochgezählt, dessen Kommandonummer die kleinere ist. Dieser Vorgang wird solan-ge durchgeführt, bis eine der Listen komplett durchlaufen wurde. Am Ende dieser Methode wird dieErgebnisliste answer zurückgegeben.

5.6.2 Rückgabewert der Interpretation

BooleanRetrievalResult

+ FLAG: enum+ Error: FLAG?+ InteractionID: int+ ExecutableInteractionID: int

+ BooleanRetrievalResult(error: FLAG?, interactionID: int, executableInteractionID :int)

Abbildung 22: UML Diagramm der Klasse BooleanRetrievalResult

1 public class BooleanRetrievalResult2 {3 public BooleanRetrievalResult(FLAG? error = null, int interactionID = -1, int

executableInteractionID = -1, int documentFrequency = -1)4 {5 InteractionID = interactionID;6 ExecutableInteractionID = executableInteractionID;7 Error = error;8 }9

10 #region Properties11 public enum FLAG { UnknownTermInInvertedIndex, NoCommandFoundedInPostingList };12 public FLAG? Error { get; private set; }13 public int InteractionID { get; private set; }14 public int ExecutableInteractionID { get; private set; }15 public int DocumentFrequency { get; set; }16 #endregion Properties

Listing 35: Konstruktor und Properties der Klasse BooleanRetrievalResult

Boolean Retrieval Result ist eine weitere Klasse nach dem Value Object Entwurfsmuster,die das Ergebnis des Boolean Retireval Models repräsentiert. Soll für ein fehlerhaftes Ergebnis einBooleanRetrievalResult–Objekt erstellt werden, wird dem Konstruktor nur das dementspre-chende FLAG übergeben. Die restlichen Parameter werden von der Anwendung auf den Default–Wert−1 gesetzt. Für ein richtiges Ergebnis muss dem ersten Parameter der Wert null übergeben werden undden restlichen beiden Parametern der entsprechende Wert.

85


5.7 Kommando–Interpretation mit dem Fuzzy Logic Model

Die Realisierung der Interpretation des von Anwender gesprochenen Kommandos für das Fuzzy LogicModel wird in diesem Kapitel dokumentiert.

1 private List<FuzzyLogicResult> DoFuzzyLogicModel(string command)2 {3 string[] commandTerms = command.ToLower().Split(’ ’);4

5 List<FuzzyLogicResult> result = new List<FuzzyLogicResult>();6

7 Dictionary<int, string> allCommands =DataProvider.Database.ExecutableInstructionDatabase.GetAllCommands();

8 foreach (int docID in allCommands.Keys)9 {

10 double docOgawaResultValue = 1.0;11 List<OgawaItem> docOgawaValues = new List<OgawaItem>();12 foreach (string commandTerm in commandTerms)13 {14 OgawaItem ogawaItem = this.InitDataManager.OgawaListe.Where15 (item => item.DocID == docID && item.Termt ==

commandTerm).FirstOrDefault();16 if (ogawaItem == null)17 {18 docOgawaValues.Add(new OgawaItem(docID, commandTerm, 0.0));19 continue;20 }21 docOgawaValues.Add(ogawaItem);22 docOgawaResultValue = Math.Min(docOgawaResultValue, ogawaItem.OgawaWert);23 }24 result.Add(new FuzzyLogicResult(docID, docOgawaResultValue, docOgawaValues));25 }26 return result.OrderByDescending(item => item.DocOgawaResultValue).ThenBy(item =>

item.DocID).ToList();27 }

Listing 36: Methode DoFuzzyLogicModel

Die Interpretation des Kommandos wird von der Methode DoFuzzyLogicModel ausgeführt. Dasvom Anwender gesprochene Kommando wird als Parameter übergeben. In Zeile 3 wird das Kommandoin einzelne Wörter gesplittet. Die Datenbank wird in Zeile 7 gebeten, ein Dictionary mit allen möglichenKommandos zu liefern. Die Keys des Dictionarys enthalten die eindeutigen Nummern der Komman-dos und die Values bestehen aus den Termen des Kommandos. Wie gut ein Kommando das übergebeneKommando beschreibt wird im Fuzzy Logic Model folgendermaßen berechnet: Zu jedem Term des über-gebenen Kommandos muss ein Ogawawert zu diesem Kommando berechnet werden. Das Kommandomit dem kleinsten Ogawa–Wert beschreibt das angefragte Kommando am Besten.

In den Zeilen 8–25 wird für jedes Kommando aus dem Dictionary der Ogawawert bezüglich jeden Termsdes übergebenen Kommandos berechnet. In den Zeilen 14 und 15 wird der bereits während der Initiali-sierung berechnete Ogawawert des aktuellen Dokuments docID zum aktuellen Term commandTermherausgesucht. Sollte dieser Wert nicht gefunden werden, wird in der Zeile 18 ein neues OgawaItem–Objekt mit dem Ogawawert 0, 0 der Variable docOgawaValues zugewiesen. In dieser Variable werdenalle Ogawawerte eines Dokuments gespeichert. Diese Liste wird nur für das Testen der Methode benötigt.Anschließend fährt die Berechnung mit dem nächsten Term fort. Wenn der Ogawawert existiert, wird die-ser der Liste docOgawaValues hinzugefügt. Zusätzlich wird in Zeile 22 der aktuelle Ogawawert in dieVariable docOgawaResultValue gespeichert. Dadurch, dass der kleinste Ogawawert das Ergebnisist, wird in jedem Schleifendurchlauf nur der kleinste Wert in der Variable docOgawaResultValuenotiert. Weil beim ersten Schleifendurchlauf die Variable docOgawaResultValue noch nicht ge-setzt werden kann, wird diese mit dem höchsten errechenbaren Wert initialisiert (Zeile 10). Nach-

86


dem in Zeile 24 die Berechnung des Ogawawertes für ein Kommando abgeschlossen ist, wird einFuzzyLogicResult–Objekt erstellt und der Ergebnisliste hinzugefügt. Neben der eindeutigen Kom-mandonummer erhält dieses Objekt den endgültigen Ogawawert docOgawaResultValue und dieListe aller Ogawawerte dieses Dokuments (docOgawaValues). Diese Zeilen werden für jedes Doku-ment ausgeführt, sodass wenn Zeile 25 erreicht wird, in der Ergebnisliste result zu jedem KommandoFuzzyLogicResult–Objekte stehen. Diese Liste wird in Zeile 26 zuerst absteigend nach dem Oga-wawert der Kommandos und danach nach dessen eindeutigen Nummern sortiert. Somit steht an ersterStelle der Liste das Kommando, welches am Besten mit dem übergebenen Kommando übereinstimmt.Die zweite Sortierung ist nur für den später beschriebenen Testfall wichtig. Anschließend wird dieseListe zurückgegeben.


FuzzyLogicResult

+ DocID: int+ DocOgawaResultValue: double+ DocOgawaValues: List<OgawaItem>

+ FuzzyLogicResult(docID: int, docOgawaResultValue: double, docOgawaValues: List<OgawaItem>)

Abbildung 23: UML Diagramm der Klasse FuzzyLogicResult

1 public class FuzzyLogicResult2 {3 public FuzzyLogicResult(int docID, double docOgawaResultValue, List<OgawaItem>

docOgawaValues)4 {5 DocID = docID;6 DocOgawaResultValue = docOgawaResultValue;7 DocOgawaValues = docOgawaValues;8 }9

10 #region Properties11 public int DocID { get; private set; }12 public double DocOgawaResultValue { get; private set; }13 public List<OgawaItem> DocOgawaValues { get; private set; }14 #endregion Properties15 }

Listing 37: Klasse FuzzyLogicResult

Die Klasse FuzzyLogicResult wurde für die Erstellung der Ergebnis–Objekte des Fuzzy LogicModels implementiert. Sie wurde ebenfalls nach dem Entwurfsmuster Value Object entwickelt. DiesesObjekt besteht aus der eindeutigen Nummer des Kommandos (docID), den Ogawa–Werten des Kom-mandos mit den einzelnen Anfrage–Kommando–Termen (DocOgawaValues) und dem endgültigenOgawa–Wert DocOgawaResultValue.

87


5.8 Kommando–Interpretation mit dem Alexa–Äquivalentes Model

Die Implementierung des Programmteils, welches die Interpretation des vom Anwender gesprochenenKommandos für das Alexa–Äquivalentem Model übernimmt, wird in diesem Kapitel erläutert.

Synonym–Datenbanktabellen

Abbildung 24: Datenbanktabellen für die Behandlung von Synonymen

Damit das Alexa–Äquivalentes Model die Behandlung von Synonymen beherrscht, wurden weitere Da-tenbanktabellen erstellt. Diese sind in der Abbildung 24 aufgeführt. Für den Term „Jalousien“, welchesein Synonym zu dem im Model bekannten Device „Rollladen“ ist, muss folgender Datenbank–Eintragvorgenommen werden: Als Device_ID wird die ID des Terms Rollladen aus der Device–Tabelleeingegeben. Weiterhin wird in die Spalte Description der Term „Jalousien“ eingetragen. Jede Store–Procedure wurde so erweitert, dass während der Interpretation der Term „Rollladen“ und die dazu gehö-rigen Synonyme, in diesem Fall der Term „Jalousien“, vom Alexa–Äquivalenten Model identisch behan-delt werden. Für die Interaction– und Location–Synonyme wurden äquivalent aufgebaute Datenbankta-bellen angelegt.

1 public class AlexaAequivalentesModel2 {3 public AlexaAequivalentesModel()4 {5 AllDevices = DeviceDatabase.GetAllDevices();6 AllLocations = LocationDatabase.GetAllLocations();7 AllInteractions = InteractionDatabase.GetAllInteractions();8

9 GSA = new GermanStemmingAlgorithm();10 }11

12 #region Properties13 private List<Device> AllDevices { get; set; }14 private List<Interaction> AllInteractions { get; set; }15 private List<Location> AllLocations { get; set; }16 private GermanStemmingAlgorithm GSA { get; set; }17 #endregion Properties18 }

Listing 38: Konstruktor und Properties der Klasse AlexaAequivalentesModel

Die Klasse, welche die Interpretation durchführt, ist die Klasse AlexaAequivalentesModel. ImKonstruktor wird die Initialisierung der Interpretation durchgeführt. Dabei werden alle Devices, Inter-actions und Locations aus der Datenbank abgefragt und in Properties gespeichert. Die Interpretationübernimmt die öffentliche Methode InterpretCommand, welche die einzelnen Terme des Anfrage–Kommandos als Übergabeparameter erhält.

88


1 public DeterminedInstruction InterpretCommand(string[] commandTerms)2 {3 string[] stemmedCommandTerms = new string[commandTerms.Length];4 for (int i = 0; i < commandTerms.Length; i++)5 {6 stemmedCommandTerms[i] = GSA.Stemming(commandTerms[i]);7 }8

9 Device determinedDevice = DetermineDevice(stemmedCommandTerms);10 List<Tuple<Device, List<Interaction>>> determinedDeviceinteractions =

DetermineInteraction(stemmedCommandTerms, determinedDevice);11 List<DeterminedInstruction> determined = DetermineLocation(stemmedCommandTerms,

determinedDeviceinteractions);12 return AnalyseInstructions(determined);13 }

Listing 39: Methode DeterminedInstruction

Die Methode DeterminedInstruction beginnt mit dem normalisieren des Kommandos durchden German Stemming Algorithmus. Danach folgt das Ermitteln des Devices. Dazu wird die Metho-de DetermineDevice aufgerufen. Diese liefert entweder das erkannte Device aus den übergebenenAnfragekommando–Termen oder den Wert null, wenn kein Device gefunden werden konnte. Mit die-ser Erkenntnis wird anschließend die Methode DetermineInteraction aufgerufen. Diese Methodeliefert eine Liste von Instructions, die aus dem Kommando herausgelesenen Interaction und dem bisherbekannten Device oder den Devices, die zu dieser Interaction gehören. Danach wird die Location er-mittelt. Dazu wird die Methode DetermineLocation aufgerufen. Nach dieser Methode steht in derVariable determined alle passenden Instructions. In der Methode AnalyseInstructions wirddiese Liste analysiert, sodass das Ergebnis mit der besten Überstimmung zurückgegeben wird.

1 private Device DetermineDevice(string[] commandTerms)2 {3 List<Device> determinedDevices = new List<Device>();4 foreach (string commandTerm in commandTerms)5 {6 foreach (Device device in this.AllDevices)7 {8 if (GSA.Stemming(device.Description.ToLower()).Equals(commandTerm.ToLower()))9 {

10 determinedDevices.Add(device);11 }12 }13 }14 if (determinedDevices.Count > 1)15 {16 throw new Exception("Mehrere Devices kann dieses System nicht behandeln.");17 }18 if (determinedDevices.Count == 0) { return null; }19 return determinedDevices[0];20 }

Listing 40: Methode DetermineDevice

Wie bereits erwähnt sucht die Methode DetermineDevice nach dem Device im übergebenen Kom-mando. Dazu wird jeder einzelne Term des Kommandos kontrolliert, ob dieser ein Device ist. DieseÜberprüfung findet in den Zeilen 4–12 statt. Ob ein Term ein Device ist, wurde in dieser Methode so im-plementiert, dass die Liste mit allen Devices abgefragt wird, ob diese den Term als Device enthält. Dabeiwird jedes Device normalisiert. Alle gefundenen Devices werden in der Liste determinedDevicesgespeichert. In Zeile 14 wurden alle Kommando–Terme durchlaufen und determinedDevices ent-hält alle gefundenen Devices. Sollte diese Liste mehr als einen Eintrag haben, wird eine Fehlermeldungausgegeben. Das implementierte System liefert nur Ergebnisse für Kommandos mit einem Device. Wird

89


kein Device gefunden, wird in Zeile 18 der Wert null zurückgegeben. Ansonsten wird in Zeile 19 dasgefundene Device returniert.

Methode DetermineInteraction

1 private List<Tuple<Device, List<Interaction>>> DetermineInteraction(string[]commandTerms, Device determinedDevice)

2 {3 List<Tuple<Device, List<Interaction>>> determined = new List<Tuple<Device,

List<Interaction>>>();4 if (determinedDevice == null)5 {6 determined.Add(new Tuple<Device, List<Interaction>>(null, new List<Interaction>()

{ DetermineInteraction(commandTerms) }));7 }8 else9 {

10 List<Interaction> deviceInteractions = new List<Interaction>();11 List<Interaction> interactions = new List<Interaction>();12 deviceInteractions.AddRange(13 InteractionDatabase.GetInteractions_ByDeviceID(determinedDevice.ID));14 foreach (string commandTerm in commandTerms)15 {16 foreach (Interaction interaction in deviceInteractions)17 {18 if (GSA.Stemming(interaction.Description.ToLower())19 .Equals(commandTerm.ToLower()))20 {21 interactions.Add(interaction);22 }23 }24 }25 if (interactions.Count > 0)26 {27 determined.Add(new Tuple<Device, List<Interaction>>(determinedDevice,

interactions));28 }29 if (determined.Count == 0)30 {31 determined.Add(new Tuple<Device, List<Interaction>>(determinedDevice,

deviceInteractions));32 }33 }34

35 return determined;36 }

Listing 41: Methode DetermineInteraction

Wie oben beschrieben implementiert die Methode DetermineInteraction das Finden der Inter-action im Kommando. In der Methode wird weiterhin auf die bisherige Erkenntnis über das DeviceRücksicht genommen. Die Methode erhält dazu die normalisierten Kommando–Terme und das bisherigeDevice–Objekt. Die Zeilen 4–7 werden ausgeführt, wenn im vorherigen Schritt kein Device gefundenwerden konnte. In diesem Fall ist der übergebene Parameter mit dem Wert null gefüllt. In Zeile 6 wirdsomit versucht nur aus den Kommando–Termen die passende Interaction herauszubekommen. Dazu wirddie Methode DetermineInteraction verwendet. Diese Methode mit einem Parameter ist nach demgleichen Schema wie die Methode DetermineDevice aufgebaut. Die gefundene Interaction oder derWert null, wenn keine Interaction gefunden werden konnte, werden anschließend dem Rückgabewertdetermined hinzugefügt.

90


Der else–Zweig von Zeile 8–33 behandelt den Fall, dass im vorherigen Schritt ein Devi-ce gefunden wurde. Zu Beginn wird die Datenbank gebeten, alle Interactions in die VariabledeviceInteractions hinzuzufügen, die das gefundene Device (determinedDevice) ausfüh-ren kann. Anschließend werden alle normierten Kommando–Terme mit dieser Liste verglichen (Zei-le 14–24). Sollte ein Kommando–Term in der Liste enthalten sein, wird diese Interaction in die Listeinteraction aufgenommen. Wenn Zeile 25 erreicht ist, enthält die Variable interaction alle ge-fundenen Interactions aus dem Kommando–Term, die zusätzlich gültig für das gefundene Device sind.Wenn diese Liste Einträge enthält, wird in Zeile 27 die Rückgabeliste determined mit diesen Einträ-gen befüllt. In den Zeilen 29–32 wird der Fall abgefangen, dass keine passenden Interactions im Kom-mando gefunden wurde. In diesem Fall werden alle möglichen Interactions des Devices der Rückgabeli-ste hinzugefügt.

Methode DetermineLocation

1 private List<DeterminedInstruction> DetermineLocation(string[] commandTerms,List<Tuple<Device, List<Interaction>>> determinedDeviceInteractions)

2 {3 List<DeterminedInstruction> result = new List<DeterminedInstruction>();4 foreach (Tuple<Device, List<Interaction>> item in determinedDeviceInteractions)5 {6 Device determinedDevice = item.Item1;7 List<Interaction> deviceInteractions = item.Item2;8

9 if (determinedDevice == null && deviceInteractions.Count == 0)10 {11 Location determinedLocation = DetermineLocation(commandTerms);12 if (determinedLocation == null)13 {14 continue;15 }16 List<Instruction> instructions =

InstructionDatabase.GetInstruction_ByLocation(determinedLocation.ID);17 foreach (Instruction i in instructions)18 {19 result.Add(new DeterminedInstruction(i.Device, i.Interaction,

i.Location));20 }21 }22 else if (determinedDevice == null)23 {24 if (deviceInteractions.Count != 1)25 {26 throw new Exception("Mehrere Interactions können in diesem Fall nicht

behandelt werden. Es wird eine Interaction erwartet.");27 }28

29 List<Location> interactionLocations = new List<Location>();30 List<Location> locations = new List<Location>();31 interactionLocations.AddRange(32 LocationDatabase.GetLocations_ByInteractionID(deviceInteractions[0].ID));33 foreach (string commandTerm in commandTerms)34 {35 foreach (Location location in interactionLocations)36 {37 if (GSA.Stemming(location.Description.ToLower())38 .Equals(commandTerm.ToLower()))39 {40 locations.Add(location);41 }42 }43 foreach (Location l in locations)44 {45 List<Instruction> instructions =

InstructionDatabase.GetInstruction_ByLocationAndInteraction(l.ID,deviceInteractions[0].ID);

91


46 foreach (Instruction i in instructions)47 {48 result.Add(new DeterminedInstruction(i.Device, i.Interaction,

i.Location));49 }50 }51 }52 }53 // Device ohne Interaction54 else if (deviceInteractions.Count == 0)55 {56 List<Location> deviceLocations = new List<Location>();57 List<Location> locations = new List<Location>();58 deviceLocations.AddRange(59 LocationDatabase.GetLocations_ByDeviceID(determinedDevice.ID));60 foreach (string commandTerm in commandTerms)61 {62 foreach (Location location in deviceLocations)63 {64 if (GSA.Stemming(location.Description.ToLower())65 .Equals(commandTerm.ToLower()))66 {67 locations.Add(location);68 }69 }70 foreach (Location location in locations)71 {72 List<Instruction> instructions =

InstructionDatabase.GetInstruction_ByLocationAndDevice(73 location.ID, determinedDevice.ID);74 foreach (Instruction i in instructions)75 {76 result.Add(new DeterminedInstruction(77 i.Device, i.Interaction, i.Location));78 }79 }80 }81 }82 // Device und Interaction(s) gegeben83 else84 {85 List<Location> deviceInteractionLocations = new List<Location>();86 List<Location> locations = new List<Location>();87 foreach (Interaction interaction in deviceInteractions)88 {89 deviceInteractionLocations.AddRange(90 LocationDatabase.GetLocations_ByDeviceIDAndInteractionID(91 determinedDevice.ID, interaction.ID));92 foreach (string commandTerm in commandTerms)93 {94 foreach (Location location in deviceInteractionLocations)95 {96 if (GSA.Stemming(location.Description.ToLower())97 .Equals(commandTerm.ToLower()))98 {99 locations.Add(location);

100 }101 }102 foreach (Location location in locations)103 {104 result.Add(new DeterminedInstruction(determinedDevice,

interaction, location));105 }106 }107 }108 if (result.Count == 0)109 {110 foreach (Interaction interaction in deviceInteractions)111 {112 List<Instruction> instructions =

92


InstructionDatabase.GetInstruction_ByInteractionAndDevice(113 interaction.ID, determinedDevice.ID);114 foreach (Instruction i in instructions)115 {116 result.Add(new DeterminedInstruction(i.Device, i.Interaction,

i.Location));117 }118 }119 }120 }121 }122 return result;123 }

Listing 42: Methode DetermineLocation

Die Methode DetermineLocation (Codeabbildung 42) ermittelt anhand der bisher herausgefunde-nem Device und Interactions und dem Kommando die dazu passende Location. Zum besseren Verständ-nis werden in den Zeile 6 und 7 namenhafte Variablen für das bisherige Device und die Interactionsgewählt und zugewiesen. In dieser Methode werden insgesamt vier unterschiedliche Fälle betrachtet:

1. Es wurde bisher kein Device und keine Interaction im Kommando gefunden (Zeile 9–21):Es wird die Methode DetermineLocation aufgerufen, die von der Logik her genauso aufge-baut ist wie DetermineDevice und DetermineInteraction. Der Rückgabewert dieserMethode ist die gefundene Location im Kommando oder der Wert null. Nur wenn eine Loca-tion gefunden wurde, werden anschließend alle Instructions aus der Datenbank abgefragt, die zudieser Location gehören. Diese Antwort wird in die Rückgabe–Variable dieser Methode resultgespeichert.

2. Es wurde bisher kein Device und mindestens eine Interaction im Kommando gefunden (Zeile 22–52):Als erstes wird überprüft, ob mehr als eine Interaction bekannt sind. Für diesen Fall ist das Systemnicht ausgelegt. Dementsprechend wird eine Fehlermeldung ausgegeben und die Interpretation ab-gebrochen. Ansonsten wird in Zeile 31 die Datenbank gebeten alle Locations zurückzugeben, diezu dieser einen Interaction gehören. Als nächstes werden die einzelnen Kommando–Terme durch-laufen und überprüft, ob diese eine Location beschreibt. Gefundene Locations als Term werdenin die Liste locations aufgenommen. Nachdem alle Kommando–Terme durchlaufen wurden,werden alle Instructions zu allen gefundenen Locations und der aus der vorherigen Methode ge-wonnenen Interaction aus der Datenbank abgefragt. Diese Instructions werden in die Rückgabe–Variable result gespeichert und die Bearbeitung dieses Falles ist beendet.

3. Es wurde bisher ein Device und keine Interaction im Kommando gefunden (Zeile 54–81):Als erstes werden alle Locations aus der Datenbank gespeichert, die zu dem Device gehören. Aufdiese Liste wird nach Locations im Kommando–Term gesucht. Anschließend wird eine Store–Procedure aufgerufen, die alle Instructions liefert, die aus den gefundenen Locations und demDevice bestehen. Diese Instructions werden zum Schluss in die Propertie result geschrieben.

93


4. Es wurde bisher ein Device und mindestens eine Interaction im Kommando gefunden (Zeile 83–120):Ziel dieses else–Zweiges ist es eine Location zu finden, welche zu dem gefundenen Deviceund den Interactions passt. Dazu werden alle gefundenen Interactions durchlaufen. Je Interactionwerden die Locations aus der Datenbank abgefragt, welche mit der Interaction und dem Deviceübereinstimmen. Mit diesen Orten werden die Kommando–Terme durchlaufen. Jede gefundeneLocation im Kommando wird in der result–Variable gespeichert. Somit stehen nach Durchlau-fen der foreach–Schleife aus Zeile 87–106 die gefundenen Locations in der Variable result,die mit dem bisher gefundenem Device und den Interactions übereinstimmt und im Kommandoauftraten. Sollte die result–Variable keinen Eintrag vorweisen, wurde keine passende Locati-on gefunden. Dann werden in den Zeilen 110–118 alle Instructions in die Rückgabevariable ge-schrieben, die aus dem gefundenen Device, den Interactions und allen dazu passenden Locationsbestehen.

Zum Schluss liefert diese Methode eine Liste bestehend aus DeterminedInstruction–Objekten.Diese Klasse wurde nach dem Value Objekt Entwurfsmuster realisiert und enthält nur einen Konstruktorund seine Properties. Insgesamt werden dem Konstruktor alle drei Properties (Device, Interaction,Location) übergeben, die ein DeterminedInstruction–Objekt beschreiben.

1 public class DeterminedInstruction2 {3 public DeterminedInstruction(Device device, Interaction interaction, Location

location)4 {5 Device = device;6 Interaction = interaction;7 Location = location;8 }9

10 #region Properties11 public Device Device { get; private set; }12 public Interaction Interaction { get; private set; }13 public Location Location { get; private set; }14 #endregion Properties15 }

Listing 43: Klasse DeterminedInstruction

94



Nachdem auch die Location durch die Methode DetermineLocation ermittelt wurde, wird als letz-ter Schritt der Interpretation dieses Models die Methode AnalyseInstructions aufgerufen.

1 private DeterminedInstruction AnalyseInstructions(List<DeterminedInstruction> determined)2 {3 int anz = determined.Count;4 if (anz == 0)5 {6 throw new Exception("Keine Ergebnis-Kommandos gefunden.");7 }8 else if (anz == 1)9 {

10 return determined[0];11 }12 else13 {14 throw new Exception($"Zu viele Ergebnis-Kommandos gefunden. Anzahl: {anz}");15 }16 }

Listing 44: Methode AnalyseInstructions

Diese Methode wertet die aus den vorherigen Methoden ermittelte Instructionliste aus. Es werden dreiFälle ausgewertet. Sollte die Liste leer sein, wird eine entsprechende Meldung zurückgegeben (Zeile 4–7). Hat das System mehr als eine passende Instruction zu dem gegebenen Kommando gefunden, wirdeine Fehlermeldung ausgegeben. Die Liste an Instructions kann nicht nach Relevanz bewertet werden,sodass eine sinnvolle Einschränkung auf eine Instruction unmöglich ist (Zeile 12–15). Nur wenn dieInterpretation nur eine Intersection herausbekam, wird diese als Ergebnis zurückgeliefert.

5.9 Aufruf der Anwendung

Die in dieser Masterarbeit erstellte Anwendung SPRInterpretationTool wurde, wie bereits erwähnt, alsKonsolenanwendung entwickelt. Diese kann auf zwei unterschiedliche Arten gestartet werden.

Möglichkeit 1 - Start der Anwendung mit zusätzlich drei ParameternArt 1 ist der Start der Anwendung mit Angabe von drei Parametern. Dadurch ergibt sich folgende Syntax:

SPRInterpretationTool.exe NORMALIZE MODELVARIANTE KOMMANDO

Parameter mögliche Werte

NORMALIZE 0 = keine Normalisierung der Tokens vornehmen1 = Tokens normalisieren

MODELVARIANTE 1 = Boolean Retrieval Model2 = Fuzzy Logic Model3 = Alexa–Äquivalentes Model

KOMMANDO das zu interpretierende Kommando

95


Der erste Parameter gibt an, ob eine Normalisierung der Tokens stattfinden soll. Soll dies der Fall sein,ist eine 1 zu übergeben, ansonsten eine 0. Die Model Variante wird der Anwendung mit dem zweitenParameter mitgeteilt. Für die Model–Varianten sind folgende Parameterwerte anzugeben:

• 1 = Boolean Retireval Model

• 2 = Fuzzy Logic Model

• 3 = Alexa–Äquivalentes Model

Der letzte Parameter ist das Kommando, welches interpretiert werden soll.

1 static int Main(string[] args)2 {3 if (args == null || args.Length != 3)4 {5 // Interaktive Variante6 [...]7 }8 else9 {

10 // parametergesteuerte Ausführen11 if (args.Length != 3)12 {13 Console.Error.WriteLine("Bitte die Parameter richtig übergeben.");14 return 1;15 }16

17 bool normalize = (args[0] == "1");18 InterpreterControl.VARIANTE variante;19 switch (args[1])20 {21 case "1":22 variante = InterpreterControl.VARIANTE.BooleanRetrieval;23 break;24 case "2":25 variante = InterpreterControl.VARIANTE.FuzzyLogic;26 break;27 case "3":28 variante = InterpreterControl.VARIANTE.AlexaAequivalentesModel;29 break;30 default:31 Console.Error.WriteLine($"Die Variante {args[1]} ist nicht

implementiert.");32 return 1;33 }34

35 string command = args[2];36

37 StartInterpretation(normalize, variante, command);38 Console.WriteLine("Result");39 return 0;40 }41 }

Listing 45: Methode Main

Die Methode Main ist der Startpunkt der Anwendung SPRInterpretationTool. In der if–Bedingung (Zeile3) wird die Anzahl der Parameter kontrolliert. Nur wenn drei Parameter zum Anwendungsstart übergebenwurden, wird der Code für die parametergesteuerte Ausführung ausgeführt (Zeile 8–41). In Zeile 17 wirddie Hilfsvariable normalize mit dem ersten Parameter zugewiesen. Nur wenn als Parameter eine 1übergeben wurde, wird in dieser Zeile die Variable auf true gesetzt. In jedem anderen Fall, auch wennein anderes Zeichen übergeben wird, wird die Variable auf false gesetzt, sodass keine Normalisierung

96


der Terme durchgeführt wird. In der switch–Anweisung aus Zeile 19–34 wird die Variante des Modelsgesetzt. Bei einem dem System unbekannten Wert wird eine entsprechende Fehlermeldung ausgegeben.In Zeile 35 wird der letzte Parameter, das Kommando, zwischengespeichert. Danach wird in Zeile 37 dieeigentliche Interpretation ausgeführt. Dies übernimmt die Methode StartInterpretation, welchedie drei eingelesenen Parameter als Übergabeparameter erhält. Die interpretierte Intersection (Aktion)wird dem Aufrufer dieser Anwendung zurückgegeben.

Möglichkeit 2 - Als KonsolenanwendungDie zweite Möglichkeit ist der Aufruf der Anwendung SPRInterpretationTool als Konsolenanwendung.Nachdem die Anwendung gestartet wurde, wird der Anwender gebeten, insgesamt drei Eingaben zu tä-tigen.

Abbildung 25: Eingabe, ob die Terme mit dem German Stemming Alorithmus normalisiertwerden sollen

Als Erstes wird der Anwender abgefragt, ob die Normalisierung der Tokens durchgeführt werden soll.Durch die entsprechende Eingabe kann er seine Entscheidung dem System mitteilen.

Abbildung 26: Abfrage der Model–Variante

Als Zweites fragt die Anwendung nach dem Model, welches für die Interpretation angewendet werdensoll. Durch eine Eingabe der dafür vorgeschriebenen Zahl wird dieses Model dem System vorgeschrie-ben.

Abbildung 27: Eingabe eines Kommandos

Mit dem letzten Dialog wird der Anwender aufgefordert das zu interpretierende Kommando einzugeben.Nach dieser Eingabe interpretiert die Anwendung dieses Kommando und präsentiert anschließend demAnwender sein Ergebnis im Konsolenfenster. Durch drücken einer belieben Taste kann der Anwender einweiteres Kommando interpretieren lassen. Jede Eingabe kann durch die Eingabe „EXIT“ abgebrochenwerden.

97

6 REALISIERUNG VOM VEKTORRAUM–MODEL

6 Realisierung vom Vektorraum–Model

Die Implementierung des Vektorraum–Models wurde mit der Anwendung MATLAB R2018b(9.5.0.944444) 64–bit durchgeführt. Zusätzlich wurde die Erweiterung Text Analytics Toolbox verwen-det. Text Analytics Toolbox bietet Algorithmen und Visualisierungen zur Vorverarbeitung, Analyse undModellierung von Textdaten. Die Text Analytics Toolbox kann Texte aus gängigen Dateiformaten extra-hieren, Rohtext vorverarbeiten, einzelne Wörter extrahieren, Text in numerische Darstellungen konvertie-ren und statistische Modelle erstellen. Mit maschinellen Lerntechniken wie LSA, LDA und Worteinbet-tungen können Cluster gefunden und Features aus hochdimensionalen Textdatensätzen erstellt werden.

Die Informationen über MATLAB stammen aus deren Dokumentation [18]. Für die Realisierung desVektorraum Models wurde die Dokumentation der Text Analytics Toolbox [19] verwendet.

6.1 Word embedding

Word embedding (Worteinbettung) ist der Sammelbegriff für eine Reihe von Sprachmodellierungs–und Feature–Lerntechniken im Natural language processing (NLP). Dabei werden Wörter oder Phra-sen aus dem Wortschatz auf Vektoren reeller Zahlen abgebildet. Konzeptionell handelt es sich um ei-ne mathematische Einbettung von einem Raum mit einer Dimension pro Wort zu einem kontinuier-lichen Vektorraum mit viel weniger Dimensionen. In dieser Masterarbeit wurde eine solche Abbil-dung mit der Methode trainWordEmbedding erstellt. Die Syntax dieser Methode lautet: emb =trainWordEmbedding(filename). Als Übergabeparameter erhält diese Methode den Namen ei-ner Textdatei. Diese Datei ist eine Sammlung von Dokumenten im UTF-8 Format. Die einzelnen Doku-menten sind zeilenweise separiert und die Wörter innerhalb eines Dokuments sind mit Leerzeichen von-einander getrennt. Die Methode trainWordEmbedding trainiert eine Einbettung von Wörtern mitdieser Dokumentensammlung. Als Rückgabewert liefert die Methode ein wordEmbedding–Objekt.Ein wordEmbedding–Objekt weist Wörter Vektoren zu und andersherum. Die Vektoren werden ver-sucht so zu bilden, dass die Semantik der Wörter bestehen bleibt. Dadurch haben ähnliche Wörter ähnli-che Vektoren. Bei einigen Einbettungen lassen sich Beziehungen zwischen den Wörtern finden, wie z.B.„König ist zur Dame wie Mann zur Frau“. In Vektorform ist diese Beziehung König - Mann + Frau =Dame. Die Methode trainWortEmbedding nimmt weitere Argumente entgegen. Diese Argumentelauten:

• Dimension des wordEmbedding–Objekts. Default–Wert ist 100.

• Größe des Kontext–Fensters. Default–Größe ist 5.

• Skip gram (Default) oder continuous bag–of–words (cbow) Model.

• Faktor zur Ermittlung der word discard rate. Default–Wert liegt bei 1e−4.Die Funktion verwirft ein Wort aus dem Eingabefenster mit der Wahrscheinlichkeit 1−

√( t

f )−tf ,

wobei f die Unigram-Wahrscheinlichkeit des Wortes ist und t der DiscardFactor ist. Normalerwei-se liegt der DiscardFactor im Bereich von 1e−3 bis 1e−5.

• Verlustfunktion (loss function) negative sampling (Default), hierarchical softmax oder softmax.

• Anzahl der negative samles für die negative sampling Verlustfunktion. Default–Anzahl ist 5.

• Anzahl der Trainings–Epochen. Default–Wert ist 5.

98


• Minimale Anzahl an Wörter, die in die Einbettung einbezogen werden sollen. Default–Wert ist 5.Die Funktion entfernt alle Wörter aus dem Vokabular, die seltener während der Epochendurchläufein den Trainingsdaten auftraten als die angegebene Anzahl.

• Inklusiver Bereich für das n–gram–Subwort. Default–Vektor ist [3 6].

• Anfangslernrate (Default–Wert ist 0.05)

• Rate für die Aktualisierung der Lernrate. Default–Wert ist 100.Die Lernrate sinkt linear in Schritten aller N Wörter auf Null, wobei N die UpdateRate ist.

• Verbose level (Ausführlichkeitsstufe).Entweder werden keine ausführliche Ausgaben angezeigt oder es werden Fortschrittsinformatio-nen angezeigt. Standardmäßig werden die Informationen angezeigt.

Die Datenbasis für das Vektorraum–Model bildet die Datei „text_pages_04_shuffeld“, die von Herr Grefbereitgestellt wurde. Sie ist auf der beigefügten CD enthalten. Die Datei beinhaltet alle Wikipedia–Einträge vom 03.07.2018. Diese sind im XML–Dateiformat abgelegt. Folgende Schritte wurden bereitsvon Herr Gref auf den Wikipedia–Einträgen ausgeführt, sodass diese Datei als Ergebnis entstand:

1. Alles außer der Bereich zwischen dem <text>– und dem </text>–Tag wurde aus der ur-sprünglichen Datei entfernt.

2. Alle Zahlen wurden in das entsprechende Wort gewandelt

3. Eine Normalisierung auf dem übrigen Text

• übrige HTML–Tags in ASCII–Zeichen umgewandelt

• Wikipedia–Formationszeichen entfernt

• Referenzen entfernt

• Nach jedem Satzzeichen ein Absatz gesetzt

4. alles außer Buchstaben, Zahlen und Umlaute entfernt

5. überflüssige Leerzeichen entfernt

6. alle Zeichen in Kleinbuchstaben konvertiert

Somit steht in der „text_pages_04_shuffeld“–Datei in jeder Zeile ein Satz. Jeder dieser Sätze besteht nuraus Wörtern in Kleinbuchstaben.

99


Abbildung 28: Erstellen eines WordEmbedding–Objekts

Mit dem Befehl emb = trainWordEmbedding(filename), wobei filename der Pfad zu derWikipedia–Einträge–Datei ist, wurde das wordEmbedding–Objekt emb erstellt. In diesem befindet sichein Vokabular mit knapp 3 Millionen Termen. Das Netz wurde mit einer Verlustrate von 0,0694252trainiert. Diese Methode benötigte zum Berechnen des wordEmbedding–Objekt zu den Sätzen aus dieserDatei mehrere Stunden, sodass die Ergebnisvariable mit dem Befehl

writeWordEmbedding(emb,“deWikiEmbedding.vec“)in die Datei deWikiEmbedding.vec gesichert wurde. Diese Datei ist ebenfalls auf der beigelegtenCD enthalten. Der Aufruf der einzelnen Schritte ist in der Abbildung 28 dargestellt.

1 badezimmer = word2vec(emb,’Badezimmer’);2 buero = word2vec(emb,’Büro’);3 esszimmer = word2vec(emb,’Esszimmer’);4 fenster = word2vec(emb,’Fenster’);5 flur = word2vec(emb,’Flur’);6 garagentor = word2vec(emb,’Garagentor’);7 haustuer = word2vec(emb,’Haustür’);8 kinderzimmer = word2vec(emb,’Kinderzimmer’);9 kueche = word2vec(emb,’Küche’);

10 labor = word2vec(emb,’Labor’);11 licht = word2vec(emb,’Licht’);12 musik = word2vec(emb,’Musik’);13 rollladen = word2vec(emb,’Rollladen’);14 wohnzimmer = word2vec(emb,’Wohnzimmer’);15 an = word2vec(emb,’an’);16 anhalten = word2vec(emb,’anhalten’);17 anschalten = word2vec(emb,’anschalten’);18 auf = word2vec(emb,’auf’);19 aus = word2vec(emb,’aus’);20 ausschalten = word2vec(emb,’ausschalten’);21 das = word2vec(emb,’das’);22 der = word2vec(emb,’der’);23 die = word2vec(emb,’die’);24 ein = word2vec(emb,’ein’);25 einschalten = word2vec(emb,’einschalten’);26 fahren = word2vec(emb,’fahren’);27 hoch = word2vec(emb,’hoch’);28 im = word2vec(emb,’im’);29 in = word2vec(emb,’in’);30 rauf = word2vec(emb,’rauf’);31 rauffahren = word2vec(emb,’rauffahren’);32 runter = word2vec(emb,’runter’);33 runterfahren = word2vec(emb,’runterfahren’);34 schalten = word2vec(emb,’schalten’);

100


35 schliessen = word2vec(emb,’schließen’);36 stoppen = word2vec(emb,’stoppen’);37 zu = word2vec(emb,’zu’);38 oeffnen = word2vec(emb,’öffnen’);

Listing 46: alle Term–Vektoren aus dem WordEmbedding–Objekt ermitteln

Die Methode word2vec gibt den Vektor eines Wortes aus dem WordEmbedding–Objekt zurück. Wenndas Wort nicht im Embedding–Vokabular enthalten ist, gibt die Funktion eine Reihe von NaNs zurück.Die Methode erwartet als ersten Parameter das erstelle WordEmbedding–Objekt. Als zweiten Parameterwird der Methode das Wort in Anführungszeichen übergeben. Diese Methode wurde für jedes Wortausgeführt, welches die anderen Modelle kannten, was im Quellcode 46 sichtbar ist.

Sollte das übergebene Kommando einen unbekannten Term enthalten, wird zu diesem Term mit dergerade beschriebenen Methode word2vec ein Vektor berechnet. Anschließend wird zu diesem Vektorund allen anderen Term–Vektoren der euklidische Abstand berechnet. Der Term mit dem geringsteneuklidischer Abstand zum unbekannten Term–Vektor ist dem unbekannten Term am Nächsten. Diesbedeutet, dass die beiden Terme Synonyme sind. MATLAB liefert die Funktion norm, die mit der Syntaxd = norm(~a − ~b) den euklidischen Abstand d zwischen den Vektoren ~a und ~b berechnet. Quellcode47 zeigt einen Ausschnitt der ausgeführten Befehle bei diesem Vorgehen.

1 d_BadezimmerJalousie = norm(badezimmer-jalousie)2 d_BueroJalousie = norm(buero-jalousie)3 d_EsszimmerJalousie = norm(esszimmer-jalousie)4 d_FensterJalousie = norm(fenster-jalousie)5 [...]6 d_OeffnenJalousie = norm(oeffnen-jalousie)

Listing 47: Berechnungen der euklidischen Distanz zwischen den bekannten Termen und demumbekannten Term

101


Jalousie Jalousie

Badezimmer 3, 9438 ausschalten 4, 6028Büro 5, 0454 das 4, 5748Esszimmer 4, 1081 der 4, 5208Fenster 3, 6348 die 4, 3437Flur 5, 3108 ein 4, 6747Garagentor 4, 1029 einschalten 4, 3785Haustür 4, 3174 fahren 5, 2036Kinderzimmer 4, 2720 hoch 4, 7344Küche 5, 1597 im 4, 6222Labor 5, 2913 in 4, 6313Licht 4, 2394 rauf 5, 2955Musik 5, 3053 rauffahren NaNRollladen 3, 0985 runter 4, 8463Wohnzimmer 4, 0948 runterfahren 4, 4828an 4, 5988 schalten 4, 3783anhalten 4, 8707 schließen 4, 6470anschalten 4, 3014 stoppen 5, 0954auf 4, 4858 zu 4, 6981aus 4, 6354 öffnen 4, 2190

Tabelle 6: Euklidischen Distanzen zwischen allen Term–Vektoren und des Jalousie–Vektors

0,0000

1,0000

2,0000

3,0000

4,0000

5,0000

6,0000

Jalousie

Abbildung 29: Grafische Darstellung des Ergebnisses aus Tabelle 6

102


In der Tabelle 6 und grafisch in Abbildung 29 ist das Ergebnis der euklidischen Berechnungen darge-stellt. Der Vektor des Terms „Rollladen“ hat den geringsten euklidischen Abstand zum Vektor des Terms„Jalousie“. Daraus wird abgeleitet, dass das Wort „Jalousie“ ein Synonym für das Wort „Rollladen“ ist.

Die selbe Idee kann für die Interpretation von einem Kommando verwendet werden. Ein Kommandowird in diesem Model durch die Addition der Vektoren der Terme gebildet. D.h. das Kommando „Fahredie Rollladen im Labor runter“ wird in diesem Model durch folgenden Vektor repräsentiert: ~Fahre +~die + ~Rollladen + ~im + ~Labor + ~runter

Das Vektorraum–Model wandelt das übergebene Kommando in dessen Vektor um. Das selbe wurdebereits für alle dem Model bekannten Kommandos durchgeführt. Zwischen alle Vektoren der bekanntenKommandos und dem Vektor des übergebenen Kommandos wird die euklidische Distanz berechnet. DerVektor mit der kleinsten euklidischen Distanz zum Vektor des übergebenen Kommandos ist somit dasErgebnis der Interpretation.

1 filename = "C:\Users\Christoph\Documents\MATLAB\deWikiEmbedding.vec";2 emb = readWordEmbedding(filename);3 C = {4 [word2vec(emb,"haustür")+word2vec(emb,"auf")],5 [word2vec(emb,"haustür")+word2vec(emb,"zu")],6 [word2vec(emb,"garagentor")+word2vec(emb,"auf")],7 [word2vec(emb,"garagentor")+word2vec(emb,"zu")],8 [word2vec(emb,"rollladen")+word2vec(emb,"küche")+word2vec(emb,"hoch")],9 [word2vec(emb,"rollladen")+word2vec(emb,"küche")+word2vec(emb,"runter")],

10 [word2vec(emb,"rollladen")+word2vec(emb,"küche")+word2vec(emb,"stopp")],11 [word2vec(emb,"rollladen")+word2vec(emb,"wohnzimmer")+word2vec(emb,"hoch")],12 [word2vec(emb,"rollladen")+word2vec(emb,"wohnzimmer")+word2vec(emb,"runter")],13 [word2vec(emb,"rollladen")+word2vec(emb,"wohnzimmer")+word2vec(emb,"stopp")],14 [word2vec(emb,"rollladen")+word2vec(emb,"badezimmer")+word2vec(emb,"hoch")],15 [word2vec(emb,"rollladen")+word2vec(emb,"badezimmer")+word2vec(emb,"runter")],16 [word2vec(emb,"rollladen")+word2vec(emb,"badezimmer")+word2vec(emb,"stopp")],17 [word2vec(emb,"rollladen")+word2vec(emb,"büro")+word2vec(emb,"hoch")],18 [word2vec(emb,"rollladen")+word2vec(emb,"büro")+word2vec(emb,"runter")],19 [word2vec(emb,"rollladen")+word2vec(emb,"büro")+word2vec(emb,"stopp")],20 [word2vec(emb,"rollladen")+word2vec(emb,"labor")+word2vec(emb,"hoch")],21 [word2vec(emb,"rollladen")+word2vec(emb,"labor")+word2vec(emb,"runter")],22 [word2vec(emb,"rollladen")+word2vec(emb,"labor")+word2vec(emb,"stopp")],23 [word2vec(emb,"rollladen")+word2vec(emb,"kinderzimmer")+word2vec(emb,"hoch")],24 [word2vec(emb,"rollladen")+word2vec(emb,"kinderzimmer")+word2vec(emb,"runter")],25 [word2vec(emb,"rollladen")+word2vec(emb,"kinderzimmer")+word2vec(emb,"stopp")],26 [word2vec(emb,"rollladen")+word2vec(emb,"esszimmer")+word2vec(emb,"hoch")],27 [word2vec(emb,"rollladen")+word2vec(emb,"esszimmer")+word2vec(emb,"runter")],28 [word2vec(emb,"rollladen")+word2vec(emb,"esszimmer")+word2vec(emb,"stopp")],29 [word2vec(emb,"licht")+word2vec(emb,"küche")+word2vec(emb,"an")],30 [word2vec(emb,"licht")+word2vec(emb,"küche")+word2vec(emb,"aus")],31 [word2vec(emb,"licht")+word2vec(emb,"wohnzimmer")+word2vec(emb,"an")],32 [word2vec(emb,"licht")+word2vec(emb,"wohnzimmer")+word2vec(emb,"aus")],33 [word2vec(emb,"licht")+word2vec(emb,"badezimmer")+word2vec(emb,"an")],34 [word2vec(emb,"licht")+word2vec(emb,"badezimmer")+word2vec(emb,"aus")],35 [word2vec(emb,"licht")+word2vec(emb,"büro")+word2vec(emb,"an")],36 [word2vec(emb,"licht")+word2vec(emb,"büro")+word2vec(emb,"aus")],37 [word2vec(emb,"licht")+word2vec(emb,"labor")+word2vec(emb,"an")],38 [word2vec(emb,"licht")+word2vec(emb,"labor")+word2vec(emb,"aus")],39 [word2vec(emb,"licht")+word2vec(emb,"kinderzimmer")+word2vec(emb,"an")],40 [word2vec(emb,"licht")+word2vec(emb,"kinderzimmer")+word2vec(emb,"aus")],41 [word2vec(emb,"licht")+word2vec(emb,"flur")+word2vec(emb,"an")],42 [word2vec(emb,"licht")+word2vec(emb,"flur")+word2vec(emb,"aus")],43 [word2vec(emb,"licht")+word2vec(emb,"esszimmer")+word2vec(emb,"an")],44 [word2vec(emb,"licht")+word2vec(emb,"esszimmer")+word2vec(emb,"aus")],45 [word2vec(emb,"musik")+word2vec(emb,"küche")+word2vec(emb,"an")],46 [word2vec(emb,"musik")+word2vec(emb,"küche")+word2vec(emb,"aus")],47 [word2vec(emb,"musik")+word2vec(emb,"wohnzimmer")+word2vec(emb,"an")],48 [word2vec(emb,"musik")+word2vec(emb,"wohnzimmer")+word2vec(emb,"aus")],49 [word2vec(emb,"musik")+word2vec(emb,"badezimmer")+word2vec(emb,"an")],50 [word2vec(emb,"musik")+word2vec(emb,"badezimmer")+word2vec(emb,"aus")],

103


51 [word2vec(emb,"musik")+word2vec(emb,"büro")+word2vec(emb,"an")],52 [word2vec(emb,"musik")+word2vec(emb,"büro")+word2vec(emb,"aus")],53 [word2vec(emb,"musik")+word2vec(emb,"labor")+word2vec(emb,"an")],54 [word2vec(emb,"musik")+word2vec(emb,"labor")+word2vec(emb,"aus")],55 [word2vec(emb,"musik")+word2vec(emb,"kinderzimmer")+word2vec(emb,"an")],56 [word2vec(emb,"musik")+word2vec(emb,"kinderzimmer")+word2vec(emb,"aus")],57 [word2vec(emb,"fenster")+word2vec(emb,"wohnzimmer")+word2vec(emb,"auf")],58 [word2vec(emb,"fenster")+word2vec(emb,"wohnzimmer")+word2vec(emb,"zu")],59 [word2vec(emb,"fenster")+word2vec(emb,"kinderzimmer")+word2vec(emb,"auf")],60 [word2vec(emb,"fenster")+word2vec(emb,"kinderzimmer")+word2vec(emb,"zu")],61 [word2vec(emb,"fenster")+word2vec(emb,"badezimmer")+word2vec(emb,"auf")],62 [word2vec(emb,"fenster")+word2vec(emb,"badezimmer")+word2vec(emb,"zu")]63 };

Listing 48: Umwandlung der Kommandos in Vektoren

Im Quellcode 48 werden alle dem Model bekannten Kommandos in Vektoren umgewandelt. Die Vekto-ren werden anschließend in die Variable C zwischengespeichert. In Zeile 2 wird das WordEmbedding–Objekt aus einer Datei gelesen. Durch die Verwendung des gleichen WordEmbedding–Objektes ist dieUmwandlung der Kommandos immer identisch.

1 queryCommand = word2vec(emb,"eingangstür")+word2vec(emb,"öffnen");

Listing 49: Umwandlung des übergebenen Kommandos in ein Vektor

Im Quellcode 49 wird das übergebene Kommando in einen Vektor umgewandelt. Hierbei muss auch aufdem selben WordEmbedding–Objekt die Umwandlung stattfinden, damit immer der gleiche Vektor alsErgebnis herauskommt.

1 minDistance = norm(C{1,1}-queryCommand);2 resIndex = 1;3 for i=2:length(C)4 euklidDistanz=norm(C{i,1}-queryCommand);5 if euklidDistanz <= minDistance6 minDistance = euklidDistanz;7 resIndex = i;8 end9 end

10 resIndex

Listing 50: Ermittlung des am übergebenen Kommando Vektor nächsten Vektors

Im Quellcode 50 soll das Kommando gefunden werden, was dem übergebenen Kommando am näch-sten ist. Dazu wird zuerst minDistance mit dem euklidischen Abstand des ersten Kommando-Vektors initialisiert. Anschließend wird durch die for–Schleife der euklidische Abstand zwischen jedemKommando–Vektor und dem übergebenen Kommando–Vektor berechnet. Durch die Zeilen 4–7 steht zujedem Schleifendurchlauf in der Variable minDistance die aktuell kleinste berechnete euklidischeDistanz. Zusätzlich wird in der Variable resIndex der Index des zur kleinsten euklidischen Distanzgehörigen Vektors gespeichert. Zum Schluss wird in Zeile 9 der Index des Vektors ausgegeben, der dengeringsten euklidischen Abstand zum übergebenen Kommando–Vektor besitzt. D.h. dieses Kommandoist dann das Ergebnis dieses Models.

104

7 EVALUATION

7 Evaluation

In diesem Kapitel wird der UnitTest vorgestellt, der den implementierten German Stemming Algorith-mus auf Richtigkeit prüft. Die anderen implementierten UnitTest–Methoden werden nicht in diesemKapitel erläutert, da die erwarteten Werte in diesen Fällen über die Datenbank berechnet werden. Die-se erwarteten Ergebnisse werden dann mit den Ergebnissen des jeweils implementierten Algorithmusverglichen.

In diesem Kapitel werden die einzelnen UnitTest–Methoden vorgestellt. Diese sollen den jeweils imple-mentierten Algorithmus auf Richtigkeit prüfen.

Anschließend werden alle vier Modelle bewertet und miteinander verglichen. Für die Evaluation wurdenspezielle Datensätze erstellt. Diese beinhaltet 555 Hausautomatisierung–Kommandos. Zusätzlich wur-den weitere Kommandos definiert, um die Synonyme abzubilden. Im weiteren Verlauf dieses Kapitelswerden diese Kommandos Evaluation–Kommandos genannt. Für die Evaluation werden jedem Modeldie einzelnen Kommandos der Datensätze übergeben. Jedes einzelne Model interpretiert das übergebe-ne Kommando entsprechend seines Algorithmus auf seine eigene Art und Weise. Nach der Ausführungdes Models wird das Ergebnis mit der erwarteten Aktion verglichen. Die 555 Kommandos wurden fürdie Retrieval Modelle für die Erstellung des inverted index verwendet. Somit sind diese Kommandosden Modellen bekannt und sollten dementsprechend je Kommando das richtige Ergebnis liefern. Einenähnlichen Aufbau verwendet das Alexa–Äquivalente Modell. Aus diesem Grund sollte für die bekanntenKommandos die richtige Aktion ermittelt werden. Das Vektorraum Model hat als Datenbasis das Voka-bular der Wikipedia–Einträge. Daher kennt dieses Model die Kommandos nicht unbedingt. Bei den Testsder Synonyme sind die Terme nur dem Fuzzy Logic Model nicht bekannt.

7.1 UnitTest – German Stemming Algorithmus

Neben der Konsolenanwendung des SPRInterpretationTools enthält die Projektmappe den UnitTest„UnitTestStemming“. In diesem UnitTest–Projekt wird der in der Anwendung zur Normalisierung derTerme verwendete German Stemming Algorithmus getestet. Dieser Test soll zeigen, dass der realisierteAlgorithmus die Terme richtig normalisiert. Zum Testen wurden die Terme aus den folgenden Inter-netseiten verwendet:

• Vokabular: https://raw.githubusercontent.com/snowballstem/snowball-data/master/german/voc.txt

• Erwartetes Ergebnis des Vokabulars: https://raw.githubusercontent.com/snowballstem/snowball-data/master/german/output.txt

Beide Listen können der beigelegten CD entnommen werden (german_vocalbular.txt und ger-man_vocalbular_stemmer_result.txt).

105

7 EVALUATION

1 [TestMethod]2 public void TestVocabularTextfile()3 {4 string[] vocabularTerms = System.IO.File.ReadAllLines("german_vocalbular.txt");5 string[] stemmedTerms =

System.IO.File.ReadAllLines("german_vocalbular_stemmer_result.txt");6

7 if(vocabularTerms.Length != stemmedTerms.Length)8 {9 Assert.Fail("Anzahl der Terme ist unterschiedlich.");

10 }11

12 int anzError = 0;13 string expected = "";14 string actual = "";15 string currentTerm = "";16 GermanStemmingAlgorithm gsa = new GermanStemmingAlgorithm();17

18 for (int i = 0; i < vocabularTerms.Length; i++)19 {20 expected = stemmedTerms[i];21 currentTerm = vocabularTerms[i];22 actual = gsa.Stemming(currentTerm);23 if (!expected.Equals(actual)) { anzError++; }24 }25

26 Assert.AreEqual(0, anzError);27 }

Listing 51: UnitTest–Methode TestVocabularTextfile

Der Unit–Test TestVocabularTextfile beginnt mit dem Einlesen beider Text–Dateien (Zeile 4und 5). Mit der if–Bedingung wird überprüft, ob die Dateien richtig eingelesen wurden, indem die An-zahl der Terme in beiden Dokumenten auf Gleichheit geprüft werden. Bei erfolgreicher Prüfung wirdin den Zeilen 18–25 jeder Term des Vokabular–Dokuments mit dem realisierten German Stemming Al-gorithmus normalisiert. Dieser normalisierte Term steht anschließend in der Variable actual. In derVariable expected steht der aus dem anderen Dokument erwartete normalisierte Term. In Zeile 23werden beide Terme auf Gleichheit geprüft. Bei Unterschieden wird eine Variable anzError hoch-gezählt. Somit steht in dieser Variablen nach dem Durchlaufen aller Terme die Anzahl an fehlerhaftnormalisierten Termen. In Zeile 26 liefert die Testmethode das Ergebnis dieses Tests. D.h. die Metho-de liefert ein Erfolg, wenn keine Terme fehlerhaft normiert wurden. Ansonsten scheitert der Test. DieVokabular–Datei enthält 35033 Terme, die dieser Test innerhalb von 166 ms umwandelt und überprüft.

7.2 Boolean Retrieval Model

Der erste Test des Boolean Retrieval Model wurde auf den Evaluation–Kommandos ohne Normalisie-rung der Terme ausgeführt. Dieser Test ergab, dass nur die Kommandos richtig erkannt wurden, die aus-schließlich aus Termen aufgebaut sind, die im inverted index des Boolean Retrieval System existieren.Dabei spielt die Reihenfolge der Terme im Evaluation–Kommando keine Rolle. Für alle Evaluation–Kommandos mit Synonymen liefert dieses Model kein Ergebnis. Das entspricht dem für dieses Modelerwarteten Ergebnisses, denn es werden die Terme eines Kommandos mit einer booleschen Operationverknüpft. Weil für eine Gerätesteuerung die Terme eines Kommandos verundet werden, kann diesesSystem entweder die dazugehörige Aktion erkennen oder es liefert kein Ergebnis zurück. Das Systemkann einem übergebenen Kommando nur dann eine Aktion zuordnen, wenn alle Terme des Komman-dos dem System bekannt sind. Kennen heißt in diesem Fall, dass genau dieser Term im inverted indexdes Models enthalten ist. Zu einem für das Model unbekannten Term wird keine posting list gefunden.

106

7 EVALUATION

Während der Zusammenführung (Intersection) der posting lists der Terme sorgt die nicht gefundene po-sting list dazu, dass keine Aktion als Ergebnis herauskommt. Zusammengefasst ist das Boolean RetrievalModel nur für Kommandos geeignet, die aus Termen bestehen, die im Vokabular des Models existieren.Für den Entwickler dieses Models heißt dies, dass jeder mögliche Term, den der Anwender dieses Sy-stems verwenden könnte, vorher definiert und im inverted index aufgenommen werden muss. DiesesVerhalten führt aber auch dazu, dass keine falschen Aktionen erkannt werden können, was bei einigenAnwendungsfällen entscheidend sein kann.

Der zweite Test dieses Models wurde auf normalisierten Termen ausgeführt. Dieser Test hatte die selbenErgebnisse wie der vorherige. Durch die Normalisierung kann somit die Menge an vordefinierten Termenreduziert werden. Terme wie „öffne“, „öffnest“ und „öffnen“ können zu einem Term zusammengefasstwerden. In der unnormalisierten Variante müssten für diese Terme mindestens drei Kommandos definiertwerden. Während in der normalisierten Variante nur ein Kommando definiert werden muss.

7.3 Fuzzy Logic Model

Das Fuzzy Logic Model ist eine Erweiterung des Boolean Retrieval Systems. Während beim BooleanRetrieval System die Terme scharf enthalten sein müssen (Term im Kommando enthalten; Term nicht imKommando enthalten), basiert die Fuzzylogik auf den unscharfen Mengen (Fuzzy-Sets). Ein Term wirdüber dessen Zugehörigkeit im Kommando–Korpus definiert. Weil die Verwendung von normalisiertenTermen am Ergebnis nichts verändert, wird das Fuzzy Logic Model auf normalisierten Termen getestet.Der Test auf den Kommandos, die dem Model bekannt sind, war vollständig erfolgreich. Für alle gete-steten Kommandos mit Synonymen lieferte das Model die richtige Aktion. Es wurde anschließend einweiterer Test mit dem Kommando „Starte die Kaffeemaschine“ ausgeführt. Dieses Kommando kann zukeinem richtigen Ergebnis führen, da die implementierte Gerätesteuerung eine Bedienung der Kaffee-maschine nicht vorgesehen hat. Als Ergebnis liefert dieses Model 93 passende Aktionen, die zum 100%mit dem übergebenen Kommando übereinstimmen. Dabei variiert das angesprochene Device, die auszu-führende Interaction oder die gewählte Location. Dies zeigt, dass dieses System auch falschen Aktionenliefern kann.

7.4 Alexa–Äquivalentes Model

Im Gegensatz zu den beiden Retrieval Modellen kennt das Alexa–Äquivalente Model die vom Anwen-der verwendeten vollständigen Kommandos in Satzform nicht. Die Datensätze dieses Models bauen aufden einzelnen Instructions, die aus einem Device, einer Interaction und einer optionalen Location beste-hen. Die Evaluation dieses Models ergab folgende Erkenntnisse: Für die Kommandos, die sich aus denInstruction–Teilen zusammensetzen, die das Alexa–Äquivalente Model kennt, wurde die richtige Aktionvom Model zurückgegeben. Solange die Synonyme in der entsprechenden Tabelle des Models vorhandensind, liefert dieses Model auch für diese Fälle die richtige Aktion als Ergebnis zurück. Ansonsten liefertdas Alexa–Äquivalente Model mehrere Aktionen, die aus Sicht des Modells das übergebenen Komman-do beschreiben. Auf dieser Liste an Ergebnissen kann ein anderes Modul die Interpretation fortführen.Dazu mehr in Abschnitt 8 „Zusammenfassung & Ausblick“ [Seite 109]. Zusammenfassend lässtsich sagen, dass das Alexa–Äquivalente Model ähnlich dem Fuzzy Logic Model ist. Im Gegensatz zudiesem Model müssen im Alexa–Äquivalente Model die Synonyme in die Datenbasis eingetragen wer-den. Die Konsolenanwendung liefert im Fall, dass mehrere Ergebnisse ermittelt wurden, kein Ergebnis.Weiterhin ist dieses Modell die speichersparenste Variante, da jeder Term nur einmal vorgehalten werdenmuss. Außerdem muss keine Vorberechnung, wie ein inverted index, erfolgen.

107

7 EVALUATION

7.5 Vektorraum – Word2Vec Model

Im Quellcode 48 „Umwandlung der Kommandos in Vektoren“ [Seite 103] wurden dem Vek-torraum Model 59 Kommandos übergeben, mit denen dieses Model die übergebenen Kommandos ver-gleichen soll. Ein Test mit diesen 59 Kommandos als übergebene Kommandos lieferte immer das ge-wünschte Ergebnis. Weitere Testdurchläufe mit anderen Kommandos wurden vom Vektorraum Modelteilweise mit der richtigen Aktion beantwortet. Auf das Kommando „eingangstür schließen“ antwortetedas Model mit der Aktion „haustür öffnen“. Der Vektor dieses Kommandos ist mit einem euklidischenAbstand von 3,58 kleiner als der Abstand 3,69 der Aktion „haustür zu“. Dagegen liefert das Komman-do „haustür schließen“ die Aktion „haustür zu“ mit einem euklidischen Abstand von 2,63. Die Akti-on „haustür öffnen“ hatte zu diesem Kommando einen Abstand von 2,90. Zusammenfassend lässt sichsagen, dass dieses Model zum übergebenen Kommando häufig die richtige Aktion als Ergebnis liefer-te. Trotzdem wurden auch falsche Aktionen vom Model vorgeschlagen. Ein wesentlicher Vorteil desVektorraum Models gegenüber den anderen drei Modellen ist die Datenpflege. Nachdem einmal dasWordEmbedding–Objekt erstellt wurde, ist die Datenbasis dieses Models gegeben. Durch das Hinzufü-gen weiterer Kommandos kann die Rate der Ergebnisse erhöht werden.

108

8 ZUSAMMENFASSUNG & AUSBLICK

8 Zusammenfassung & Ausblick

Keines der im Rahmen dieser Masterarbeit entwickelten Modelle liefert für ein beliebiges Kommandoimmer die richtige Aktion. Deshalb werden in diesem Kapitel zu jedem Model Verbesserungsvorschlägeaufgeführt.

Das Boolean Retrieval Model ist für eine Gerätesteuerung, bei der keine falschen Aktionen erkanntwerden dürfen, perfekt geeignet. Die Datenmenge, die vorher definiert werden muss, lässt sich durch dieNormalisierung der Terme reduzieren. Die Erkennungsrate lässt sich bei diesem Modell nur durch einengrößeren Wortschatz der bekannten Terme steigern.

Das Fuzzy Logic Model liefert immer die gleiche Menge an Ergebnissen. Diese sind nach der Zugehö-rigkeit zum übergebenen Kommando sortiert. Das in dieser Arbeit entwickelte Model liefert einfach denobersten Eintrag als Ergebnis, obwohl der höchste Ogawa–Wert für mehrere Aktionen gilt. Ein weite-res Modul könnte diese Ergebnisse eingrenzen. Eine Idee wäre die Setzung eines Schwellwertes. AlleErgebnisse unter diesem Schwellwert werden vom Modul nicht als Ergebnis angesehen.

Das Alexa–Äquivalente Model kann ebenfalls mehrere Aktionen als Ergebnis haben. Auch hier könnteein weiteres Modul die Ergebnismenge eingrenzen, indem die Ergebnisse mit dem aktuellen Status desGeräts verglichen werden. Liefert das Alexa–Äquivalente Model zum Beispiel folgende Aktionen alsErgebnis zu einer Anfrage

• Rolllade im Wohnzimmer runter

• Rolllade im Wohnzimmer hoch

• Rolllade im Wohnzimmer stopp

könnte eine Statusabfrage der Rolllade im Wohnzimmer diese Menge an Ergebnissen eingrenzen. Ist dieRolllade bereits unten, ist es sehr unwahrscheinlich, dass die erste Aktion vom Anwender gewünscht ist.Weiterhin ist ein stoppen der Rolllade unwahrscheinlich, da sich die Rolllade in einem stehenden Statusbefindet. Somit wäre die Aktion „Rolllade im Wohnzimmer hoch“ für diesen Status der Rolllade amsinnvollsten.

Das Vektorraum Model könnte durch weitere oder für eine Haussteuerung besser geeignete Dokumenteverbessert werden. Die Verteilung der einzelnen Wortvektoren ist noch verbesserungswürdig. Wörter,die semantisch das Gleiche bedeuten, sind noch weit voneinander entfernt. Mit den Einträgen von Wiki-pedia wurden viele Sätze und Wörter im Netz trainiert, aber Wikipedia–Einträge beschreiben selten eineGerätesteuerung. Das Netz sollte durch weitere oder andere Texte, die auf die Kommandos der Geräte-steuerung angepasst sind, trainiert werden. Die Idee ist, durch kontextbezogenere Texte die Verteilungder Wörter zu verbessern.

Eine weitere Erweiterung wäre ein Modul, welches eine fehlende Information oder nicht eindeutige Ak-tionen mit dem Anwender im Dialog klärt. Wenn der Anwender ein Kommando eingibt, für welches dasModel nur eine Interaction ermitteln kann, werden alle Aktionen mit dieser Interaktion zurückgegeben.Die Erweiterung könnte den Anwender in einem Dialog nach dem Device fragen, welches er steuernmöchte.

109

LITERATUR

Literatur

[1] Christopher D. Manning, Prabhakar Raghavan, and Hinrich Schütze. Introduction to InformationRetrieval. Cambridge University Press, September 2008.

[2] Wiktionary (en). hotword - wiktionary. Website, Oktober 2017. Online verfügbar unter https://en.wiktionary.org/wiki/hotword; abgerufen am 23. Oktober 2018.

[3] wikipedia.org. Smart speaker - wikipedia. Website, 09.08.2018, um 22:35 (UTC). Online verfügbarunter https://en.wikipedia.org/wiki/Smart_speaker; abgerufen am 02. Oktober2018.

[4] t3n Magazin | Julian Wölk. User-interfaces für sprachassistenten: Die magie von alexa erklärt |t3n – digital pioneers. Website, Juni 2017. Online verfügbar unter https://t3n.de/news/user-interfaces-fuer-sprachassistenten-831249/; abgerufen am 05. Septem-ber 2018.

[5] Ink amazon.com. Alexa-hilfe - aktivierungswort ändern. Website, 24.08.2018. Online verfüg-bar unter https://www.amazon.de/gp/help/customer/display.html?nodeId=201971890; abgerufen am 05. September 2018.

[6] Lumizil.de | Sabrina. Amazon echo » mit alexa lampen steuern! Website, 04.05.2017.Online verfügbar unter https://www.lumizil.de/magazin/lumitech/amazon-echo-lampen-kinderleicht-mit-smartphones-und-alexa-echo-steuern/;abgerufen am 05. September 2018.

[7] amazon.com. Alexa skills kit - create the interaction model for your skill | custom skills. Web-site, 05.09.2018. Online verfügbar unter https://developer.amazon.com/de/docs/custom-skills/create-the-interaction-model-for-your-skill.html; ab-gerufen am 11. September 2018.

[8] Martin F. Porter. An algorithm for suffix stripping. Data Technologies and Applications, 14(3):130–137, 1980.

[9] Martin F. Porter, Richard Boulton, and Patrick Miles. German stemming algorithm - snow-ball. Website, 7 2018. Online verfügbar unter http://snowballstem.org/algorithms/german/stemmer.html; abgerufen am 23. Oktober 2018.

[10] Martin F. Porter, Richard Boulton, and Patrick Miles. German stemming algorithm - snow-ball. Website, 7 2018. Online verfügbar unter http://snowballstem.org/texts/r1r2.html; abgerufen am 20. November 2018.

[11] Martin F. Porter, Richard Boulton, and Patrick Miles. German stemming algorithm - snow-ball. Website, 7 2018. Online verfügbar unter http://snowballstem.org/texts/glossary.html; abgerufen am 30. Oktober 2018.

[12] Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean. Efficient estimation of word represen-tations in vector space. CoRR, abs/1301.3781, 2013.

[13] S. Bosch. Algebra. Springer-Lehrbuch. Springer, 2009.

[14] Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg Corrado, and Jeffrey Dean. Distributed represen-tations of words and phrases and their compositionality. CoRR, abs/1310.4546, 2013.

110

https://en.wiktionary.org/wiki/hotword

https://en.wiktionary.org/wiki/hotword

https://en.wikipedia.org/wiki/Smart_speaker

https://t3n.de/news/user-interfaces-fuer-sprachassistenten-831249/

https://t3n.de/news/user-interfaces-fuer-sprachassistenten-831249/

https://www.amazon.de/gp/help/customer/display.html?nodeId=201971890

https://www.amazon.de/gp/help/customer/display.html?nodeId=201971890

https://www.lumizil.de/magazin/lumitech/amazon-echo-lampen-kinderleicht-mit-smartphones-und-alexa-echo-steuern/

https://www.lumizil.de/magazin/lumitech/amazon-echo-lampen-kinderleicht-mit-smartphones-und-alexa-echo-steuern/

https://developer.amazon.com/de/docs/custom-skills/create-the-interaction-model-for-your-skill.html

https://developer.amazon.com/de/docs/custom-skills/create-the-interaction-model-for-your-skill.html

http://snowballstem.org/algorithms/german/stemmer.html

http://snowballstem.org/algorithms/german/stemmer.html

http://snowballstem.org/texts/r1r2.html

http://snowballstem.org/texts/r1r2.html

http://snowballstem.org/texts/glossary.html

http://snowballstem.org/texts/glossary.html

LITERATUR

[15] Xin Rong. word2vec parameter learning explained. CoRR, abs/1411.2738, 2014.

[16] Frederic Morin and Yoshua Bengio. Hierarchical probabilistic neural network language model. InProceedings of the Tenth International Workshop on Artificial Intelligence and Statistics, AISTATS2005, Bridgetown, Barbados, January 6-8, 2005, 2005.

[17] Andriy Mnih and Geoffrey E. Hinton. A scalable hierarchical distributed language model. In NIPS,pages 1081–1088. Curran Associates, Inc., 2008.

[18] Inc. The MathWorks. Matlab documentation - mathworks deutschland. Website, 09.2018. Onlineverfügbar unter https://de.mathworks.com/help/matlab/index.html; abgerufenam 16. Dezember 2018.

[19] Inc. The MathWorks. Text analytics toolbox documentation - mathworks deutschland. Website,09.2018. Online verfügbar unter https://de.mathworks.com/help/textanalytics/index.html; abgerufen am 16. Dezember 2018.

111

https://de.mathworks.com/help/matlab/index.html

https://de.mathworks.com/help/textanalytics/index.html

https://de.mathworks.com/help/textanalytics/index.html

LITERATUR

Begleit–CD

Die beigefügte CD enthält alle Literaturangaben im pdf–Format und die Projektmappe mit den imple-mentierten Modellen und den UnitTests. Der Stand aller Implementierungen entspricht der zum Druck-zeitpunkt vorhandenen Version (Stand: 16.12.2018).

Abbildung 30: Verzeichnisstruktur der beigefügten CD

Folgende Verzeichnisse enthält die beigefügte CD:

• DocIn diesem Verzeichnis befindet sich der schriftliche Teil dieser Masterarbeit im PDF-Format.

• LiteraturAusdrucke der in dieser Masterabrbeit verwendete Literatur und Dokumentationen als PDF.

• RealisierungIn diesem Verzeichnis befinden sich alle (Quell–)Dateien, die im Rahmen dieser Masterarbeitentstanden sind, sowie die Input- und Zwischendateien der einzelnen Modelle.

112

Labor für digitale Nachrichtentechnik - Entwicklung eines...

Documents

Transcript of Labor für digitale Nachrichtentechnik - Entwicklung eines...