Andere Kunden kauften auch ...

Tutorial: Realisierung eines Empfehlungssystems mit Apache Mahout

David Broßeit, Karsten Voigt
andere-kunden-kaufen-auch

© Shutterstock / gpointstudio

„Das könnte Sie auch interessieren …“ oder „Andere Nutzer kauften auch …“ – wie oft trifft man auf diese oder ähnliche Formulierungen beim Einkaufen im Onlineshop seines Vertrauens. Aber woher weiß das Unternehmen, was mich interessiert, und wie lässt sich ein solches System ohne großen Aufwand umsetzen? Eine Lösung: Apache Mahout.

Mahout ist ein kostenloses, quelloffenes, unter dem Dach der Apache Software Foundation entwickeltes Java- und Scala-basiertes Framework, das sich verschiedener Aspekte der Verarbeitung und Auswertung von Massendaten annimmt. Mahout stellt dabei eine Sammlung von Algorithmen für intelligente und lernende Systeme zur Verfügung. Die Themenblöcke Clusterbildung, Klassifizierung und kollaboratives Filtern werden von Mahout unterstützt und sollen in dieser dreiteiligen Artikelserie näher betrachtet werden.

Die Clusterbildung versucht Elemente in einer Datenbasis zu gruppieren, d. h. zum Beispiel Kunden zu Kundengruppen automatisch zuzuordnen. Bei der Klassifizierung werden Eigenschaften von Objekten untersucht, um die Objekte mit einer bestimmten Wahrscheinlichkeit einer Eigenschaft zuzuordnen, wobei das System selbst aus den Erfahrungswerten lernt. Ein klassisches Beispiel für die Klassifizierung ist die Erkennung von Spam in E-Mails. Innerhalb des kollaborativen Filterns werden Nutzerinteressen ausgewertet, um daraus Empfehlungen ableiten zu können. Für die Umsetzung von modernen Empfehlungssystemen greifen dabei oft alle drei Themen ineinander. Fachlich sollen die erhobenen Kundendaten effizient analysiert und ausgewertet werden, sodass einem Kunden intelligent die richtige Werbung oder richtige Empfehlung angezeigt wird. Am Ende sollen Privat- und Geschäftskunden mehr oder höherwertige Produkte kaufen. Die Abbildungen 1 und 2 zeigen eine durch Mahout erzeugte Produktempfehlung in IBM WebSphere Commerce. Die verwendeten Mechanismen sind jedoch unabhängig von dem eingesetzten E-Commerce Framework und nicht auf E-Commerce Szenarien beschränkt.

Die Artikelreihe fokussiert sich auf die aktuell verfügbaren in Java implementierten Algorithmen und die programmatische Ausführung selbiger. Für die meisten Algorithmen und Prozesse stehen auch Kommandozeilenaufrufe zur Verfügung, die hier jedoch nicht näher betrachtet werden sollen. In neueren Mahout-Versionen wird zusätzlich verstärkt Scala zum Einsatz kommen.

Recommender recommender = new GenericUserBasedRecommender(dataModel, neighborhood, similarity);
Abb. 1: Produktempfehlungen

Abb. 1: Produktempfehlungen

Abb. 2: Produktempfehlungen

Abb. 2: Produktempfehlungen

Mahout im Überblick

Zur Realisierung der verschiedenen Aufgaben bietet Mahout eine Vielzahl an Mechanismen an, die per Kommandozeile oder programmatisch ausgeführt werden können. Technologisch sind diese Algorithmen mit Standard-Java-Mitteln implementiert. Für die Massendatenverarbeitung kommt jedoch Apache Hadoop oder bei neueren Implementierungen Apache Spark zum Einsatz. Mit der Verwendung von Mahout für große Datenmengen sollte man auch die grundlegenden Konzepte hinter Hadoop oder Spark verstehen. Für die einfachen Algorithmen sind allgemeine Java-Kenntnisse ausreichend. Im Folgenden werden nun die Möglichkeiten der Produktempfehlung näher betrachtet und an einem Beispiel beschrieben. Zur Implementierung wird eine aktuelle Version des Mahout-Frameworks benötigt (mindestens Version 0.9). Die meisten Algorithmen sind auch in den neueren Versionen enthalten, jedoch werden manchmal auch einzelne Implementierungen nicht weiter fortgeführt. Die Qualität bzw. Aktualität einzelner Algorithmen hängt leider auch stark vom Einsatz der entsprechenden Contributors ab. In Summe besteht Mahout aus einer Vielzahl an Bibliotheken, die man je nach Anwendungsfall einbinden muss.

Bevor wir nun mit der beispielhaften Implementierung beginnen, benötigen wir eine entsprechende Datenbasis. Für den Entwickler besteht hier schon fast das größte Problem, eine ausreichende Menge an realitätsnahen Daten zu erhalten. Bei der Verwendung kleiner Datenmengen lässt sich meist nicht die Effizienz oder Korrektheit der Algorithmen bewerten. Die Daten für eine Empfehlungs-Engine müssen zu einem Kunden, Artikel mit einer evtl. Bewertung sind enthalten. Die Artikel könnten dabei aus dem Kaufverhalten (Warenkörbe) ausgelesen werden, aber auch andere Quellen wie die Webanalyse sind verwendbar. Die Angabe einer Bewertung ist optional. Sollten in der Datenbasis keine Bewertungen vorhanden sein, wird nur die Existenz von Datensätzen bewertet. Möchte man dennoch seinen Datensätzen eine Gewichtung geben, lassen sich eigene Bewertungssysteme festlegen. Beispielsweise könnte als Bewertung die Häufigkeit des Produkterwerbs oder nur die reine Ansicht eingesetzt werden. Demzufolge haben häufig gekaufte Produkte eine „bessere“ Bewertung als weniger gekaufte Produkte und nur angezeigte Produkte.

Aufbau eines Datenmodells

Die für die Ausführung der Berechnungen notwendigen Daten werden über ein Datenmodell geladen. Das Datenmodell speichert die für die Berechnungen relevanten Daten und ermöglicht einen zentralen Zugriff. Für das Aufbauen des Datenmodells wird eine Instanz vom AbstractDataModel benötigt. Für einfache Aufgaben kann dazu das FileDataModel verwendet werden. Bei komplexen Datenstrukturen und insbesondere bei großen Datenmengen wird eine alternative Datenquelle empfohlen. Gleichzeitig kann auch das FileDataModel erweitert werden, sodass hier der Datenzugriff für eigene Strukturen optimiert werden kann. Für den Aufbau einer einfachen Datei wird das folgende Pattern verwendet:

userID,itemID[,preference,[,timestamp]]

Die Nutzer-ID und Artikelnummer müssen sich als long und die Gewichtung (preference) als double parsen lassen. Gleichzeitig muss die Datei konsistente Informationen enthalten. Das heißt, wurde einmal eine Gewichtung mitgegeben, so muss dies für alle Einträge erfolgen. Liegt die Datenbasis vor, so kann die Auswertung mit Mahout beginnen.

DataModel dataModel = new FileDataModel(new File(yourinput));

Das FileDataModel besitzt zusätzlich einen Updatemechanismus. Erweiterungen und Anpassungen der Datenbasis können in ein bestehendes Model importiert werden.

Wer ist mir am ähnlichsten?

Für die Auswertung möglicher Empfehlungen steht eine Reihe an Algorithmen zur Verfügung. Im Folgenden wird die Variante der nutzerbasierten Empfehlung näher betrachtet. Der Grundgedanke liegt darin, dass nach Benutzern gesucht wird, die dieselben Interessen aufweisen. Die Basis dafür bildet das Kaufverhalten. Aus Performancesicht sind nutzerbasierte Empfehlungen im Allgemeinen schneller, wenn die Anzahl von Produkten höher ist als die Anzahl von Benutzern.

Für die Berechnung zur Ähnlichkeit von Benutzern wird ein Objekt der Klasse UserSimilarity und ein dazugehöriger Berechnungsalgorithmus benötigt. Als Parameter wird das zuvor definierte Datenmodell angegeben.

UserSimilarity similarity = new LogLikelihoodSimilarity(dataModel);

Details zum oben genannten Algorithmus können hier nachgelesen werden. Eine Reihe weiterer Standardalgorithmen steht zur Verfügung, wobei natürlich auch Eigenimplementierungen möglich sind:

  • LogLikelihoodSimilarity
  • TanimotoCoefficientSimilarity
  • PearsonCorrelationSimilarity
  • EuclideanDistanceSimilarity
  • SpearmanCorrelationSimilarity
  • UncenteredCosineSimilarity

Generell lässt sich keine Aussage treffen, welcher Algorithmus der genaueste oder schnellste ist. Die besten Empfehlungen lassen sich immer nur durch A/B-Tests herausfinden. Im finalen System sollte man also mit verschiedenen Algorithmen experimentieren und schauen, welche Informationen die besten Conversions erzielen. Am Ende wird die technische Produktempfehlung nicht alleine für den Erfolg einer Marketingmaßnahme verantwortlich sein. Tabelle 1 zeigt die durchschnittliche Performance (Zeit in Sekunden) von verschiedenen Algorithmen bei unterschiedlicher Anzahl von Datensätzen bei nicht parallelisierter Ausführung. Als Datenbasis dienten hierbei Bewertungen von Filmen. Die Bewertungen lassen sich hier herunterladen. Für die eigene Beispielimplementierung stellen diese Datensätze eine gute Ausgangslage dar.

Tabelle 1: Gegenüberstellung verschiedener Algorithmen und ihrer Laufzeiten

Tabelle 1: Gegenüberstellung verschiedener Algorithmen und ihrer Laufzeiten

Im weiteren Vorgehen benötigt man eine Implementierung des Interface UserNeighborhood zur Festlegung, welche Benutzer sich am ähnlichsten sind. Im Standard besteht die Auswahl zwischen den Klassen NearestNUserNeighborhood und ThresholdUserneighborhood. Der Unterschied besteht darin, dass bei NearestNUserNeighborhood eine Anzahl von Benutzern angegeben wird, die sich am ähnlichsten sein sollen. Bei ThresholdUserneighborhood wird ein Schwellwert angegeben. Liegt die Übereinstimmung über dem Schwellwert, wird der Benutzer als „Nachbar“ deklariert. Im Beispiel wird die Variante NearestNUserNeighborhood genutzt.

UserNeighborhood neighborhood = new NearestNUserNeighborhood(nearestNUser, similarity, dataModel);

Mit der so aufbereiteten Datenbasis können die eigentlichen Empfehlungen generiert werden. Dazu wird ein Recommender benötigt, der die Präferenzen der Nutzer berücksichtigt. Die Klasse GenericUserBasedRecommender erfüllt die notwendigen Voraussetzungen. Liegen keine Bewertungen vor, so kann GenericBooleanPrefUserBasedRecommender verwendet werden.

Recommender recommender = new GenericUserBasedRecommender(dataModel, neighborhood, similarity);

Die Empfehlungen zu allen Nutzern sind nun im Objekt recommender abgespeichert. Zur Ermittlung der Empfehlungen für einen konkreten Nutzer muss nur noch die Methode recommend aufgerufen werden. Die Methode erwartet zum einen die ID des Nutzers und zum anderen die Anzahl der gewünschten Empfehlungen. Sollen einzelne Ergebnisse nochmals anders gewichtet werden, so kann ein eigener IDRescorer definiert werden. Der IDRescorer ermöglicht es dabei, mithilfe der ID eines Elements auf Basis der originalen Bewertung einen neuen Wert festzulegen. Das Ergebnis einer Bewertung ist eine Liste an Datenobjekten mit einer ID (Artikelnummer) und einer Stärke der Empfehlung. Je höher der Wert ist, desto valider ist die generierte Empfehlung. Die Abbildung 3 zeigt noch einmal schematisch die Zusammenhänge.

Abb. 3: Schema für nutzerbasierte Bewertungen

Abb. 3: Schema für nutzerbasierte Bewertungen

Evaluierung von Produkten

Stellt sich nun die Frage, wie aussagekräftig die Stärken der ermittelten Bewertungen bzw. ob die Empfehlungen überhaupt valide sind. Dies lässt sich mithilfe des RecommenderEvaluator analysieren. Dazu wird die Datenbasis in eine Trainigsdatenbasis und in eine Testdatenbasis geteilt. Der Codeausschnitt in Listing 1 zeigt exemplarisch, wie eine solche Evaluierung stattfindet.

Listing 1

RecommenderBuilder userSimRecBuilder = new RecommenderBuilder()
  {
    public Recommender buildRecommender(DataModel dataModel) throws TasteException
    {
      UserSimilarity similarity = new LogLikelihoodSimilarity(dataModel);
      UserNeighborhood neighborhood = new NearestNUserNeighborhood(nearestNUser, similarity, dataModel);
      Recommender recommender = new GenericUserBasedRecommender(dataModel, neighborhood, similarity);

      return recommender;
    }
  };

  RandomUtils.useTestSeed();
  DataModel dataModel = new FileDataModel(new File(yourinput));
  RecommenderEvaluator evaluator = new AverageAbsoluteDifferenceRecommenderEvaluator();

  double userScore = evaluator.evaluate(userSimRecBuilder, null, dataModel, trainingPercentage, evaluationPercentage);

Zunächst wird für das Berechnen der Empfehlungen eine Instanz des RecommenderBuilder benötigt. Diese Instanz überschreibt die Methode buildRecommender, die die Berechnung der Empfehlungen vornimmt. Für die Erzeugung von Zufallszahlen wird die Klasse RandomUtils in den verschiedenen Algorithmen eingesetzt. Um für die Tests nun ein gleichbleibendes Ergebnis bei gleichen Ausgangsdaten zu erhalten, wird mithilfe der Methode useTestSeed() festgelegt, dass immer dieselben Zufallsparameter beim Teilen der Datenbasis verwendet werden. Diese Methode darf niemals in produktivem Code verwendet werden. Für die Evaluierung wird anschließend eine Implementierung des RecommenderEvaluator benötigt. Der AverageAbsoluteDifferenceRecommenderEvaluator berechnet die durchschnittliche Abweichung zwischen vorhergesagter und tatsächlicher Stärke der Empfehlung. Die Berechnung erfolgt abschließend mit der Methode evaluate. Als Parameter werden die folgenden Werte benötigt:

  • Instanz des RecommenderBuilder, der die Empfehlungen berechnet.
  • Instanz eines DataModelBuilders, dieser Parameter kann auch null gesetzt werden.
  • Das Datenmodell, das getestet werden soll.
  • Wert zwischen 0 und 1, als Angabe, wie viel Prozent der Datenbasis als Trainings- und Testdaten verwendet werden (Bsp: 0.7, es werden 70 Prozent Trainings- und 30 Prozent Testdatenbasis verwendet).
  • Wert zwischen 0 und 1, als Angabe, wie viel Prozent der Nutzer der Datenbasis zur Evaluierung berücksichtigt werden sollen.

Der anschließend berechnete Wert wird in userScore abgespeichert. Dieser Wert gibt nun die durchschnittliche Abweichung zwischen vorhergesagten und tatsächlichen Stärken der Empfehlung an. Je niedriger der Wert, desto besser ist die Empfehlung. Ist der Wert 0, können die Empfehlungen als perfekt gewertet werden.

Das Problem des „Cold Start“

Der bisherige Prozess betrachtet nur die Empfehlung von Produkten auf Basis des Verhaltens eines bekannten Nutzers. Das bedeutet: Man betrachtet, welche Produkte ein Kunde bisher gekauft oder bewertet hat. Was ist jedoch, wenn Empfehlungen zu einem Benutzer angezeigt werden sollen, der noch kein Produkt bewertet oder gekauft hat bzw. wie geht man mit Gastnutzern um? Dieses Problem wird als „Cold Start“ bezeichnet und ist dabei in zwei Fälle zu unterscheiden: 1. Wenn, wie bereits erwähnt, ein neuer Kunde nur Produkte im Onlineshop betrachtet, 2. wenn ein neues bisher nicht bewertetes oder gekauftes Produkt in das Sortiment das Onlineshops aufgenommen wird. Für dieses Problem gibt es keine Patentlösung. Dennoch soll im Weiteren ein Ansatz vorgestellt werden, wie das Problem des Cold Starts verringert werden kann.

Ähnlichkeit von Produkten

Ruft ein Nutzer einen Onlineshop auf und ist nicht eingeloggt bzw. hat noch keine Produkte betrachtet, lassen sich keine persönlichen Empfehlungen aussprechen. Sobald jedoch eine Produktseite aufgerufen wird, lässt sich mithilfe von Mahout eine Empfehlung anzeigen. Dazu verwendet man die Technik der Ähnlichkeit von Produkten. Die Realisierung erfolgt prinzipiell ähnlich wie im vorhergehenden Beispiel. Jedoch kommt nun eine produktbasierte Empfehlung zum Einsatz.

Zunächst wird wieder das Aufbauen einer Datenbasis nötig, und das weitere Vorgehen erfolgt analog zur Nutzerempfehlung, jedoch wird anstelle einer UserSimilarity eine ItemSimilarity verwendet. Das Benutzen einer UserNeighborhood entfällt. Der bisher verwendete Recommender wird durch den ItemBasedRecommender ersetzt.

ItemSimilarity similarity = new LogLikelihoodSimilarity(dataModel);
ItemBasedRecommender recommender = new GenericItemBasedRecommender(dataModel, similarity);
List<RecommendedItem> recommendations = recommender.mostSimilarItems(item, amount);

Nun lässt sich mithilfe der Methode mostSimilarItems eine Anzahl von Produkten in einer Liste ablegen, die einem anderen Produkt am meisten ähnlich sind, unter Berücksichtigung bekannter Kaufmuster. Der erste Parameter gibt an, auf welches Produkt Bezug genommen werden soll. Möchte man mehrere Produkte angeben, so ist ein Array mit den jeweiligen Produktnummern zu verwenden. Als Zweites wird nun wie immer angegeben, wie viele Empfehlungen angezeigt werden sollen.

Frequent Pattern Mining

Eine weitere Variante zur Ermittlung von potenziellen Empfehlungen ist die Identifikation wiederkehrender Muster in Warenkörben (Assoziationsanalyse). Besonders im B2B-Umfeld oder beim Verkauf von Gebrauchsgütern lassen sich oft ähnliche Warenkörbe identifizieren. Ein Heizungsbauer in Berlin bestellt im Allgemeinen ähnliche Produkte wie ein Heizungsbauer in Hamburg oder München. Die Herausforderung besteht nun darin, Produkte oder Produktkombinationen zu finden, die oft zusammen gekauft werden. Die Bewertung einzelner Produkte ist hierbei nicht relevant. In Mahout wurde auch dafür der entsprechende Mechanismus umgesetzt.

Das Vorgehen zur Bewertung ist hier wieder sehr ähnlich. Zuerst müssen alle Bestellungen ausgelesen und gewichtet werden. Die einzelnen Produktnummern werden in einer Liste gesammelt und mit einem Supportwert verknüpft. Für das einfachere Verständnis wird der Wert 1 als Support verwendet, was sinngemäß bedeutet, dass die Transaktion mit ihren Produkten einmal vorgekommen ist. Alle folgenden Aussagen zum Supportwert bzw. zur Anzahl von Bestellungen etc. beziehen sich auf den Wert 1.

LinkedList<Pair<List<String>, Long>> transactions = new LinkedList<Pair<List<String>, Long>>();
...
transactions.add(new Pair<List<String>, Long>(listOfPartnumbers, 1L));

Für diese Daten werden nun die Häufigkeiten einzelner Produkte innerhalb aller Bestellungen ermittelt. Für die Ermittlung kann wieder ein Supportwert angegeben werden. Dieser Supportwert definiert, wie oft ein Produkt vorhanden sein muss, damit es bei der Ermittlung der Muster berücksichtigt wird. Wurde ein Produkt nur zweimal gekauft, kann man wahrscheinlich daraus noch keine Rückschlüsse ziehen. Der optimale Wert lässt sich hier nicht definieren, wobei man auch einen minimalen prozentualen Anteil an allen Bestellungen festlegen könnte. Hier sind Erfahrungswerte aus echten Systemen unerlässlich. Mit den so aufbereiteten Daten können nun die Muster ermittelt werden. Listing 2 zeigt den notwendigen Quellcode.

Listing 2

FPGrowth<String> fps = new FPGrowth<String>();
StautsUpdater updater = new StatusUpdater() {
  public void update(String status) {  }
};
OutputCollector output = 
  new OutputCollector<String, List<Pair<List<String>, Long>>>() {
  public void collect(String key, List<Pair<List<String>, Long>> value)
  throws IOException {
    for (Pair<List<String>, Long> v : value) {
      List<String> list = v.getFirst();
      if (!list.isEmpty()) results.put(Sets.newHashSet(list), v.getSecond());
    }
  }
};
Collection<Pair<String, Long>> frequencies = fps.generateFList(transactions.iterator(), minSupportPerItem);
fps.generateTopKFrequentPatterns(transactions.iterator(), frequencies, minSupport, patterns, retFeatures, output, updater);

Zuerst wird eine Instanz der Klasse mit der FPGrowth-Implementierung benötigt. Details zu diesem Algorithmus für das Frequent Pattern Mining sind hier zu finden. Dann werden zwei weitere Objekte erzeugt, die vom zugrunde liegenden MapReduce verwendet werden. Interessant ist hier der OutputCollector, da dieser die Ergebnisse sammelt und für die weitere Auswertung zur Verfügung stellt. Mit den Objekten wird dann der eigentliche Algorithmus ausgeführt. Als Parameter gibt man die folgenden Werte mit:

  • Iterator über die Gesamtheit der Transaktionen
  • Häufigkeit der einzelnen Produkte (generateFList)
  • Die minimale Anzahl an Bestellungen mit dem gefundenen Pattern (minSupport)
  • Die maximale Anzahl der Muster, die ermittelt werden soll (patterns)
  • Eine Liste an Produktnummern, für welche die Muster ermittelt werden sollen. Diese Liste kann null sein, dann werden alle Produkte berücksichtigt
  • Eine Instanz des OutputCollectors und die Instanz des StatusUpdaters

Lässt man sich die erzeugten Informationen ausgeben, so erhält man zum Beispiel die folgende Ausgabe (Artikelnummern wurden durch Produktnamen ersetzt):

TK Magnum Mandel :: TK Magnum Mandel, TK Magnum Gold, TK Calippo Cola :: 336

Die oben genannten Eissorten wurden in 336 Bestellungen gemeinsam gekauft und als ein wiederkehrendes Muster im Rahmen der Gesamtbestellungen für die Eissorte TK Magnum Mandel erkannt. Mit den so ermittelten Daten lassen sich weitere Faktoren berechnen, die Berücksichtigung in einem Empfehlungssystem finden sollten.

Beispiel der Mustererkennung

Das folgende Beispiel soll einige Kennzahlen der Mustererkennung verdeutlichen. Abbildung 4 zeigt einige Transaktionen mit den zugehörigen Produkten. Vorhandene Muster lassen sich durch die überschaubare Datenmenge direkt erkennen. Für einzelne Produkte bzw. Produktgruppen lässt sich als Erstes der Support bestimmen. Dieser Wert definiert das Verhältnis des Vorhandenseins eines Produkts/einer Produktgruppe zu der Gesamtanzahl der Transaktionen. Ein Support von 0,05 bedeutet, dass das Produkt in 5 Prozent der Bestellungen enthalten war. Eine weitere Kenngröße ist die Konfidenz, die den Anteil eines Musters an der Gesamtzahl an Bestellungen eines Produkts definiert. Dieser Wert dividiert den Supportwert des Musters durch den Supportwert des Einzelprodukts. Am Beispiel des Warenkorbs kommt Mayonnaise mit Pommes in 62,5 Prozent der Bestellungen vor (Support(Mayonnaise, Pommes)) und Mayonnaise alleine in 75 Prozent der Bestellungen (Support(Mayonnaise)), daraus ergibt sich dann die Konfidenz von 83 Prozent. Je höher dieser Wert ist, desto sicherer ist das Muster. Eine kleine Konfidenz beutet, dass ein Artikel auch oft außerhalb des Musters gekauft wird. Tabelle 2 stellt einige Werte auf Basis des Beispiels dar. Zusätzlich finden noch weitere Kennzahlen Anwendung. Der Lift zum Beispiel definiert das Verhältnis des Supports eines Musters zum Support, wenn die Bestandteile des Musters unabhängig wären (Support des Musters geteilt durch das Produkt der Supportwerte der Musterbestandteile).

Abb. 4: Beispielbestellungen

Abb. 4: Beispielbestellungen

Tabelle 2: Musterkennzahlen

Tabelle 2: Musterkennzahlen

Das Frequent Pattern Mining kann also zur Anwendung kommen, wenn ein Nutzer bereits Produkte in seinem Warenkorb hat. Dabei wird keine Rücksicht auf das bisherige Kaufverhalten des Kunden genommen. Die Empfehlungen auf Basis von Ähnlichkeiten sind besonders geeignet, wenn für einen Kunden das Kaufverhalten bekannt ist oder ein Kunde einzelne Produkte nur betrachtet hat.

Fazit

Zur Realisierung der unterschiedlichsten Aufgaben bietet Mahout eine Vielzahl an Algorithmen, die per Kommandozeile oder auch aus einem Java-/Scala-Programm heraus aufgerufen werden kann. Bei der Anwendung der verschiedenen Mechanismen zur Generierung von Produktempfehlungen sollte man immer auch etwas Zeit für die Betrachtung der mathematischen Grundlagen hinter den Algorithmen einplanen. Eine konkrete Empfehlung, welcher Algorithmus wann anzuwenden ist und welcher Algorithmus die besten Ergebnisse erzielt, lässt sich nur durch entsprechende Tests ermitteln. Am Ende treiben die fachlichen Anforderungen (Geschwindigkeit der Darstellung vs. Aktualität von Daten) und die vorhandenen Datenquellen die Entscheidung für einzelne Algorithmen. Gerade bei der Verwendung in E-Commerce Systemen kommen parallel dazu noch weitere Mechanismen, wie das Bilden von Kundenclustern, zur effizienten Verkaufssteuerung zum Einsatz.

Aufmacherbild: Happy woman doing online shopping via Shutterstock / Urheberrecht: gpointstudio

Geschrieben von
David Broßeit

David Broßeit studiert Wirtschaftsinformatik an der Hochschule für Technik und Wirtschaft in Dresden. Im Rahmen eines Praxissemesters im Bereich E-Commerce hat er sich mit dem Themenkomplex Big Data und intelligente Produktempfehlungen auseinander gesetzt.

Karsten Voigt

Karsten Voigt arbeitet für die T-Systems Multimedia Solutions als IT-Architekt für Enterprise-E-Commerce-Lösungen. Im Rahmen von B2B-Projekten setzt er verschiedene Technologien zur effizienten Produktpräsentation und Optimierung des Kaufverhaltens ein.

Kommentare

Hinterlasse einen Kommentar

1 Kommentar auf "Tutorial: Realisierung eines Empfehlungssystems mit Apache Mahout"

avatar
4000
  Subscribe  
Benachrichtige mich zu:
Felix Haller
Gast

Hi,

ich mache auch gerade eine Evaluierung von CF-Algorithmen mit Mahout. Dabei rufe ich die evaluate() Funktion wiederholt auf um anschließend Mittelwert und Standardabweichung berechnen zu können. Leider passiert es bei mehr als 2 oder 3 Wiederholungen, dass Mahout einfach ewig rechnet und die evaluate Funktion nicht fertig wird. Hattet ihr das schon mal? Ich finde im Netz nichts weiter dazu.