Topic Modeling der codecentric Blog-Artikel

Der größte Teil von Big Data sind unstrukturierte Daten. Wenn eine Organisation ihre oder externe Daten von sozialen Medien mit dem Ziel besserer Geschäftsentscheidungen nutzbar machen möchte, so besteht eine Herausforderung darin aus unstrukturierten Textdokumenten in natürlicher Sprache die wichtigen Informationen zu ziehen. Ein Hauptziel von Techniken des Natural Language Processing (NLP) ist es Text in strukturierte Daten zu überführen, die für weitere Analysen genutzt werden können.

Ein wichtiges Beispiel von NLP sind probabilistische Topic Modelle, die versuchen gemeinsame Topics oder Themen in einer Sammlung von Dokumenten zu entdecken. Zu diesem Zweck wurden eine Reihe von Unsupervised Machine-Learning-Algorithmen entwickelt. Die gefundenen Topics können genutzt werden um die Sammlung von Dokumenten zu verwalten und zu organisieren. Verschiedene Fragen im Rahmen von Data-Science -Projekten können adressiert werden. Ein Beispiel ist Recommendation: „Welche Artikel sind am relevantesten für ein bestimmten Thema?“. Ein weiteres Anwendungsfeld betrifft Clustering: „Was wird in neuen Artikeln diskutiert und wie ähnlich sind sich zwei Artikel?“. Die abgeleiteten Topics können außerdem als Dimensionsreduktion angesehen werden oder dienen als Feature für weiterführende Machine-Learning-Anwendungen (Feature Engineering).

In diesem Artikel präsentieren wir Ergebnisse einer Topic-Modellierung im codecentric Blog. Die Topics werden genutzt um den Inhalt des Blogs sowie dessen zeitliche Veränderung zu analysieren. Natürlich könnte man argumentieren, dass die meisten Autoren ihre Blog Posts einer Kategorie zuordnen und zusätzliche Tags benutzen um Hinweise auf den Inhalt des Posts zu geben. Im Fall von sehr großen Sammlungen von Dokumenten und wenn keine Annotationen vorhanden sind, ist Topic-Modellierung ein adäquates Werkzeug.

Die Analysen werden mit Apache Spark und dessen Python API durchgeführt. Das entsprechende Jupyter Notebook kann von GitHub geladen werden. Spark erlaubt es skalierbare Machine Learning (ML) Pipelines zu bauen, welche hier die Latent Dirichlet Allocation (LDA ) Topic Modellierung aus der Machine-Learning-Bibliothek (MLlib ) enthält. Wie ein kleiner Spark Cluster aufgesetzt wird, ist in diesem Post beschrieben. Ein weiterer Vorteil von Spark ist es, dass entwickelte Prototypen eines Datenproduktes relativ einfach in eine Produktionsumgebung überführt werden können.

Dieser Artikel ist in fünf Sektionen unterteilt:

LDA Topic Modell
Daten Vorverarbeitung
Modell Training und Evaluation
Ergebnisse
Zusammenfassung

Die ersten drei Sektionen beschreiben einige theoretische Konzepte von LDA Topic Modellierung sowie Details zur Implementierung von Daten-Vorverarbeitung und Modell Training. Weniger technisch interessierte Leser können direkt zu den Ergebnissen springen.

LDA Topic Modell

Im Natural Language Processing beschreiben probabilistische Topic-Modelle die semantische Struktur einer Sammlung von Dokumenten, dem sogenannten Corpus. Latent Dirichlet Allocation (LDA ) ist das bekannteste und erfolgreichste Modell zur Aufdeckung gemeinsamer Topics als die versteckte Struktur einer Sammlung von Dokumenten. Demnach werden Textdokumente durch eine Mischung von Topics repräsentiert. Das bedeutet, dass ein Dokument ein oder mehrere Topics mit verschiedenen Anteilen behandelt. Ein Topic kann als eine Gruppe ähnlicher Wörter angesehen werden. Formaler ausgedrückt: das Modell nimmt an, dass jedes Topic durch eine Verteilung über ein festes Vokabular charakterisiert wird und dass jedes Textdokument durch eine Verteilung von Topics generiert wird.

Die grundlegende Annahme von LDA ist, dass Dokumente durch einen zwei-schrittigen Zufallsprozess generiert wurden und nicht etwa von Menschen geschrieben sind. Der generative Prozess für ein Dokument von N Wörtern ist wie folgt. Zunächst muss die Anzahl der Topics k vorgegeben werden. Im ersten Schritt wird dann die Mischung der Topics entsprechend einer Dirichlet Verteilung  von k Topics generiert. Aus dieser Verteilung von Topics wird im zweiten Schritt ein Topic zufällig ausgewählt, das wiederum ein Wort aus der dazugehörigen Verteilung über dem Vokabular generiert. Dieser zweite Schritt wird so lange wiederholt, bis die N Wörter des Dokuments generiert sind. Es ist zu beachten, dass LDA ein bag-of-words Modell ist und somit die Reihenfolge der Wörter im Text sowie die Reihenfolge der Dokumente in der Sammlung vernachlässigt werden.

Startet man mit einer Sammlung von Dokumenten und betrachtet den generativen Prozess in umgekehrter Richtung, so ist LDA Topic Modellierung eine Methode abzuleiten, welche Topics die Dokumentensammlung generiert haben könnten. Weitere Details zu LDA können im ursprünglichen Paper von Blei et al. oder in diesem Review über probabilistische Topic-Modelle gefunden werden. Probabilistische Topic-Modelle bilden eine Klasse von Algorithmen, welche entwickelt wurden um die Verteilung von Topic aus einem Textcorpus zu schätzen, da es keine exakten Lösungen für diese Verteilungen gibt.

Daten-Vorverarbeitung

Wir folgen einem typischen Arbeitsfluss bei der Daten-Vorverarbeitung für Natural Language Processing (NLP). Textdaten werden in numerische Feature transformiert, welches das benötigte Eingabeformat für den LDA Machine-Learning-Algorithmus ist. Ein ähnliches Vorgehen ist in einem kürzlich erschienen Blog-Artikel über Spam-Erkennung beschrieben.

Eine MySQL-Tabelle der Blog Posts wird mittels JDBC in einen Spark DataFrame geladen. Ein zusätzliches Spart Submit Argument enthält die MySQL Connector  jar Datei.

1# read from mysql table, only use published posts sorted by date
2df_posts = ((spark.read.format("jdbc")
3 .option("url", "jdbc:mysql://localhost/ccblog")
4 .option("driver", "com.mysql.jdbc.Driver")
5 .option("dbtable", "wp_2_posts")
6 .option("user", "*****")
7 .option("password", "**********")
8 .load()
9 ).filter("post_type == 'post'").filter("post_status == 'publish'")
10 .sort("post_date"))

Vom Inhalt der Posts extrahieren wir die Texte, welche mit einer Vielzahl von HTML Tags versehen sind. Eine schöne Python Bibliothek für diesen Zweck ist BeautifulSoup . Ein Beispiel eines unbearbeiteten Textes ist im Notebook für den ersten Eintrag zu sehen. Die extrahierten Textdaten werden dann normalisiert, indem Zahlen, Interpunktion und anderer Sonderzeichen entfernt werden und nur Kleinbuchstaben verwendet werden. Ein sogenannter Tokenizer teilt die Sätze in Wörter (Token) auf. Diese Operationen an Spark DataFrame Columns erfolgen mittels Sparks User-Defined Functions (UDF).

1extractText = udf(
2 lambda d: BeautifulSoup(d, "lxml").get_text(strip=False), StringType())
3removePunct = udf(
4 lambda s: re.sub(r'[^a-zA-Z0-9]|[0-9]', r' ', s).strip().lower(), StringType())
5 
6# normalize the post content (remove html tags, punctuation and lower case..)
7df_posts_norm = df_posts.withColumn("text", removePunct(extractText(df_posts.post_content)))
8 
9# breaking text into words 
10tokenizer = RegexTokenizer(inputCol="text", outputCol="words", 
11                           gaps=True, pattern=r'\s+', minTokenLength=2)
12df_tokens = tokenizer.transform(df_posts_norm)

Der RegexTokenizer ist ein Beispiel für ein Spark Transformer. Inspiriert von dem Konzept von scikit-learn werden Transformers und Estimators zu einer Pipeline verbunden, i.e., ein Machine-Learning-Arbeitsfluss, der die verschieden Phasen von Vorverarbeitung, Feature-Generierung und Modell Training und Evaluation beinhaltet.

Sprache identifizieren

Wir möchten nur englische Blog Posts analysieren und müssen die Sprache der Posts identifizieren, da keine entsprechende Kennzeichnung in unserem Datensatz vorhanden ist. Eine einfache Klassifikation zwischen Englisch und Deutsch als primäre Sprache eines Textes wird durch den Vergleich der Anteile von den jeweiligen Stoppwörtern erreicht. Stoppwörter sind die am meisten verwendeten Wörter einer Sprache wie „a“, „of“, „the“, „and“ im Englischen. Listen von Stoppwörtern verschiedener Sprachen sind beim NLTK erhältlich. Der Anteil englischer Stoppwörter in einem Artikel wird berechnet, indem man die Stoppwörter die mindestens einmal vorkommen zählt, und durch die Gesamtzahl der Stoppwörter in der Liste teilt. Auf analoger Weise berechnen wir den Anteil von deutschen Stoppwörtern und entscheiden anhand des größeren Anteils welche Sprache hauptsächlich benutzt wird.

1from nltk.corpus import stopwords
2englishSW = set(stopwords.words('english'))
3germanSW = set(stopwords.words('german'))
4 
5nEngSW = len(englishSW)
6nGerSW = len(germanSW)
7 
8RatioEng = udf(lambda l: len(set(l).intersection(englishSW)) / nEngSW)
9RatioGer = udf(lambda l: len(set(l).intersection(germanSW)) / nGerSW)
10 
11df_tokens_en = (df_tokens.withColumn("ratio_en", RatioEng(df_tokens['words']))
12                         .withColumn("ratio_ge", RatioGer(df_tokens['words']))
13                         .withColumn("Eng", col('ratio_en') > col('ratio_ge'))
14                         .filter('Eng'))

Filtern von Stoppwörtern und Stemming

Die letzen Vorbereitungsschritte bestehen im Herausfiltern von englischen Stoppwörtern, da diese wahrscheinlich nicht beim Identifizieren von sinnvollen Topics helfen, sowie dem Stemming der Wörter, bei dem zum Beispiel „test“, „tests“, „tested“ und „testing“ alle auf den selben Wortstamm „test“ reduziert werden. Die Liste der Stoppwörter erweitern wir um moreStopWords, welche manuell wie folgt gesammelt werden. Nachdem ein LDA-Modell trainiert ist, inspizieren wir die Topics und identifizieren weitere Stoppwörter. Diese werden für das nächste Modell-Training herausgefiltert. Diese Prozedur wird solange wiederholt bis keine Stoppwörter mehr in der Liste der Top Wörter erscheinen.

1swRemover = StopWordsRemover(inputCol=tokenizer.getOutputCol(), outputCol="filtered")
2swRemover.setStopWords(swRemover.getStopWords() + moreStopWords)
3 
4df_finalTokens = swRemover.transform(df_tokens_en)
5 
6# Stemming
7from nltk.stem.snowball import SnowballStemmer
8stemmer = SnowballStemmer("english", ignore_stopwords=False)
9udfStemmer = udf(lambda l: [stemmer.stem(s) for s in l], ArrayType(StringType()))
10 
11df_finalTokens = df_finalTokens.withColumn("filteredStemmed",
12                                           udfStemmer(df_finalTokens["filtered"]))

Feature-Generierung

Die Feature-Vektoren werden mit einem bag-of-words-Ansatz mittels Sparks CountVectorizer generiert. Jedes Dokument wird durch einen Countvektor repräsentiert, dessen Länge der Zahl der Wörter im Vokabular entspricht. Die Größe des Vokabulars setzen wir fest auf 2500. Der CountVectorizer ist ein Estimator, der ein Modell generiert von dem tokenisierte Dokumente in Countvektoren transformiert werden können. Damit Wörter in Betracht gezogen werden müssen diese in mindestens zwei Dokumenten jeweils mindestens viermal erscheinen.

1cv = CountVectorizer(inputCol="filteredStemmed", outputCol="features", vocabSize=2500, minDF=2, minTF=4)
2 
3cvModel = cv.fit(df_finalTokens)
4 
5countVectors = (cvModel
6                .transform(df_finalTokens)
7                .select("ID", "features").cache())
8 
9cvModel.save("path/to/model/file")

Modell Training und Evaluation

Die Spark-Implementierung von LDA erlaubt Online Variational Inference  als Methode um das Modell zu trainieren. Daten werden inkrementell in kleinen Mengen verarbeitet, wodurch einfache Skalierung auf sehr große Datenmengen oder sogar auf Ströme von Daten ermöglicht wird.

1df_training, df_testing = countVectors.randomSplit([0.9, 0.1], 1)
2 
3numTopics = 20 # number of topics
4 
5lda = LDA(k = numTopics, seed = 1, optimizer="online", optimizeDocConcentration=True,
6 maxIter = 50,           # number of iterations
7 learningDecay = 0.51,   # kappa, learning rate
8 learningOffset = 64.0,  # tau_0, larger values downweigh early iterations
9 subsamplingRate = 0.05, # mini batch fraction 
10 )
11 
12ldaModel = lda.fit(df_training)
13 
14lperplexity = ldaModel.logPerplexity(df_testing)
15 
16ldaModel.save(path)

Generell wird ein Datensatz in Trainings- und Testdaten geteilt, damit das Modell mit Hilfe eines Maßes wie Perplexity evaluiert werden kann. Dies ist ein Maß dafür wie gut die Countvektoren der Testdokumente durch die Wortverteilungen der Topics repräsentiert werden. In unserem Fall finden wir es jedoch nützlicher das Modell manuell zu evaluieren, indem wir die Topics und die entsprechenden Verteilungen von Wörtern inspizieren. Ein gutes Ergebnis finden wir bei einem 20-Topic LDA-Modell, trainiert am gesamten Corpus von englischen codecentric Blog-Artikeln. Der Vorteil von quantitativen Maßen für die Modell-Evaluation wäre die Möglichkeit eines sogenannten Hyper-Parameter Tuning. Die Suche nach optimalen Modell-Parametern, wie die Anzahl der Topics, wird durch Sparks Pipeline-Konzept erheblich vereinfacht. Die ML Modelle werden für die weitere Benutzung gespeichert.

Ergebnisse

Im Folgenden zeigen wir die Ergebnisse von einem 20-Topic Modell, trainiert am gesamten Datensatz der englischen codecentric Blog-Artikel, welche bis einschliesslich November 2016 publiziert wurden. Die Wordclouds in Fig.1 und Fig.2 bieten eine Visualisierung der Verteilungen der Wörter für die zwei Top Topics. Die Größe der Wörter entspricht deren relativen Gewichten. Wörter mit höheren Gewicht werden öfter durch das Topic generiert. Durch Inspektion von einigen Dokumenten die ein Topic diskutieren und zusammen mit den Top Wörtern, ist es oft möglich manuell eine zusammenfassende Bezeichnung für die Topics zu finden. Die Topics der Wordclouds in Fig.1 und Fig.2 bezeichnen wir als „Agility“ und „Testing“. Es ist zu beachten, dass einige Wörter auf ungültige Wortstämme wie etwa „stori“ oder „softwar“ reduziert werden.

Figure 1. Wordcloud des Topics „Agility„.

Figure 2. Wordcloud des Topics „Testing„.

Bezeichnung der Topics and Identifizierung der Top-Dokumente

Die zwölf sinnvollsten Topics unseres 20-Topic Modells sind in Tab.1 aufgelistet. Diese Topics wurden per Hand ausgewählt, wobei sinnvoll natürlich ein sehr subjektives Maß ist. Unter anderem schließen wir Topics aus bei denen verschiedenen Themen vermischt erscheinen. Für jedes Topic schlagen wir eine Bezeichnung vor, welche das behandelte Thema zusammenfasst. Außerdem werden die Top Wörter in der Reihenfolge ihrer Wahrscheinlichkeiten generiert zu werden aufgelistet. Um das Top Dokument für ein gegebenes Topic zu finden, ordnen wir die Dokumente nach ihrer Wahrscheinlichkeit mit der das Topic diskutiert wird. Das Top Dokument ist dann definiert als dasjenige, welches die höchste Wahrscheinlichkeit hat und damit mit dem größten Beitrag von dem Topic charakterisiert ist, im Vergleich zu allen anderen Dokumenten.

Als Nächstes bestimmen wir die Anzahl von Dokumenten, die das selbe Haupt-Topic haben. Wir erinnern uns zunächst daran, dass Dokumente normalerweise verschiedene Topics in unterschiedlichen Anteilen diskutieren. Das Haupt-Topic eines Dokuments ist definiert als das Topic mit der größten Wahrscheinlichkeit.

1getMainTopicIdx = udf(lambda l: int(numpy.argmax([float(x) for x in l])), IntegerType())
2 
3countTopDocs = (ldaModel
4                .transform(countVectors)
5                .select(getMainTopicIdx("topicDistribution").alias("idxMainTopic"))
6                .groupBy("idxMainTopic").count().sort("idxMainTopic"))

Für jedes Dokument in unserem Datensatz bestimmen wir den Index des Topics, für welches die Wahrscheinlichkeit am Größten ist, i.e., das Haupt-Topic. Gruppieren nach Topic Index, zählen und sortieren resultiert in der Anzahl der zugeordneten Dokumente je Topic, wie in Fig.3 zu sehen. Die am meisten diskutierte Topics in der gesamten Sammlung von Blog Artikeln sind Topic 0 – „Testing“, Topic 6 – „Spring“ und Topic 10 – „Agility“.

Figure 3. Für jedes Topic zählen wir die Anzahl der zugeordneten Dokumente, die mit der größten Wahrscheinlichkeit dieses Topic behandeln. Nur die 12 sinnvollsten Topics des 20-Topic Modells werden gezeigt.

Entwicklung des Blog-Inhalts über die Zeit

Wie viele Blog-Artikel wurden während eines Jahres zu einem bestimmten Topic oder Thema publiziert? Mit dieser Frage beschäftigt sich Fig.4., wo für die Top Topics: „Testing“, „Spring“ und „Agility“, die Anzahl der zugeordneten Dokumente, die das Topic mit der größten Wahrscheinlichkeit behandeln, als Funktion der Zeit aufgetragen ist. Auf den ersten Blick scheint „Agility“ nach einem Hype im Jahr 2009 weniger wichtig zu werden, wie an der roten Linie in Fig.4 zu sehen ist. Eine andere Erklärung wäre jedoch, dass in späteren Jahren agile Methoden nicht mehr ausschließlich als Haupt-Topic auftreten, sondern eher zusammen mit anderen Topics in kleineren Anteilen erscheinen. Eine wachsende Zahl von Artikeln sind den beiden Topics „Spring“ und „Testing“ gewidmet, wobei einige Oszillationen für das letztere auftreten. Es wäre auch interessant, sich die Anzahl der Dokumente anzuschauen, die ein bestimmtest Topic mit einer Wahrscheinlichkeit über einem Schwellwert diskutieren, als nur das Topic mit der höchsten Wahrscheinlichkeit zu zählen, so wie es in Fig.4 gemacht wird. Jedoch wollen wir hier nicht ins Detail gehen, sondern nur einen Eindruck davon vermitteln, welche Analysen möglich sind.

Figure 4. Zeitentwicklung der Anzahl der Dokumente mit demselben Haupt-Topic. Ergebnisse sind nur für die drei Top Topic des LDA Modells gezeigt, welches am gesamten Datensatz trainiert wurde.

Entwicklung der Topics über die Zeit

Eine weitere interessante Fragestellung betrifft die zeitliche Veränderung von Topics: „Wann treten neue Topics auf und wann verschwinden Topics?“. Für die Ergebnisse in Fig.4 wurde nur ein einzelnes LDA Modell am gesamten Datensatz trainiert. Die resultierende Topic Verteilung ist fest und nicht zeitabhängig. Um die Entwicklung der Topics mit der Zeit systematisch zu studieren, haben Machine-Learning-Forscher Dynamische Topic-Modelle entwickelt.

Hier verwenden wir einen einfacheren Ansatz, um die Verteilung der Topic im zeitlichen Verlauf zu untersuchen. Mehrere verschiedene LDA-Modelle werden trainiert, mit Blog-Artikeln von einem bestimmten Jahr inklusive aller Artikel aller vorherigen Jahre. Damit erhalten wir Topic-Verteilungen für die Sammlungen von Dokumenten publiziert in den Jahren 2008-2010, 2008-2011, …, 2008-2016. Wir versuchen daraufhin die selben Topics in den verschiedenen LDA Modellen zu identifizieren, die natürlich unterschiedliche Top Wörter haben können. Prinzipiell ist es mit diesem Ansatz möglich, die Topics des nächsten Jahres anhand der Daten aus den vorangehenden Jahren vorherzusagen. Ohne ins Detail zu gehen, präsentieren wir als Beispiel in Tab.2 die Top 10 Wörter für das Topic „Agility“ von den verschiedenen LDA-Modellen, trainiert mit allen Daten bis zu und einschließlich aufeinanderfolgender Jahre.

Wie in Fig.5 zu sehen, ändert sich die Wahrscheinlichkeit der Top Wörter in Texten über „Agility“ der Zeit. Beispielsweise ist ein leichter Rückgang bei der Benutzung der Wörter „agile“ und „scrum“ zischen 2010 bis 2016 zu verzeichnen.

Figure 5. Für das Topic „Agility“ werden die Gewichte für einige Wörter als Funktion der Zeit gezeigt.

Die Topic-Verteilung des vorliegenden Artikels

Um unser trainiertes LDA Topic Modell einem weitern Test zu unterziehen, machen wir nun eine Vorhersage für die Topics der englischen Version dieses Artikels. Wir benutzen das LDA Model, trainiert am gesamten Datensatz, und machen eine Vorhersage bevor dieser Paragraph geschrieben wurde. Als Ergebnis erhalten wir die Topic-Verteilung, die in Fig.6 als Pie Chart dargestellt ist. Die zwei dominantesten Topics mit über 20 Prozent sind „Functional Programming“ und „Data/Search“, was sehr passend ist. Alle anderen Topics, mit weniger als fünf Prozent Wahrscheinlichkeit, werden unter „Other“ gesammelt dargestellt.

Figure 6. Die Topic Verteilung für die englische Version dieses Artikels, vorhergesagt durch das LDA Modell, trainiert am gesamten Datensatz englischer Blog Artikel.

Zusammenfassung

In diesem Artikel analysieren wir den Inhalt des codecentric Blogs mit Hilfe von Sparks Implementierung der LDA Topic Modellierung. Zunächst werden Schritte der Daten-Vorverarbeitung beschreiben, die meist notwendig für NLP sind. Ein 20-Topic Modell, trainiert an allen Blog Posts erlaubt die Identifizierung einer Reihe von sinnvollen Topics. Einige sondierende Untersuchungen der Zeitentwicklung des Blog-Inhalts werden durchgeführt. Dazu werden verschiedene LDA-Modelle mit Artikeln bis zu einem bestimmten Jahr trainiert. Wir erhalten dadurch Hinweise darauf, wie sich die Topics and deren Wörter mit der Zeit ändern. Im letzen Teil sagen wir erfolgreich die Topics der englischen Version des vorliegenden Artikels voraus.

In einem Folgeartikel wäre es sicher interessant auch die deutschen Blog-Artikel zu untersuchen, um zu sehen ob die Topics von der Sprache abhängen. Weiterhin wäre es lohnenswert LDA mit anderen Methoden, wie Nicht-negative Matrix-Faktorisierung, und ausgefeilteren (dynamischen) Topic-Modellen mit anderen Features (e.g. tf-idf) zu vergleichen. Zusätzliche Einsichten, darüber wie Topics gleichzeitig auftreten, könnten durch Modellierung der Verbindungen zwischen Topics in einem Graph erlangt werden, wodurch die Zusammenhänge zwischen verschiedenen Topics studiert werden können.
Als abschließende Bemerkung ist zu erwähnen, dass Topic-Modellierung sich nicht nur auf Textdokument beschränkt, sondern auch auf andere unstrukturierte Daten wie Bilder oder Videoclips, wie z.B. beim Video Behavior Mining angewendet werden können, indem visuelle Features als Wörter interpretiert werden.

Referenzen

David M. Blei, Andrew Y. Ng, Michael I. Jordan. „Latent Dirichlet Allocation“  Journal of Machine Learning Research 3. 993-1022. 2003.

Blei, David. „Probabilisitic Topic Models.“ Communications of the ACM. 55.4: 77-84. 2012.

Hoffman, Matthew, Francis R. Bach, and David M. Blei. „Online learning for latent dirichlet allocation.“ Advances in neural information processing systems. 2010.

David M. Blei and John D. Lafferty. „Dynamic topic models.“ In Proceedings of the 23rd international conference on Machine learning. ACM, 113-120. 2006.