Text - PVS: Parallel and Distributed Systems Group at Heidelberg

Ruprecht-Karls-Universität Heidelberg
Institut für Informatik
Lehrstuhl für Parallele und Verteilte Systeme
Bachelorarbeit
Einbindung des Mahout-Frameworks in das
KNIME-Workflowsystem zwecks Analyse
großer Datenmenge
Name:
Matrikelnummer:
Betreuer:
Datum der Abgabe:
Max Ernst
2743117
Prof. Dr. Artur Andrzejak, Dipl.-Math. Lutz Büch
30.07.2014
Ich versichere, dass ich diese Bachelor-Arbeit selbstständig verfasst und nur die angegebenen
Quellen und Hilfsmittel verwendet habe.
Heidelberg, 30.07.2014
Zusammenfassung
In der heutigen Zeit gewinnt Data-Mining immer mehr an Bedeutung. Dabei wird versucht,
aus einem Datenbestand neue Muster zu erkennen. Data-Mining Tools wie „KNIME“ (Konstanz Information Miner) bieten dem Benutzer eine grafische Oberfläche für die Verarbeitung
der Daten mit Hilfe des maschinellen Lernens an. Aus Speicherplatzgründen ist es jedoch nur
möglich relativ kleine Datenmengen zu verarbeiten.
Auf der anderen Seite benutzt die neue Generation der parallelen Algorithmen für maschinelles Lernen das Map-Reduce Paradigma, um eine hohe Skalierbarkeit, insbesondere
für große Daten, zu erlangen. So wurden, zum Beispiel, in dem Projekt Apache Mahout
(http://mahout.apache.org/) eine Vielzahl von Algorithmen implementiert, die das Framework
Hadoop benutzen. Schwierigkeiten, die sich dabei ergeben, sind zum Einen, dass viel Zeit
sowohl für die Einrichtung und Konfiguration als auch in die Einarbeitung von Mahout investiert werden soll, bevor damit angefangen zu arbeiten werden kann und zum Anderen, dass
der Output nicht so einfach in ein KNIME Workflow übernommen werden kann.
In dieser Arbeit werden für die freie Software „KNIME“ (Konstanz Information Miner) Knoten mit einer Anbindung an Mahout implementiert, um die Datenanalyse von großen Datenmengen dem Benutzer zu ermöglichen.
Mit dem Einsatz von Mahout werden große Daten außerhalb von KNIME verarbeitet und nur
eine kleine Datenmenge als Output dem nächsten Knoten übergeben.
Die Verwendung von Mahout innerhalb eines KNIME-Knotens bietet den Vorteil, dass die
Verarbeitung der Daten über Mahout in ein KNIME-Workflow eingebunden werden kann.
Das Ganze wird in Form einer virtuellen Maschine dem Benutzer zur Verfügung stehen.
Abstract
Today data mining is becoming increasingly important. It attempts to identify new patterns
from a data sets. Data mining tools such as „KNIME“ (Konstanz Information Miner) provide
the user with a graphical interface for processing the data with the help of machine learning.
Space reasons, however, it is only possible to process relatively small amounts of data.
On the other hand, the new generation of parallel algorithms for machine learning uses the
Map-Rreduce paradigm to achieve high scability. Variety of algorithms in Apache Mahout
Project, for example, were implemented using the Hadoop framework. One problem is that a
lot of time both should be invested for the installation and configuration as well as the incorporation of Mahout, before it can be started to work and secondly, that the output can not be
iii
used so easily in a KNIME workflow.
In this work nodes for the free software „KNIME“(Konstanz Information Miner) with a
connection to Mahout to simplify the data analysis of large data sets will be implemented.
With the use of Mahout large data are processed outside of KNIME and only a small amount
of data passed as output to the next node.
Using Mahout within KNIME node has the advantage that the processing of data on Mahout
can be integrated in a KNIME workflow.
The whole work will be available within a virtual machine.
iv
Inhaltsverzeichnis
Abbildungsverzeichnis
vii
Tabellenverzeichnis
viii
1
2
Einleitung
1
1.1
Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1
1.2
Ziele der Arbeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2
1.3
Aufbau der Arbeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
Grundlagen
4
2.1
Related Works . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4
2.2
Parallele Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4
2.3
Map-Reduce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
2.3.1
Vorgehensweise . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
2.3.2
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7
Apache Hadoop Framework . . . . . . . . . . . . . . . . . . . . . . . . . .
7
2.4.1
Job- und TaskTracker . . . . . . . . . . . . . . . . . . . . . . . . . .
8
2.4.2
Hadoop Distributed File System . . . . . . . . . . . . . . . . . . . .
8
2.5
KNIME . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
2.6
Clustering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10
2.7
Recommender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11
2.8
Mahout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11
2.4
3
Implementierung und Ausführung Mahout-Knoten
12
3.1
Mahout-Knoten Aufbau . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12
3.2
Oracle VM VirtualBox Einrichtung . . . . . . . . . . . . . . . . . . . . . . .
13
3.3
Mahout-KMeans-Knoten Ausführung . . . . . . . . . . . . . . . . . . . . .
14
3.4
Ausführung innerhalb eines Hadoop-Clusters . . . . . . . . . . . . . . . . .
17
3.5
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19
v
Inhaltsverzeichnis
3.6
4
5
22
4.1
22
Beschreibung Mahout-Knoten . . . . . . . . . . . . . . . . . . . . . . . . .
Szenario und Evaluation
5.2
7
Szenario . . . . . . . . . .
5.1.1 KNIME K-Means .
5.1.2 Mahout K-Means .
Evaluation . . . . . . . . .
5.2.1 Einzelinstanz . . .
5.2.2 Cluster . . . . . .
27
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
27
27
29
30
30
35
Schlussbetrachtung
38
6.1
6.2
38
38
Ergebnisse dieser Arbeit . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Anhang
Literaturverzeichnis
vi
20
Workflow aus Mahout-Knoten
5.1
6
Fehlerbehebung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
39
40
Abbildungsverzeichnis
2.1
2.2
2.3
Pervasive Big Data & AnalyticsTM . . . . . . . . . . . . . . . . . . . . . . .
Datenfluss beim Map-Reduce Verfahren . . . . . . . . . . . . . . . . . . . .
KNIME Workflow (http://www.knime.org/screenshots) . . . . . . . . . . . .
5
6
9
3.1
3.2
3.3
Mahout-Knoten Dialog . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Mahout-KMeans-Knoten Beispiel . . . . . . . . . . . . . . . . . . . . . . .
CSV Writer Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16
20
20
4.1
4.2
4.3
4.4
4.5
4.6
4.7
Mahout Workflow . . . . . . . . . . .
Konfiguration Start-Knoten . . . . . .
Konfiguration Input-Knoten . . . . .
Konfiguration Clustering-Knoten . . .
Konfiguration Fetch-Knoten . . . . .
Konfiguration Stop-Knoten . . . . . .
Konfiguration Recommender-Knoten .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
23
23
24
25
25
26
26
5.1
5.2
5.3
5.4
5.5
5.6
KNIME K-Means vor der Ausführung . . . . . . . . . . . . . .
KNIME K-Means nach der Ausführung . . . . . . . . . . . . .
Mahout K-Means vor der Ausführung . . . . . . . . . . . . . .
Mahout K-Means nach der Ausführung . . . . . . . . . . . . .
K-Means Java heap space overflow . . . . . . . . . . . . . . . .
Verarbeitungsgeschwindigkeit Einzelinstanz und Hadoop Cluster
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
28
28
29
30
32
36
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
vii
Tabellenverzeichnis
5.1
5.2
5.3
viii
Vergleich K-Means KNIME und Mahout (Laufzeiten) . . . . . . . . . . . . .
Vergleich K-Means Mahout und Mahout Workflow (Laufzeiten) . . . . . . .
Vergleich K-Means Mahout Einzelinstanz und Cluster . . . . . . . . . . . . .
31
34
35
1 Einleitung
1.1 Motivation
In der heutigen Zeit werden immer schnellere Rechenleistungen verlangt und vorausgesetzt. In
den letzten Jahrzehnten sind Prozessoren und Arbeitsspeicher um Vielfaches schneller geworden, Festplatten besitzen Kapazitäten, die man vor einiger Zeit noch für unmöglich gehalten
hat, was wiederum dazu führt, dass schnellere Prozessoren mit mehr Daten belastet werden.
Die Datenmengen werden tendenziell immer größer und sind leichter verfügbar (Stichwort
"Big Data") und wegen des begrenzten Hauptspeichers muss auf verteilte Systeme ausgewichen werden.
Bei sehr großen Datenmengen findet häufig das von Google eingeführte Framework „MapReduce“ den Einsatz. Dabei werden die Daten auf mehrere Rechner innerhalb eines Rechnerverbands (Computercluster) verteilt, separat verarbeitet und die Ergebnisse dann zusammengefügt. Innerhalb eines Rechners werden die Daten z.B. auf mehrere Kerne verteilt.
Das Problem mit den großen Datenmengen und Verarbeitungszeit stellt sich auch bei der Clusteranalyse, Klassifikationsverfahren und allgemein im Bereich des maschinellen Lernens.
Die Apache Mahout Sammlung bietet eine Menge von skalierbaren Algorithmen, um Klassifikatoren zu trainieren / testen, aber auch um Cluster zu bilden. Durch das Hinzufügen weiterer
Knoten / Rechnern steigt auch proportional die Leistung.
Bei einer Verteilung von Daten bringt uns Map-Reduce nicht nur schnellere Verarbeitung mit
sich, sondern auch die Sicherheit, dass alle Daten verarbeitet werden. Beim Ausfall eines Knotens muss sichergestellt werden, dass Daten, die diesem Rechner zugewiesen wurden, nicht
ins Leere gehen, sondern einem anderen Knoten zugewiesen und über diesen zum Output
weitergeleitet werden. Wäre dies nicht der Fall, so könnten manche Daten verloren gehen und
das Ergebnis letztendlich verfälscht werden.
Alle diese Eigenschaften machen Mahout zu einem mächtigen und ziemlich stabilen Werkzeug. Jedoch bietet Mahout keine grafische Benutzeroberfläche.
Für eine Datenanalyse mit grafischer Oberfläche wird oft das Werkzeug „KNIME“ eingesetzt.
Dem Benutzer ist es möglich, mit Hilfe unterschiedlicher Knoten, Workflows zu bilden. Jeder
1
1 Einleitung
Knoten verarbeitet die Daten auf seine vordefinierte Art und Weise. Sind die Daten „klein“,
können sie innerhalb eines Knotens erfolgreich verarbeitet werden, bei etwas größeren (dabei
handelt es sich um Daten, die wesentlich kleiner als 1 GB groß sind) oder ganz großen Daten
(Tera-, Petabyte...) wird der Knoten die Ausführung einfach abbrechen, da der Speicher für
die Verarbeitung nicht ausreichend vorhanden ist.
In dieser Arbeit werden neue KNIME-Knoten für das Clustern großer Datenmengen implementiert, die die Verarbeitung nicht intern ausführen, sondern einen Mahout Prozess starten,
der die Daten verarbeitet, und das Ergebnis an den nächsten Knoten übergibt. Somit wird die
Vorteile von Mahout (Verarbeitung großer Datenmengen) und KNIME (Datenanalyse über
grafische Benutzeroberfläche) miteinander kombiniert.
1.2 Ziele der Arbeit
In dieser Arbeit wird eine Schnittstelle zwischen KNIME und Mahout gebildet, um parallele
Mahout-Algorithmen von KNIME aus starten zu können.
Mahout enthält Algorithmen, die auf Hadoop Plattform ausgeführt werden und somit Verteilung der Daten und ihre Verarbeitung auf mehrere Rechner erlaubt. Aber auch wenn die Daten
auf einem Rechner verarbeitet werden, ist es möglich viel größere Datensätze zu übergeben
als es von KNIME standardmäßig vorgesehen ist. Dafür muss Hadoop und Mahout konfiguriert werden. Für die Mahout Einrichtung muss der Benutzer viel Zeit aufwenden. Das erste
Ziel ist also, die Einrichtung und Arbeit mit Mahout zu vereinfachen, so dass sich der Benutzer nur mit der Verarbeitung seiner Daten beschäftigen muss.
KNIME bietet die Möglichkeit, verschiedene Algorithmen über grafische Knoten auszuführen. D.h. der Benutzer kann alle Einstellungen über die grafische Benutzeroberfläche vornehmen, ohne tiefe Kenntnisse in den Terminalbefehlen zu haben. Es fehlt jedoch die Schnittstelle zwischen Mahout und KNIME, es ist also nicht möglich einen Mahout-Befehl in einem
KNIME-Knoten und somit in einem Workflow auszuführen. Ein weiteres Ziel ist somit einen
Mahout-Knoten für KNIME zu erstellen, welcher nur die Eingangsdaten benötigt und die
Ausgabe innerhalb eines Workflows weiterleitet oder in ein vom Benutzer eingegebenes Verzeichnis schreibt.
Der Mahout-Knoten soll Mahout und KNIME vereinigen. Beispielhaft wurde der K-Means
Algorithmus integriert, bei dem der Benutzer als Eingabedaten die Vektoren, die Anzahl der
Cluster und ggf. maximale Anzahl der Iterationen übergibt. Es wird als gewöhnlicher KNIMEKnoten ausgeführt und die Ausgabe kann wiederum als Eingabe in weiteren Knoten verwendet werden.
2
1.3 Aufbau der Arbeit
1.3 Aufbau der Arbeit
In Kapitel 2 werden grundlegende Methoden und Konzepte für diese Arbeit vorgestellt. Diese Grundlagen sollen dem Verständnis über eingesetzte Frameworks und damit verbundenen
Themen helfen und sich dahinter befindliche Abläufe kurz vorstellen.
Kapitel 3 beschreibt die Umsetzung der Anforderungen und Einsatzmöglichkeiten der entwickelten Knotenen. Ebenfalls wird auf die Konfiguration der Knoten, mögliche Fehler und
dazugehörige Lösungen eingegangen. Diese Knoten dienen als Prototypen und werden im
nächsten Schritt in weitere Knoten zerteilt.
4 Kapitel beschreibt weitere Entwicklung der Knoten, die den Aufbau der Workflows, durch
das Trennen der Ausführungen einzelner Aufgaben, flexibler macht.
Im Kapitel 5 wird ein mögliches Szenario für den Einsatz des Mahout Knotens präsentiert.
Zusätzlich findet noch ein Vergleich zwischen dem standardmäßigen K-Means Knoten aus
KNIME und dem Mahout K-Means Knoten statt.
3
2 Grundlagen
Die in diesem Kapitel vorgestellte Bereiche sollen das Verständnis über Technologien, die
in dieser Arbeit eingesetzt werden, erweitern und letztendlich den Sinn und den Zweck dieser Arbeit erläutern. Eingesetzte Verfahren aus der Mahout-Sammlung zur Datenanalyse wie
Clustering und Recommender werden beschrieben.
2.1 Related Works
Das Problem mit der Verarbeitung großer Datenmengen bei KNIME ist nicht neu, deswegen
werden KNIME Erweiterungen von Pervasive Big Data & AnalyticsTM für verteilte Frameworks wie Hadoop entwickelt. „Pervasive RushAnalytics for KNIME“ wurde mit dem Ziel
entwickelt, den maximalen Vorteil aus der Infrastruktur der parallelen Verarbeitung zu erzielen und damit eine höhere Verarbeitungsgeschwindigkeit zu erreichen. [3]
Abbildung 2.1 zeigt, dass RushAccelerator for KNIME 2 bis 10 und RushAnalytics 10 bis
100 Mal schneller als KNIME sind.
Im Download Center werden unterschiedliche Versionen zur Verfügung gestellt und können
nach einer Anmeldung als virtuelle Maschinen heruntergeladen werden.
2.2 Parallele Algorithmen
Ein Algorithmus heißt parallel, wenn er erstens so in Einzelschritte zerlegt werden kann, dass
diese auf verschieden Prozessoren (Rechner) verteilt werden können, und wenn zweitens diese Prozessoren unabhängig und gleichzeitig arbeiten. [10]
Diese Vorgehensweise wird z.B. von Google zum Einsatz gebracht, um extrem große Datenmengen verarbeiten zu können, bräuchte eine einzelne Maschine mehrere Jahre, um Suchindexe zu erstellen. So eine lange Verarbeitungszeit würde dazu führen, dass Google die Daten
niemals aktuell halten könnte, deswegen wird mit parallelen Algorithmen gearbeitet, die es
möglich machen, große Datenmenge auf viele Maschinen zu verteilen. Parallele Algorithmen
werden auch bei Mahout (Abschnitt 2.8) eingesetzt.
4
2.3 Map-Reduce
Abbildung 2.1: Pervasive Big Data & AnalyticsTM
Bei parallelen Algorithmen werden die Daten zerlegt und getrennt voneinander verarbeitet,
was uns zum nächsten Begriff führt - Map-Reduce.
2.3 Map-Reduce
Map-Reduce ist ein Framework für nebenläufige Berechnungen über große Datenmengen. Es
wurde von Jeffrey Dean und Sanjay Ghemawa im Jahr 2004 bei Google entwickelt.
Dadurch, dass die Daten auf mehrere Rechner verteilt werden, ist es möglich große Datenmengen in kurzer Zeit zu bearbeiten.
Ein weiterer Vorteil ist, dass man keine spezielle High-End Server bereitstellen muss, sondern
auf handelsüblichen Computern die Verarbeitung durchführen kann.
Wie der Name schon sagt, besteht Map-Reduce aus zwei Phasen: Map und Reduce, genau so
heißen die Funktionen, die nebenläufig verwendet werden.
Die map() Funktion berechnet die Werte für alle Eingabeelemente und stellt sie in modifizierter Form wieder dar. Die reduce() Funktion fasst die Ergebnisse zusammen und reduziert sie
auf eine Ausgabedatei(-wert).
5
2 Grundlagen
Abbildung 2.2: Datenfluss beim Map-Reduce Verfahren
2.3.1 Vorgehensweise
Abbildung 2.2 stellt Map- und Reducephasen mit jeweiligen Ergebnissen dar, einzelne Schritte sind im Folgenden erklärt:
• Daten werden auf unterschiedliche Map-Prozesse verteilt und parallel berechnet
• Berechnungen werden als Zwischenergebnisse gespeichert, wobei jede Map-Funktion
ihre Ergebnisse auf jedes Zwischenergebnis verteilen kann
• sind alle Map-Prozesse fertig, ist die Map-Phase zu Ende
• nun beginnt die Reduce-Phase, die aus jedem Zwischenergebnis ein Endergebnis berechnet, Reduce-Prozesse laufen ebenfalls parallel ab
Die Map-Phase stellt Zwischenergebnisse als Schlüssel-Wert-Paare dar und die Reduce-Phase
fasst diese zusammen und gibt auch Schlüssel-Wert-Paare aus. Formal gesehen ist MapReduce-Framework eine Abbildung:
(K × V)∗ → (L × W)∗
[(k1 , v1 ), ..., (kn , vn )] 7→ [(l1 , w1 ), ..., (lm , wm )],
wobei K und L Schlüssel, V und W Werte enthalten.
6
2.4 Apache Hadoop Framework
2.3.2 Beispiel
Man kann sich viele Anwendungen für das parallele Berechnen vorstellen, an dieser Stelle
wird das gängigste Einführungsbeispiel vorgestellt. Das „Hello World!“ Beispiel aus der Programmierung ist in Map-Reduce das Beispiel Wörter in einem Text zu zählen, d.h. es wird
gezählt wie oft jedes Wort in einem Text vorkommt.
In der Map-Phase wird der Text geteilt und verschiedenen Rechnern zugeteilt, jeder Rechner
berechnet Anzahl Wörter, die in seinem Teil vorkommen und legt sie als Zwischenergebnisse
im Speicher ab. So kann es vorkommen, dass das Wort „ich“ vom ersten Map-Prozess 5 mal
gezählt wurde und vom zweiten Map-Prozess 7 mal, d.h. es sind 2 Ergebnisse, die aber zusammengefasst werden sollen, was auch die einzelnen Reduce-Phasen machen und als Ergebnis
eine Liste aus Wörtern (Schlüsseln) und der jeweiligen Anzahl (Werte) ausgeben.
Pseudo-Code:
map(String key, String value):
// key: document name
// value: document contents
for each word w in value:
EmitIntermediate(w, "1");
reduce(String key, Iterator values):
// key: a word
// values: a list of counts
int result = 0;
for each v in values:
result += ParseInt(v);
Emit(AsString(result));
2.4 Apache Hadoop Framework
Map-Reduce Framework nimmt dem Entwickler viel Arbeit ab, so müssen nur die Map- und
Reducefunktionen implementiert werden, alles andere, wie Fehlerbehandlungen, Scheduling
Verfahren für die Jobverteilung und Koordination, d.h. technische Details werden vom System
erledigt. Ein konkretes Framework wird in diesem Abschnitt vorgestellt.
Das von Google entwickelte Map-Reduce Framework ist kostenpflichtig und urheberrechtlich geschützt, deswegen wird an dieser Stelle das Open-Source, in Java entwickeltes Framework der Apache Foundation verwendet.
7
2 Grundlagen
Es stehen 3 Modi zur Verfügung, in denen Hadoop-Framework gestartet werden kann:
• Standalone mode: Programm startet in einem einzigen Prozess
• Pseudo-distributed mode: Programm startet auf einem Rechner, wird jedoch in mehrere
Java Prozesse gesplittet
• Cluster mode oder Fully distributed: läuft auf einem Cluster aus mehreren Rechnern
Hadoop ist offen für alle Entwickler, bietet eine sehr hohe Fehlertoleranz und eignet sich damit
bestens für diese Arbeit.
2.4.1 Job- und TaskTracker
In einem Framework gibt es zwei Arten von Prozessen, die für die Verarbeitung der Daten
zuständig sind - der eine wird als JobTracker-Prozess bezeichnet, alle andere Prozesse werden
TaskTracker-Prozesse genannt (Google verwendet dazu die Begriffe Master und Worker.).
Der JobTracker-Prozess weist den einzelnen Rechnern im Cluster Jobs zu, welche wiederum Map- oder Reducefunktionen sind. Nach der Zuweisung werden die Daten mit Hilfe von
Remote Method Invocation (RMI) aus dem Speicher gelesen und verarbeitet. Nachdem alle
Map- und Reduceprozesse beendet sind, weckt der JobTracker ein Benutzerprogramm auf,
dass alle Daten berechnet wurden und weitergeleitet werden können.
Es gibt also genau einen JobTracker und mehrere TaskTracker; JobTracker bekommt Mapund Reducefunktionen, die er an einzelne Knoten (TaskTracker) verteilt. Dem JobTracker ist
bekannt, an welchem Knoten welche Daten zu finden sind, dies wird bei der Arbeitszuweisung berücksichtigt, wodurch das Verschicken der Daten über das Netzwerk vermieden und
Zeit gespart wird. Daten werden nur in dem Fall zum nächsten Rechner im Cluster geschickt,
falls auf einem anderen momentan keine Funktion ausgeführt werden kann.
2.4.2 Hadoop Distributed File System
Hadoop Distributed File System (HDFS) ist von Apache entwickeltes Dateisystem. Es wird
eigenes Dateisystem verwendet, da es speziell für große Datenmengen auf verteilten Rechnern
erstellt wurde. Die Verteilung auf die Cluster wird möglichst optimal durchgeführt und die
Zugriffszeiten sind sehr kurz.
In einem Cluster gibt es unterschiedliche Typen von Knoten mit jeweiligen Aufgaben,
auf die sie spezialisiert sind. Der sogenannte „NameNode“ ist für die Steuerung des Namespaces, Metadaten des Dateisystems und Rechenzugriffe zuständig. Auf den „DataNodes“
8
2.5 KNIME
werden tatsächliche Daten, die bearbeitet werden, gespeichert. Als letztes existiert noch ein
„SecondaryNameNode“, der die Änderungen des ursprünglichen Dateisystems als Log-Files
speichert.
2.5 KNIME
KNIME ist eine freie Software, die in solchen Bereichen wie Mathematik, Bioinformatik,
Statistik usw. für die Datenanalyse eingesetzt wird. Dabei bietet es zahlreiche Verfahren des
maschinellen Lernens und Data-Mining an.
Ein Workflow in KNIME besteht aus Knoten, die Daten verarbeiten, und Kanten, die einen
Datenfluss darstellen. Ein Knoten kann sowohl eine als auch mehrere Eingangskanten als Input haben, genauso ist es aber möglich zu verarbeitende Daten von der Festplatte zu laden
(zumindest der erste Knoten bekommt seine Daten nicht von einem anderen Knoten).
Abbildung 2.2 zeigt die Arbeitsfläche von KNIME. Auf der linken Seite werden unterschied-
Abbildung 2.3: KNIME Workflow (http://www.knime.org/screenshots)
liche Knoten kategorisiert aufgelistet, die je nach Art der Analyse und den Eingangsdaten
ausgewählt werden können.
Im mittleren Bereich wird der ganze Workflow dargestellt. Die Knoten können unterschiedliche Status besitzen, dies sieht man an der Farbe, die sich unter dem Knoten befindet: gelb
9
2 Grundlagen
bedeutet, dass der Knoten notwendige Daten enthält und bereit für die Ausführung ist; bei rot
müssen noch Daten angegeben werden; grün - der Knoten wurde bereits ausgeführt.
2.6 Clustering
Clustering - Datensätze werden nach ihrer Ähnlichkeit dermaßen in Cluster unterteilt, dass ein
Cluster Datensätze enthält, die zueinander ähnlich und möglichst unterschiedlich zu den Datensätzen aus anderen Clustern sind. Wie ähnlich die Datensätze zueinander sind wird durch
eine Distanzfunktion bestimmt, z.B. durch die Euklidische Distanzfunktion.
Im Gegensatz zur Klassifikation sind die Cluster am Anfang unbekannt, es findet also kein
Lernvorgang mit Trainingsdaten statt. Es ist jedoch möglich die Anzahl der Cluster und die
Distanzfunktion innerhalb dieser Cluster zu bestimmen.
Als ein Beispiel, wird an der Stelle ein einfaches Clusteringverfahren K-Means vorgestellt.
K-Means ist ein einfaches und das meistverbreitete Clusteringverfahren. Jeder Cluster bei
K-Means besitzt seinen eigenen Schwerpunkt, den sogenannten „Centroid“. Anzahl der Cluster wird vor der Ausführung angegeben, die Schwerpunkte werden dann zufällig verteilt. Das
Ziel dabei ist es, den durchschnittlichen quadratischen Abstand vom Schwerpunkt zu minimieren, indem iterativ jeder Datensatz einem Cluster zugewiesen wird und anschließend die
Schwerpunkte neuberechnet werden.
Der letzte Schritt wird solange ausgeführt, bis eine bestimmte Anzahl von Iterationen erreicht
ist oder bis die Schwerpunkte sich nicht mehr bewegen.
Einsatzgebiet von K-Means ist oft in der Computergraphik die Bildsegmentierung. Das Bild
wird in bestimmte Bereiche (Segmente) unterteilt, in welchen die Bildpunkte gemeinsame
Eigenschaften besitzen. Welche Eigenschaften es sind, hängt vom Kontext ab; auf den Röntgenbildern z.B. werden zusammengehörende Elemente über Farbintensität den Clustern zugeordnet.
Es existieren unterschiedliche Variationen von K-Means wie z.B. K-Means++, bei dem
versucht wird bessere Startpunkte zu finden, oder Fuzzy K-Means, wo jeder Datensatz nicht
einem bestimmten Cluster, sondern ein Satz Gewichte zugeordnet wird, die angeben wie stark
die Zugehörigkeit zu einem bestimmen Cluster ist.
10
2.7 Recommender
2.7 Recommender
Recommender System (Empfehlungsdienst) ist ein Verfahren, welches dazu benutzt wird,
ähnliche Objekte zu ermitteln und Empfehlungen zu erstellen. Anhand bestehender Daten
(Kontext) kann bestimmt werden welche weitere Daten als Empfehlung verwendet werden
können.
Eine Recommender Engine kann beispielsweise bei Videofilmen oder Büchern eingesetzt werden. Bereits ausgeliehene Bücher stellen die Vorlieben eines Benutzers dar. Darüber kann erfahren werden, welche Autoren oder Genre der Benutzer bevorzugt; ebenso können das Alter,
das Geschlecht und die Herkunft der Person eingesetzt werden, um passende Vorschlage machen zu können.
Die Eingabe enthält somit eine Liste der gelesenen Büchern und einer Liste noch zusätzlich
vorhandener Bücher. Daraus wird eine Rankingliste erstellt.
2.8 Mahout
Mahout ist ein Apache Projekt, welches sich mit der skalierbaren Implementierung von maschinenlernenden Algorithmen auf der Hadoop Plattform befasst. Es enthält einige Algorithmen für z.B. Clustering und Klassifikation. So ist auch im Abschnitt 2.6 vorgestelltes KMeans Clusteringverfahren in der Mahout Sammlung vorhanden.
Mahout modifiziert die Inputdaten nicht, somit bleibt der Benutzer flexibel und kann Algorithmen mit verschiedenen Parametern ausführen, um diese auszuprobieren, zu testen und zum
bestmöglichen Ergebnis zu kommen. Die Daten werden jedoch zwischen verschiedenen Ausführungen nicht im Speicher gehalten, sondern müssen immer wieder neu geladen werden.
11
3 Implementierung und Ausführung
Mahout-Knoten
In diesem Kapitel werden zu implementierende Methoden und Algorithmen und jeweilige
Entscheidungen gezeigt und vorgestellt.
Als Einstieg in die KNIME-Implementierung wird zuerst ein KMeans-Knoten implementiert
und die Ausführung mit den jeweiligen Konfigurationen gezeigt. Wie der Name bereits verrät,
ist dieser Knoten nur auf K-Means beschränkt und sogar bei diesem Verfahren können nur
wichtigste Konfigurationen vorgenommen werden.
Ein weiterer wichtiger Teil dieses Kapitels ist die Vorstellung und der Umgang mit der virtuellen Maschine. Da man diese Mahout-Knoten nicht in jede beliebige KNIME Umgebung
einbinden kann, werden die Knoten zusammen mit dem Betriebssystem (mit installiertem Hadoop Framework etc.) als virtuelle Maschine herausgegeben. Somit müssen zumindest Grundlegende Bereiche der virtuellen Maschine, aber auch, falls es zu Problemen kommen sollte,
Schritte, die bei Fehlerbehebungen durchzuführen sind, erwähnt werden.
3.1 Mahout-Knoten Aufbau
Um einen Mahout-Knoten implementieren zu können, werden einige Klassen von KNI ME tech
zur Verfügung gestellt, die auf eigene Anforderungen vervollständigt und angepasst werden
können. Im folgenden werden diese Klassen vorgestellt.
NodeModel - diese Klasse ist für die allgemeine Beschreibung des Knotens verantwortlich. Der Konstruktor definiert die Anzahl der Ein- und Ausgangsports. Da die Eingangsdaten
von unserem Knoten sehr groß sein und auch meistens von außen hinzugefügt werden, besitzt
der Mahout-Knoten keinen Eingangsport. Die Ausgabe wird jedoch so klein sein, dass sie als
Eingabe für den nächsten Knoten genommen werden kann und auch soll.
Weiterhin werden alle Dialog-Komponenten angegeben, welche der Benutzer bei der Konfiguration des Knotens angezeigt bekommt. Im Falle des Mahout-Knotens handelt es sich um
12
3.2 Oracle VM VirtualBox Einrichtung
solche Komponenten wie Ein- und Ausgabepfade, Anzahl der Cluster und maximale Anzahl
der Iterationen. Diese werden mit Default-Werten erzeugt, die dann später vom Benutzer geändert werden können / müssen.
Wichtige Methoden aus dieser Klasse sind validateSettings(), saveSettingsTo() und loadValidatedSettingsFrom(), um die Einstellungen zu prüfen, ob erforderliche Daten angegeben wurden; Einstellungen zu speichern und diese zu laden. execute() enthält Anweisungen für die
Ausführung des Knotens.
NodeDialog - platziert die in der NodeModel definierte Komponente auf das Fenster (panel)
bzw. Dialog, den der Benutzer angezeigt bekommt. Dabei geht es im Wesentlichen um die
Positionen der einzelnen Komponente und ihrem Verhalten wie beispielsweise Verschwinden
einzelner Einstellungen beim Setzen eines Hakens.
NodeView - zeigt die Ausgabe graphisch an.
3.2 Oracle VM VirtualBox Einrichtung
Das Endergebnis dieser Arbeit wird in Form einer virtuellen Maschine allen Benutzern zur
Verfügung gestellt. Eine ganze Maschine deswegen, weil es nicht nur der implementierte Knoten als Plugin in KNIME eingebunden werden muss (was auch möglich wäre, nur den Knoten
in KNIME zu importieren), sondern auch Hadoop und Mahout eingerichtet und lauffähig sein
müssen.
Es existiert eine Reihe von virtuellen Maschinen, solche wie „Windows Virtual PC“, „VMware Workstation“, „Parallels Workstation“ usw. Da nicht alle Maschinen kostenlos sind und
auch die Einrichtung bei manchen viel Aufwand erfordert, fiel die Entscheidung auf die eine
der bekanntesten und zugleich kostenlose virtuelle Maschine „Oracle VM Virtual Box“.
Obwohl die Maschine lauffähig zur Verfügung gestellt wird, müssen vom Benutzer dennoch
einige Einstellungen, Änderungen oder Anpassungen vorgenommen werden. Dieser Abschnitt
beschreibt grundlegende Operation, die notwendig oder sinnvoll für die Ausführung der VirtualBox sein können.
Maschine Einbinden:
Um eine neue Maschine in die Virtual Box aufzunehmen, wird im Menü „Maschine –> Hinzufügen“ entsprechende Maschine ausgewählt. Damit wird die neue Maschine eingebunden
und kann bereits gestartet werden. Administrator „VM“ mit dem Passwort „admin“ ist angelegt.
13
3 Implementierung und Ausführung Mahout-Knoten
Gemeinsamen Ordner definieren:
Es muss evtl. eine Schnittstelle zwischen dem echten Betriebssystem und der virtuellen Maschine geschaffen werden, nämlich ein gemeinsamer Ordner (oder mehrere) den die beiden
Systeme nutzen. Dazu wird in der Virtual Box die entsprechende Maschine markiert und
Menüpunkt „Ändern“ausgewählt. Daraufhin erscheint ein Fenster mit dem Unterpunkt „Gemeinsame Ordner“. Hier kann ein gemeinsamer Ordner definiert werden, als Beispiel wird ein
der Stelle Verzeichnis „C:\Gemeinsamer Ordner“ verwendet.
Dieses Verzeichnis muss auch in der virtuellen Maschine eingebunden werden, dies geschieht
im Terminal mit der Ausführung des Befehls:
sudo mount -t vboxsf Gemeinsamer_Ordner /home/vm/Desktop/Shared/ ,
wobei „Gemeinsamer_Ordner“ der Ordner-Name ist, der beim Hinzufügen in die Virtual Box
angezeigt wurde und „/home/vm/Desktop/Shared/“ das Verzeichnis, in welchem der Inhalt
des gemeinsames Ordners unter Linux angezeigt werden soll.
Nach der Eingabe des Passworts sollen beide Systeme auf den gemeinsamen Ordner zugreifen
können.
Netzwerk einrichten:
Die Maschine besitzt 2 Netzwerkadapter, einen, um Zugang ins Internet zu bekommen und
einen zweiten, um sich mit dem echten Betriebssystem in einem Netzwerk befinden zu können. Dies ist z.B. für einen Cluster notwendig. Werden mehrere virtuelle Maschinen eingebunden muss evtl. die Mac-Adresse unter „Ändern“ –> „Netzwerk“ –> „Adapter 2“ –> „MACAdresse:“ –> „aktualisieren“ geändert werden.
Auch sonstige Einstellungen bzgl. des Netzwerkes und Adapter können hier angepasst werden.
3.3 Mahout-KMeans-Knoten Ausführung
Dieser Abschnitt beschreibt Einzelschritte, die bei der Ausführung des ersten Knotens passiert
werden.
Im Kapitel 2 wurde ein Clustering-Verfahren K-Means vorgestellt. Dieses Verfahren führt der
erste Knoten aus. Der Vorteil dieses Knotens ist, dass der Benutzer alle Einstellungen über
grafische Oberfläche vornehmen kann. Es ist ein reiner K-Means Knoten, der nur K-Means
ausführt und keine Kenntnisse über Terminal-Befehle von Mahout erfordert. Das ganze Projekt wird nicht auf einem „normalen“ Betriebssystem, sondern auf einer virtuellen Maschine
14
3.3 Mahout-KMeans-Knoten Ausführung
durchgeführt. Als Betriebssystem wurde Linux-Distribution Ubuntu 12.10 verwendet. Dieses
beinhaltet alle notwendigen Pakete, um darauf Hadoop und Mahout ausführen zu können.
Bevor dieser Knoten näher erläutert wird, wird an dieser Stelle genauer auf den Umgang mit
Mahout eingegangen. Um einen Mahout-Befehl in der Kommandozeile auszuführen, muss der
Benutzer in den Systemeinstellungen den Pfad zu der Ausführungsdatei von Mahout angeben
und damit Mahout aus jedem beliebigen Verzeichnis starten können oder zum Unterverzeichnis „bin/mahout“ von Mahout navigieren und von dort aus Befehle an Mahout übergeben.
Eine Eingabe hat etwa folgende Gestalt:
bin/mahout kmeans \
− i < input vectors directory > \
− c < input clusters directory > \
− o < output working directory > \
− k < optional number o f initial clusters to sample f rom input vectors > \
− dm < DistanceMeasure > \
− x < maximum number o f iterations > \
− cd < optional convergence delta. De f ault is 0.5 > \
− ow < overwrite output directory i f present > \
− cl < run input vector clustering a f ter computing Canopies > \
−xm < execution method : sequential or mapreduce >
[6]
Das Beispiel listet 10 Eingabeparameter auf. Der K-Means Knoten kann diese Anzahl von
Argumenten natürlich nicht aufnehmen, über den Dialog können lediglich: -i, -o, -k, -x Parameter konfiguriert werden.
Notwendige Benutzereingaben für den Knoten sind:
1. Pfad zu Vektoren (-i)
2. Anzahl der Cluster (-k)
Als optionale Parameter können
• Ausgabeverzeichnis (-o)
• Maximale Anzahl Iterationen (-x)
• Hadoop auf einem Cluster laufen lassen
15
3 Implementierung und Ausführung Mahout-Knoten
(a) Max. Anzahl Iterationen wird gesetzt
(b) Standartwert für Max. Anzahl der Iterationen verwenden
Abbildung 3.1: Mahout-Knoten Dialog
angegeben werden. Wird der Haken jedoch nicht gesetzt, wird die Anzahl der Iterationen standardmäßig auf 10 gesetzt. Beide Darstellungen werden in der Abbildung 3.1 gezeigt.
Wie in Kapitel 2 bereits erwähnt, muss auf der Maschine Hadoop laufen, um einen MahoutJob ausführen zu können. D.h. vor einem Mahout-Algorithmus muss Hadoop konfiguriert und
gestartet werden. Der Knoten führt folgende Schritte durch:
• Hadoop stoppen
• HDFS formatieren
• Hadoop starten
• 30 Sekunden Pause, damit Hadoop vollständig hochfährt
• Mahout-Algorithmus ausführen
Als Erstes wird Hadoop gestoppt, da es vorkommen kann, dass Hadoop bereits auf der Maschine läuft und sowohl der dritte Schritt (Starten) fehlschlagen als auch der Rest nicht ausgeführt wird.
Ohne Formatierung könnte es vorkommen, dass sich fälschlicherweise alte Daten auf dem
Dateisystem befinden und diese der Ausführung Probleme bereiten. Mit der Formatierung
16
3.4 Ausführung innerhalb eines Hadoop-Clusters
wird sichergestellt, dass nur die zu verarbeitende Daten sich auf dem Dateisystem befinden.
Für die korrekte Ausführung braucht Hadoop für das Starten eine gewisse Zeit, 30 Sekunden
sollten im Normalfall ausreichen, so dass die Ausführung eines Algorithmus nicht zu schnell
kommt.
Diese einzelne Befehle werden an ein Terminal übergeben und als Kommandozeilen ausgeführt. Um den Verlauf beobachten zu können, wird die Ausgabe in der unteren KNIMEKonsole als Info ausgegeben. So ist es für den Benutzer möglich einzelne Befehle, Fortschritt
oder Fehler dort auszulesen.
3.4 Ausführung innerhalb eines Hadoop-Clusters
Abschnitt 3.3 beschreibt den Ablauf auf einem einzelnen Rechner. Es ist aber genauso möglich
die Ausführung auf mehrere Rechner, sprich Cluster, zu verteilen. Die Vorgehensweise und
dafür notwendige Konfigurationen werden in diesem Abschnitt beschrieben.
Es gibt eine Reihe von Konfigurationen, die nur ein Mal eingetragen werden müssen und
keine Änderung mehr benötigen, falls man die virtuelle Maschine mehrmals klont. Werden jedoch andere Maschinen verwendet, müssen diese Konfigurationen auf allen Maschinen durchgeführt werden, damit Hadoop auf einem Cluster laufen kann.
In einem Cluster muss eine Maschine existieren, von der aus alle Befehle gestartet werden,
diese Maschine wird im Folgenden master genannt. Andere Maschinen, die die Aufgaben
nur durchführen werden als slave bezeichnet. Auf welcher Maschine welche Änderungen
vorgenommen werden müssen, werden mit dem jeweiligen Namen gekennzeichnet.
Für die Ausführung auf einem Rechner wird /home/vm/local/hadoop Verzeichnis verwendet,
für die Ausführung auf einem Cluster - /home/vm/local/hadoop-cluster. D.h. alle Änderungen,
die jetzt folgen werden, werden auf das letzte Verzeichnis angewendet.
Als Erstes müssen alle IP-Adressen unter /etc/hosts eingetragen werden, z.B.:
192.168.0.1 master
192.168.0.2 slave
192.168.0.3 slave2
Diesen Eintrag kann nur der Administrator durchführen:
mit sudo vim /etc/hosts gelangt mant zum Vim-Fenster
mit I (insert) kann man den Inhalt editieren
nach dem die Änderung vorgenommen wurde: Esc –> :wq (write + quit) –> Enter
17
3 Implementierung und Ausführung Mahout-Knoten
Dateien, die im Verzeichnis /home/vm/local/hadoop-cluster angepasst werden:
conf/masters (master):
master
conf/slaves (master):
master
slave
slave2
conf/core-site.xml (alle Maschinen):
<property>
<name>fs.default.name</name>
<value>hdfs://master:54310</value>
<description>
The name of the default file system
</description>
</property>
conf/mapred-site.xml (alle Maschinen):
<property>
<name>mapred.job.tracker</name>
<value>master:54311</value>
<description>
The host and port that the MapReduce jobtracker runs
</description>
</property>
conf/hdfs-site.xml (alle Maschinen):
<property>
<name>dfs.replication</name>
<value>2</value>
<description>
Default block replication
</description>
</property>
18
3.5 Beispiel
Auf allen Maschinen kann unter /home/vm/local/hadoop-cluster mit jps geschaut werden,
welche Java-Prozesse laufen. Beim slave könnten die Ausgaben beispielsweise so aussehen:
Nach dem HDFS deamons gestartet wurden:
15183 DataNode
15616 Jps
Nach dem MapReduce deamons gestartet wurden:
15183 DataNode
15897 TaskTracker
16284 Jps
HDFS und MapReduce daemons werden von dem Mahout-Knoten bei der Ausführung automatisch gestartet.
Wie man an der letzten Ausgabe erkennen kann, müssen DataNode und TaskTracker laufen,
dies bedeutet, dass alles korrekt läuft. Ist die Ausgabe anders, wurde etwas falsch konfiguriert.
Die einzelnen Prozess-ID’s werden sich von dem Beispiel höchstwahrscheinlich unterscheiden und ihr Wert spielt an dieser Stelle selbstverständlich keine Rolle.
3.5 Beispiel
Dieser Abschnitt beschreibt die Ausführung des Knotens anhand von synthetic_control.data.
Die Datei befindet sich unter „Home“ –> „Mahout Example“.
Schritt 1 KNIME starten, Doppelklick auf den MahoutKMeans-Knoten.
Schritt 2 Knoten Konfigurieren: entweder über Doppelklick auf den Knoten oder rechter
Mausklick auf den Knoten und „Configure...“.
Schritt 3 Als „Input file“ den Pfad „ /home/vm/Mahout Example/synthetic_control.data“
wählen.
Schritt 4 Für „Output working directory “ kann beliebiges Verzeichnis gewählt werden, z.B.
„/home/vm/Mahout Example/output “ .
Schritt 5 „Number of clusters“ auf 10 setzen (kann auch beliebig sein).
Schritt 6 „CSV Writer “ Knoten hinzufügen und Ausgabedatei setzen.
Schritt 7 Beide Knoten verbinden.
Schritt 8 Ok & rechter Mausklick auf den Knoten –> „Execute“.
19
3 Implementierung und Ausführung Mahout-Knoten
Abbildung 3.2 stellt den fertigen Workflow dar.
Abbildung 3.2: Mahout-KMeans-Knoten Beispiel
Nach einer erfolgreichen Ausführung wird eine Ausgabedatei im Ordner „output“ von Mahout angelegt. Diese beinhaltet gelabelte Vektoren.
Die Struktur der Daten, wie sie an weitere Knoten von K-Means Knoten übergeben wird, sieht
man in der von CVS Writer Knoten erstellten Datei (Abbildung 3.3). Die Zeilen in der CSVDatei stellen je einen Vektor dar, die letzte Zelle beinhaltet das Label. Die Labels werden von
Mahout vergeben und gelangen unverändert in den Output vom K-Means Knoten.
Somit werden 10 Vektoren der Länge 60 und eine Spalte fürs Label erstellt.
Abbildung 3.3: CSV Writer Ausgabe
3.6 Fehlerbehebung
Dieses Kapitel beschreibt mögliche Fehler, die bei der Konfiguration auftauchen können und
Lösungen, die zur Behebung weiterhelfen sollen. Hauptsächlich handelt es sich um die Einrichtung der virtuellen Maschine, da diese als Voraussetzung (für die korrekte Ausführung der
Knoten) richtig konfiguriert werden soll und um Fehlermeldungen, die während der Ausführung der Knoten auftauchen können.
Einbinden der Platte Falls das Hinzufügen der Platte einen Fehler derart „virtual box could
20
3.6 Fehlerbehebung
not find an open hard disk with uuid...“ auftaucht, kann man mit folgenden Schritten die Maschine auf andere Art und Weise hinzufügen:
1. Neue Maschine erstellen.
2. Z.B. „Ubuntu“ benennen, Arbeitsspeichergröße wählen.
3. Vorhandene Festplatte verwenden.
4. Gewünschte virtuelle Maschine auswählen.
5. Maschine starten.
IP-Adresse vergeben Bekommen mehrere virtuelle Maschinen die gleiche IP-Adresse, muss
die MAC-Adresse geändert werden. Dies ist unter „Ändern“ –> „Netzwerk“ –> „Adapter 2“
–> „MAC-Adresse:“ –> „aktualisieren“ möglich.
Grafikkartenanzeige verbessern Wird die Anzeige etwas verlangsamt, d.h. Fenster werden
mit Zeitverzögerung aufgemacht, kann unter „Ändern“ –> „Anzeige“ Grafikspeicher erhöht
und 3-D Beschleunigung aktiviert werden. Dies wird die Reaktionszeit der Anzeige verbessern.
DiskErrorException Bei einer Exception: „org.apache.hadoop.util.DiskChecker$DiskErrorException:
Could not find output/spill0.out in any of the configured local directories “ führen Sie den
Knoten erneut aus oder starten Sie die ganze Maschine neu.
21
4 Workflow aus Mahout-Knoten
Im Kapitel 3 beschriebene Knoten sind einzelne Knoten, die die ganze Mahout Aufgabe in
einem einzelnen Knoten ausführen. Angefangen mit dem Kopieren von Daten ins HDFS bis
hin zur Verarbeitung der Daten lokal oder auf einem Cluster.
Auf der einen Seite bieten solche Knoten die Möglichkeit, gewünschte Einstellungen schnell
in einem Knoten vorzunehmen und nur diesen einen Knoten auszuführen, auf der anderen
Seite kann es aufgrund großer Datenmenge, die verarbeitet wird, ziemlich lästig werden z.B.
einzelne Parameter zu ändern und den Algorithmus erneut auszuführen. Denn dadurch werden die Daten wieder ins HDFS kopiert, obwohl sie schon ohnehin auf dem HDFS vorhanden
waren.
Damit ist die Ausführung in einem einzelnen Knoten nicht immer sinnvoll, da man den ganzen
Ablauf neustarten muss und nicht erst ab dem Punkt, an dem sich die Einstellungen geändert
haben. Um diese Einschränkung zu beseitigen wird der ganze Ablauf in mehrere Knoten gesplittet.
4.1 Beschreibung Mahout-Knoten
Die Ausführung beinhaltet 5 Schritte. Diese 5 Schritte entsprechen auch den einzelnen Knoten:
1. Starten von Hadoop
2. Kopieren der Daten ins HDFS
3. Verarbeitung der Daten (z.B. Clustering)
4. Holen der Daten aus HDFS und Übergabe an den nächsten Knoten
5. Stoppen von Hadoop
Durch so eine Aufteilung kann der Ablauf ab einem beliebigen Knoten neugestartet werden,
ohne, dass vorherige Knoten ausgeführt werden. Möchte man beispielsweise die Anzahl der
22
4.1 Beschreibung Mahout-Knoten
Abbildung 4.1: Mahout Workflow
Abbildung 4.2: Konfiguration Start-Knoten
Cluster ändern, so muss eine Änderung beim dritten Knoten vorgenommen werden, damit
werden Knoten 1 und 2 nicht mehr wiederholt ausgeführt, es werden die selben Daten aus
HDFS verwendet, die zuvor übertragen wurden.
Knotenübersicht:
Start (Abbildung 4.2):
Der Benutzer kann Hadoop lokal oder auf einem Cluster starten. Falls Hadoop bereits läuft,
kann angegeben werden, dass dieser Knoten nur als Startknoten verwendet wird, ohne Hadoop zu starten.
Input (Abbildung 4.3):
Beim Input muss eine Datei ausgewählt werden, die ins HDFS übertragen wird. Dieser Kno-
23
4 Workflow aus Mahout-Knoten
Abbildung 4.3: Konfiguration Input-Knoten
ten übergibt dann dem nächsten Knoten die Referenz auf die Daten, so dass die Verarbeitung
im nächsten Knoten stattfinden kann.
Clustering (Abbildung 4.4):
In diesem Knoten kann der Algorithmus ausgewählt und dazu notwenige Parameter wie Anzahl der Cluster, maximale Anzahl der Iterationen gesetzt werden.
Fetch (Abbildung 4.5):
Fetch-Knoten bietet die Möglichkeit, Daten von HDFS auf lokalem Rechner zu speichern
oder die Daten an den nächsten Knoten zu übergeben.
Stop (Abbildung 4.6):
Dieser Knoten kann ausgeführt werden, um Hadoop zu stoppen.
Recommender (Abbildung 4.7):
Bei einem Recommender-Knoten kann die Anzahl der Empfehlungen gesetzt werden.
24
4.1 Beschreibung Mahout-Knoten
Abbildung 4.4: Konfiguration Clustering-Knoten
Abbildung 4.5: Konfiguration Fetch-Knoten
25
4 Workflow aus Mahout-Knoten
Abbildung 4.6: Konfiguration Stop-Knoten
Abbildung 4.7: Konfiguration Recommender-Knoten
26
5 Szenario und Evaluation
In diesem Kapitel wird ein mögliches Szenario vorgestellt, wie der Mahout Knoten in Einsatz
gebracht werden kann. In diesem Szenario wird der Mahout Knoten in ein KNIME Workflow eingebunden. Für die Evaluation wird der standardmäßige Knoten aus KNIME mit dem
Mahout Knoten verglichen.
5.1 Szenario
Es wird ein einfaches Szenario mit einem Clustering Verfahren und einem Klassifikator betrachtet. Ein Klassifikator benötigt 2 Eingangsquellen. Beim ersten Input handelt es sich um
Trainingsdaten, d.h. Daten die bereits klassifiziert wurden, anhand dieser Daten wird der zweite Input, den sogenannten Testdaten, analysiert und klassifiziert. Als letzter Schritt wird das
Ergebnis in einem Diagramm grafisch dargestellt.
Als Clustering Verfahren wird „K-Means“ gewählt, für den Klassifikator empfiehlt sich an
dieser Stelle der „K Nearest Neighbor“ Klassifikator. Warum die Entscheidung auf „K Nearest Neighbor“ fiel, wird im Abschnitt 5.1.2 erläutert.
5.1.1 KNIME K-Means
KNIME besitzt bereits einen Knoten für das Clustern der Daten nach dem K-Means Algorithmus. Abbildungen 5.1 und 5.2 zeigen je den Workflow vor und nach der Ausführung.
Die Trainingsdaten werden über den File Reader Knoten eingelesen und dem K-Means Knoten übergeben. Dieser clustert alle Eingangsvektoren und übergibt gelabelte Vektoren dem K
Nearest Neighbor Knoten. Ein zweiter File Reader Knoten liest die Testdaten ein und leitet
sie ebenfalls an den K Nearest Neighbor Knoten als zweiter Input.
Nach einer erfolgreichen Klassifikation werden die Testdaten über den Bar Chart Knoten im
Diagramm angezeigt.
27
5 Szenario und Evaluation
Abbildung 5.1: KNIME K-Means vor der Ausführung
Abbildung 5.2: KNIME K-Means nach der Ausführung
28
5.1 Szenario
Abbildung 5.3: Mahout K-Means vor der Ausführung
5.1.2 Mahout K-Means
Im Gegensatz zu einem standardmäßigen K-Means Knoten aus KNIME ist der Mahout KMeans Knoten auf die Verarbeitung großer Daten ausgelegt, deswegen besitzt der letzte keine
Eingangskante für z.B. einen File Reader Knoten, da die Daten als Eingabedateien über das
Dialogmenü übergeben werden. Ein File Reader Knoten nimmt bereits beim standardmäßigen K-Means viel Zeit in Anspruch und dies bevor K-Means überhaupt ausgeführt wird, bei
größeren Daten würde die Einlesezeit ins Unermessliche steigen und würde keinen Vorteil
bringen, da die Daten sowieso ins HDFS kopiert werden und der Benutzer sie bereits auf der
eigenen Platte hat. Dies hat zur Folge, dass der Workflow mit dem Mahout Knoten etwas kleiner ausfällt.
Ein weiterer Unterschied ist bei der Ausgabe des Mahout K-Means Knotens zu sehen. Es ist
nicht möglich alle Inputvektoren gelabelt auszugeben, da die Daten wiederum zu groß sind
und der nächste Knoten überlastet wäre. Hilfe an der Stelle verschafft möglichst kleine Ausgabe und dies ist nur möglich, wenn man Zentroide (Schwerpunkte) gelabelt ausgibt. D.h. bei
k gesetzten Clustern verkleinert sich die Ausgabe auf k gelabelte Vektoren.
Besitzt man nur die Zentroide als Trainingsdaten, empfiehlt es sich für die Testdaten zu entscheiden, zu welchem Zentroid der jeweilige Vektor am nähesten liegt, aus diesem Grund
wurde an der Stelle der „K Nearest Neighbor“ Klassifikator verwendet.
Die Testdaten stellen kleine Daten dar. Somit bekommt der Klassifikator nur kleine Daten an
beiden Input-Kanten und führt die Klassifikation wesentlich schneller durch als beim KNIME
K-Means Knoten.
29
5 Szenario und Evaluation
Abbildung 5.4: Mahout K-Means nach der Ausführung
5.2 Evaluation
5.2.1 Einzelinstanz
Um die Performance vergleichen zu können, wird bereits in diesem Kapitel vorgestelltes Szenario verwendet. Es werden die gleichen Daten für zwei Workflows verwendet und für den
Ablauf benötigte Zeit gemessen. Die beiden Workflows unterscheiden sich in der Anzahl der
File Reader Knoten, K-Means Knoten von Mahout benötigt keinen File Reader, und an den
beiden K-Means Knoten, Workflow 1 mit dem K-Means Knoten von KNIME, Workflow 2
mit dem K-Means Knoten von Mahout.
Testumgebung:
• Intel(R) Core(TM) i7-2640M CPU 2.80 GHz
• 2 GB Arbeitsspeicher
• HDD Festplatte
• 10 MB Textdatei für die Testdaten
• 1 MB - 4 GB Textdateien für die Trainingsdaten
• 10 Cluster für K-Means Output
30
5.2 Evaluation
• Maximal 10 Iterationen
Die Test- und Trainingsdaten wurden mit einem Generator erstellt.
Größe
1 MB
10 MB
50 MB
200 MB
500 MB
1 GB
2 GB
4 GB
KNIME K-Means
FR1
FR2
K-Means
0 sec
4 sec 2 sec
5 sec
6 sec 15 sec
15 sec
5 sec 1:15 min
1:10 min
6 sec 5:19 min
1:47 min
4 sec 12:02 min
3:59 min
5 sec 26:38 min
9:10 min
5 sec 1:08 h
20:46 min 6 sec HS
Größe
1 MB
10 MB
50 MB
200 MB
500 MB
1 GB
2 GB
4 GB
Mahout K-Means
FR
K-Means KNN
3 sec 2:01 min
1 sec
4 sec 2:06 min
1 sec
4 sec 2:31 min
1 sec
5 sec 3:53 min
0 sec
5 sec 6:56 min
0 sec
5 sec 11:18 min 1 sec
4 sec 20:50 min 0 sec
3 sec 42:21 min 2 sec
KNN
13 sec
3:40 min
20:41 min
1:41:06 h
HS
HS
HS
HS
Gesamt
19 sec
4:06 min
22:16 min
1:47:41 h
HS
HS
HS
HS
Gesamt
2:05 min
2:11 min
2:36 min
3:58 min
7:01 min
11:24 min
20:54 min
42:26 min
FR - File Reader vor dem K Nearest Neighbor Knoten (Testdaten Mahout)
FR1 - File Reader vor dem K-Means Knoten (Trainingsdaten KNIME)
FR2 - File Reader vor dem K Nearest Neighbor Knoten (Testdaten KNIME)
HS - Java Heap Space Overflow
KNN - K Nearest Neighbor
Tabelle 5.1: Vergleich K-Means KNIME und Mahout (Laufzeiten)
Tabelle 5.1 zeigt die Ausführungszeiten beider Workflows mit der jeweiligen Größe der
Testdaten in der ersten Spalte. Dabei wurde nur die Zeit für der Verarbeitung betrachtet, d.h.
die Zeit zwischen dem Starten und Beenden eines Workflows und nicht die, die für das Konfigurieren eines Knotens benötigt wurde. Denn z.B. der File Reader Knoten benötigt bereits
bei der Konfiguration einer Datei, die größer als 50 MB ist, einige Minuten, um die Datei
einzulesen. Dies würde dann gegen den K-Means Knoten von KNIME sprechen, da dieser
die Daten vom File Reader übergeben bekommt. Die Testdaten haben eine geringe Größe und
benötigen bei beiden Workflows etwa die gleiche Zeit für das Einlesen, da sie Daten für den
K Nearest Neighbor Knoten liefern.
31
5 Szenario und Evaluation
Abbildung 5.5: K-Means Java heap space overflow
Die beiden File Reader Knoten (FR2 vom K-Means KNIME Knoten und FR vom K-Means
Mahout Knoten) benötigen etwa die gleiche Zeit, da sie in beiden Fällen die gleiche Funktion
erfüllen. FR1 ist im Workflow mit dem Mahout Knoten nicht vorhanden und ist somit nur bei
kleinen Daten vernachlässigbar.
Der Vorteil für den K Nearest Neighbor Knoten bei Mahout, dass dieser höchstens 2 Sekunden für die Verarbeitung braucht, liegt, wie im Abschnitt 5.1.2 beschrieben, daran, dass nur
die Zentroide an diesen übergeben werden und nicht der ganze Input gelabelt von K-Means.
Bei einer Dateigröße bis 10 MB ist der Overhead für das Starten und Stoppen von Hadoop so
groß, dass es an der Stelle vorteilhafter ist den standardmäßigen K-Means Knoten von KNIME zu benutzen.
Bei 500 MB bekommt der K Nearest Neighbor Knoten ein Java Heap Space Overflow Problem. Obwohl K-Means mit den Dateien solcher Größe zurechtkommt, scheitert es am nächsten Knoten. Dabei ist die Verarbeitung mit dem Mahout Knoten nicht nur schneller, sondern
überhaupt möglich.
Eine 4 GB große Datei kann auch der K-Means KNIME Knoten nicht mehr bewältigen, Java
Heap Space Overflow lautet wieder die Fehlermeldung (Abbildung 5.5). Mit einer Gesamtlaufzeit von 42:26 min ist die Verarbeitung derselben Datei im Workflow mit dem Mahout
Knoten erfolgreich abgeschlossen.
32
5.2 Evaluation
Die Entscheidung für die Verarbeitung zwischen den beiden Knoten lässt sich anhand der
Größe der Trainingsdaten klären. Nur die Laufzeit der beiden K-Means Knoten zu messen
und zu vergleichen macht wenig Sinn, da diese unterschiedliche Ausgaben haben. Wenn im
Workflow mit dem KNIME K-Means Knoten bei kleinen Daten die Laufzeit für den File Reader vernachlässigbar ist, so beträgt diese Zeit bereits bei 200 MB fast 1/3 der Gesamtlaufzeit
im Workflow mit dem Mahout Knoten.
In jedem Durchgang wurde der Workflow entweder abgebrochen oder mit einer bestimmten
Gesamtlaufzeit und zu verarbeitenden Dateigröße erfolgreich beendet. Abbildung 5.2.1 zeigt
die durchschnittliche Menge an MB, die innerhalb einer Minute verarbeitet wurde. Rote Linie
stellt den Workflow mit dem Mahout Knoten, blaue Linie den mit dem KNIME Knoten dar.
Der höchste Wert beim KNIME Knoten konnte mit 1 MB in 19 sek. erreicht werden, dies
entspricht etwa 3.16 MB/min. Danach hat die durchschnittliche Menge bei den Tests abgenommen und endete mit dem 4-ten Durchlauf mit einer Dateigröße von 200 MB.
Die durchschnittliche Menge im Workflow mit dem Mahout Knoten pro Minute stieg mit der
wachsenden Größe der Daten bis 2 GB. Bei knapp über 2 GB wäre ein Hochpunkt zu erwarten. Danach nahm die Menge pro Minute langsam ab. Z.B bei einer Verdoppelung der
Datenmenge von 2 GB auf 4 GB ist die Geschwindigkeit nur um fast 2 MB/min gefallen.
33
5 Szenario und Evaluation
Durchschnittlich verarbeitete Größe / Minute
100
90
80
70
Mahout Knoten
KNIME Knoten
MB/min
60
50
40
30
20
10
3.16
0
1 200 500
1024
2048
Dateigröße in MB
4096
Bemerkung: Die Evaluation wurde mit dem K-Means-Knoten durchgeführt, da die
Aufteilung des Knotens (in Start-, Input-, Clustering- und Fetch-Knoten) keine relevante
Änderung mit sich bringt. Diese Knote führen die gleichen Aufgaben durch und übergeben
die Ergebnisse weiter an den nächsten Knoten. Die Zeiten für die Ausführung werden in der
Tabelle 5.2 gegenübergestellt.
Größe
1 GB
2 GB
4 GB
Start
45 sec
45 sec
46 sec
Mahout K-Means vs. Mahout Workflow
Input
Clustering Fetch Stop Gesamt
1:14 min 10:08 min 8 sec 1 sec 12:16 min
2:26 min 17:32 min 9 sec 1 sec 20:53 min
6:20 min 33:50 min 9 sec 1 sec 40:20 min
K-Means
11:18 min
20:50 min
42:21 min
Tabelle 5.2: Vergleich K-Means Mahout und Mahout Workflow (Laufzeiten)
34
5.2 Evaluation
5.2.2 Cluster
Die Verarbeitung der Daten kann nicht nur auf einem Rechner stattfinden, sondern auf
mehrere Knoten in einem Cluster verteilt werden. Als Cluster wird hier zum Vergleich noch
ein Rechner mit folgenden Werten und Testdaten zu der vorherigen Maschine hinzugefügt:
• AMD Phenom II X4 945 3 GHz
• 4 GB Arbeitsspeicher
• HDD Festplatte
• Netzwerkkarte mit 1 Gbit/s
• 10 MB Textdatei für die Testdaten
• 1 GB - 16 GB Textdateien für die Trainingsdaten
• 10 Cluster für K-Means Output
• Maximal 10 Iterationen
Daraus ergibt sich ein kleines Netzwerk aus insgesamt 2 Maschinen. Als Master wird die
gleiche Maschine aus Abschnitt 5.2.1 verwendet. Die zweite Maschine wird in diesem Fall
als Slave eingesetzt.
Einzelinstanz K-Means
Größe FR
K-Means
1 GB
5 sec 11:18 min
2 GB
4 sec 20:50 min
4 GB
3 sec 42:21 min
8 GB
3 sec 1:27:47 h
16 GB 5 sec 2:53:42 h
KNN
1 sec
0 sec
2 sec
2 sec
1 sec
Gesamt
11:24 min
20:54 min
42:26 min
1:27:51 h
2:53:48 h
Cluster K-Means
FR
K-Means KNN
5 sec 09:35 min 1 sec
5 sec 16:44 min 1 sec
5 sec 30:45 min 1 sec
4 sec 1:06:38 h 1 sec
4 sec 2:12:08 h 1 sec
Gesamt
09:41 min
16:50 min
30:51 min
1:06:43 h
2:12:13 h
FR - File Reader vor dem K Nearest Neighbor Knoten (Testdaten Mahout)
KNN - K Nearest Neighbor
Tabelle 5.3: Vergleich K-Means Mahout Einzelinstanz und Cluster
Wie man aus der Tabelle 5.3 ablesen kann, sind bereits bei der kleinst gewählten Menge von
1 GB Größe deutlich bessere Ergebnisse bei der Durchlaufzeit in einem Cluster zu
beobachten. Die ganzen Daten müssen zwar über’s Netzwerk auf alle Rechner übertragen
werden, doch die Verteilung der Aufgaben auf mehrere Prozessorkerne bringt eine schnellere
Verarbeitung und verkürzt somit auch die Gesamtlaufzeit. Bei 4 GB z.B. ist die
Durchlaufzeit um ca. 25% schneller.
35
5 Szenario und Evaluation
Durchschnittlich verarbeitete Größe / Minute
Einzelinstanz
Cluster
130
MB/min
120
110
100
90
1
2
4
8
Dateigröße in GB
16
Abbildung 5.6: Verarbeitungsgeschwindigkeit Einzelinstanz und Hadoop Cluster
36
5.2 Evaluation
Abbildung 5.6 stellt den Vergleich zwischen einer einzelnen Maschine (blau) und einem
Cluster aus zwei Maschinen (rot) dar. Der starke Abfall der Performanz bei 8 GB wird durch
eine zusätzliche Auslastung der Rechner verursacht, was wiederum zeigt, dass die Leistung
der einzelnen Maschinen von großen Bedeutung ist.
Insgesamt betrachtet ist eine deutliche Steigerung der Performanz im Gegensatz zu einer
Maschine zu sehen.
37
6 Schlussbetrachtung
6.1 Ergebnisse dieser Arbeit
In dieser Bachelorarbeit konnte ich mein im Studium erlerntes Wissen in der Entwicklung
des Projektes anwenden und vertiefen. Angefangen mit der Planung des gesamten Ablaufes
über Programmierung bzw. einer Weiterentwicklung eines bestehendes Projektes bis hin zum
kontinuierlichen Testen und der Evaluation des Endergebnisses.
Im Laufe der Arbeit bin ich auf einige Schwierigkeiten gestoßen, die ich mit Hilfe meiner
Ansprechpartner (Betreuer), beseitigen konnte.
Obwohl das Ergebnis dieser Arbeit nicht die ultimative Lösung für alle Algorithmen aus
Mahout ist, sehe ich das Projekt als erfolgreich an, da dieses die Möglichkeit bietet, KNIME
und Mahout zu verbinden und dadurch das Arbeiten mit Mahout den KNIME Nutzern zu
realisieren.
6.2 Ausblick
Der Mahout-Knoten stellt bereits eine Schnittstelle zwischen Mahout und KNIME dar, es ist
aber genauso möglich weitere Knoten zu erstellen. Der erste Grund warum es nicht nur einen
Mahout-Knoten für alle Algorithmen gibt, ist, dass die Eingabe unterschiedlich sein kann,
aber auch die Ausgabe bei den meisten Algorithmen auf eine andere Art und Weise
ausgelesen werden muss. Ein weiterer Grund ist die Weitergabe der Daten innerhalb eines
Workflows, denn auch hier ist der Entwickler für die Weitergabe der Daten, also wie und
welche Daten weitergeleitet werden, verantwortlich. Zusätzlich müssen Entscheidungen
getroffen werden, welche Einstellungen der Benutzer für den jeweiligen Knoten vornehmen
darf.
In dieser Arbeit vorgestellte Clustering Verfahren und Recommendation können noch
zusätzlich um Klassifikatoren erweitert werden. Dabei handelt es sich um mehrere
Klassifikatoren aus der Mahout Sammlung.
38
7 Anhang
Beiliegend zu dieser Ausarbeitung ist eine DVD mit der virtuellen Maschine verfügbar.
Diese enthält unter ’Documents’ die Entwicklungsumgebung mit dem Quellcode, die
KNIME-Umgebung und die Beispieldaten auf dem Desktop.
39
Literaturverzeichnis
[1] KNIME.com AG, 2013. CTAN: http://www.knime.org.
[2] Cheng-Tao Chu, Sang Kyun Kim, Yi-An Lin, Yuan Yuan Yu, Gary Bradski, Andrew Y.
Ng, and Kunle Olukotun. Map-Reduce for Machine Learning on Multicore.
[3] Actian Corporation. Pervasive partner, 2013. CTAN:
http://bigdata.pervasive.com/Partners/KNIME.aspx.
[4] J. Deanl and S. Ghemawat.
MapReduce - Simplified Data Processing on Large Clusters. San Francisco, USA,
2004.
[5] The Apache Software Foundation. Hdfs users guide, 2012. CTAN:
http://hadoop.apache.org/common/docs/current/hdfs_user_guide.html.
[6] The Apache Software Foundation. K-means clustering, 2013. CTAN: https:
//cwiki.apache.org/confluence/display/MAHOUT/K-Means+Clustering.
[7] Maciej Niemczyk. Entwurf und Implementierung eines Verfahrens zur Analyse
komplexer Daten insbesondere auf strukturelle Ähnlichkeit. pages 46–47, 2011.
[8] Michael G. Noll, 2013. CTAN: http://www.michael-noll.com/tutorials/
running-hadoop-on-ubuntu-linux-multi-node-cluster/.
[9] Sean Owen, Robin Anil, Ted Dunning, and Ellen Friedman. Mahout In Action. 2011.
[10] Paul Levi und Ulrich Rembold. Einführung in die Informatik für Naturwissenschaftler
und Ingenieure. (4), 2003.
40