Latent Semantic Analysis mit Python

Themenerkennung ist für viele Zwecke hilfreich: etwa zum Clustern von Dokumenten, zum Strukturieren frei verfügbarer Inhalte für die Informationssuche und für Empfehlungen. Zahlreiche Content-Anbieter und Nachrichtenagenturen setzen Topic-Modelle ein, um Leserinnen und Lesern passende Artikel vorzuschlagen. Ebenso nutzen Personalvermittler sie, um Stellenbeschreibungen zu extrahieren und mit dem Kompetenzprofil von Kandidatinnen und Kandidaten abzugleichen. Der Job von Data Scientists dreht sich im Kern darum, aus großen Datenmengen „Wissen“ zu gewinnen. Die vorliegenden Daten sind dabei oft unstrukturiert. Du brauchst leistungsfähige Werkzeuge und Methoden, um große Mengen unstrukturierter Daten zu analysieren und zu verstehen.

Topic Modeling ist eine Text-Mining-Technik, die ko-vorkommende Schlüsselwörter identifiziert, um große Textsammlungen zusammenzufassen. Sie hilft, verborgene Themen in Dokumenten aufzudecken, Dokumente mit diesen Themen zu annotieren und umfangreiche unstrukturierte Daten zu ordnen.

Topic Modeling

Topic Modeling entdeckt automatisch verborgene Themen in gegebenen Dokumenten. Es handelt sich um einen unüberwachten Textanalyse-Algorithmus, der Wortgruppen in Dokumenten findet. Diese Wortgruppen repräsentieren jeweils ein Thema. Ein einzelnes Dokument kann mehreren Themen zugeordnet sein. Ein Beispiel: Wörtergruppen wie „patient“, „doctor“, „disease“, „cancer“ und „health“ stehen für das Thema „Healthcare“. Topic Modeling ist etwas völlig anderes als regelbasierte Textsuche mit Regulären Ausdrücken.

Vergleich: Textklassifikation vs. Topic Modeling

Textklassifikation ist ein überwachtes Machine-Learning-Problem, bei dem ein Textdokument oder Artikel vorab definierten Klassen zugeordnet wird. Topic Modeling hingegen entdeckt Gruppen ko-vorkommender Wörter in Textdokumenten. Diese Gruppen verwandter Wörter bilden „Themen“. Da es sich um unüberwachtes Lernen handelt, ist die Menge möglicher Themen zunächst unbekannt. Topic Modeling kann genutzt werden, um Textklassifikation zu unterstützen. Während Topic Modeling die in einem Dokument vorhandenen Themen identifiziert, ordnet die Textklassifikation den Text einer einzelnen Klasse zu.

Latent Semantic Analysis

LSA (Latent Semantic Analysis), auch bekannt als LSI (Latent Semantic Indexing), verwendet das Bag-of-Words-(BoW)-Modell, aus dem eine Term-Dokument-Matrix (Auftreten von Begriffen in einem Dokument) entsteht. Zeilen stehen für Terme, Spalten für Dokumente. LSA lernt latente Themen, indem die Dokument-Term-Matrix mittels Singulärwertzerlegung (SVD) faktorisiert wird. LSA wird typischerweise zur Dimensionsreduktion oder Rauschunterdrückung eingesetzt.

Singulärwertzerlegung (SVD)

SVD ist ein Matrixfaktorisierungsverfahren, das eine Matrix als Produkt mehrerer Matrizen darstellt. Es bietet vielfältige Anwendungen, zum Beispiel in der Signalverarbeitung, Psychologie, Soziologie, Klima- und Atmosphärenwissenschaft, Statistik und Astronomie.

• M ist eine m×m-Matrix.
• U ist eine m×n linke Singulärmatrix.
• Σ ist eine n×n Diagonalmatrix mit nichtnegativen reellen Zahlen.
• V ist eine m×n rechte Singulärmatrix.
• V* ist eine n×m-Matrix, also die Transponierte von V.

Einheitsmatrix: Eine quadratische Matrix, in der alle Elemente der Hauptdiagonalen Eins sind und alle anderen Elemente Null.

Diagonalmatrix: Eine Matrix, in der alle Einträge außerhalb der Hauptdiagonalen Null sind.

Singuläre Matrix: Eine Matrix ist singulär, wenn ihre Determinante 0 ist, also keine Inverse existiert.

Optimale Anzahl an Themen bestimmen

Wie lässt sich k (die Anzahl der Themen) im Topic Modeling am besten bestimmen? Die optimale Themenanzahl in einem Korpus zu finden, ist anspruchsvoll. Zur Bestimmung können unter anderem folgende Ansätze genutzt werden:

• Man kann jedes Thema als Cluster betrachten und die Clusterqualität mit dem Silhouettenkoeffizienten bewerten.
• Das Topic-Coherence-Maß ist ein praxistauglicher Indikator zur Ermittlung der Themenanzahl.

Topic Coherence ist ein weitverbreitetes Maß zur Bewertung von Topic-Modellen. Es nutzt latente Variablenmodelle. Jedes erzeugte Thema besteht aus einer Liste von Wörtern. Beim Topic-Coherence-Maß wird der Mittel- oder Medianwert der paarweisen Wortähnlichkeiten innerhalb eines Themas berechnet. Ein hohes Topic-Coherence-Ergebnis deutet auf ein gutes Modell hin.

LSA mit Gensim implementieren

Benötigte Bibliotheken importieren

#import modules
import os.path
from gensim import corpora
from gensim.models import LsiModel
from nltk.tokenize import RegexpTokenizer
from nltk.corpus import stopwords
from nltk.stem.porter import PorterStemmer
from gensim.models.coherencemodel import CoherenceModel
import matplotlib.pyplot as plt

Daten laden

Erstelle zunächst eine Funktion zum Laden von articles.csv. Du kannst die Daten hier herunterladen.

def load_data(path,file_name):
    """
    Input  : path and file_name
    Purpose: loading text file
    Output : list of paragraphs/documents and
             title(initial 100 words considred as title of document)
    """
    documents_list = []
    titles=[]
    with open( os.path.join(path, file_name) ,"r") as fin:
        for line in fin.readlines():
            text = line.strip()
            documents_list.append(text)
    print("Total Number of Documents:",len(documents_list))
    titles.append( text[0:min(len(text),100)] )
    return documents_list,titles

Daten vorverarbeiten

Nach dem Laden musst du den Text vorverarbeiten. Die folgenden Schritte sind sinnvoll:

• Text der Artikel tokenisieren
• Stoppwörter entfernen
• Stemming auf den Text anwenden

def preprocess_data(doc_set):
    """
    Input  : docuemnt list
    Purpose: preprocess text (tokenize, removing stopwords, and stemming)
    Output : preprocessed text
    """
    # initialize regex tokenizer
    tokenizer = RegexpTokenizer(r'\w+')
    # create English stop words list
    en_stop = set(stopwords.words('english'))
    # Create p_stemmer of class PorterStemmer
    p_stemmer = PorterStemmer()
    # list for tokenized documents in loop
    texts = []
    # loop through document list
    for i in doc_set:
        # clean and tokenize document string
        raw = i.lower()
        tokens = tokenizer.tokenize(raw)
        # remove stop words from tokens
        stopped_tokens = [i for i in tokens if not i in en_stop]
        # stem tokens
        stemmed_tokens = [p_stemmer.stem(i) for i in stopped_tokens]
        # add tokens to list
        texts.append(stemmed_tokens)
    return texts

Korpus vorbereiten

Im nächsten Schritt bereitest du den Korpus vor. Dazu erstellst du eine Dokument-Term-Matrix und ein Wörterbuch der Terme.

def prepare_corpus(doc_clean):
    """
    Input  : clean document
    Purpose: create term dictionary of our courpus and Converting list of documents (corpus) into Document Term Matrix
    Output : term dictionary and Document Term Matrix
    """
    # Creating the term dictionary of our courpus, where every unique term is assigned an index. dictionary = corpora.Dictionary(doc_clean)
    dictionary = corpora.Dictionary(doc_clean)
    # Converting list of documents (corpus) into Document Term Matrix using dictionary prepared above.
    doc_term_matrix = [dictionary.doc2bow(doc) for doc in doc_clean]
    # generate LDA model
    return dictionary,doc_term_matrix

LSA-Modell mit Gensim erstellen

Nach der Korpus-Erstellung kannst du ein LSA-Modell trainieren.

def create_gensim_lsa_model(doc_clean,number_of_topics,words):
    """
    Input  : clean document, number of topics and number of words associated with each topic
    Purpose: create LSA model using gensim
    Output : return LSA model
    """
    dictionary,doc_term_matrix=prepare_corpus(doc_clean)
    # generate LSA model
    lsamodel = LsiModel(doc_term_matrix, num_topics=number_of_topics, id2word = dictionary)  # train model
    print(lsamodel.print_topics(num_topics=number_of_topics, num_words=words))
    return lsamodel

Themenanzahl bestimmen

Um die Ergebnisse zu optimieren, solltest du eine geeignete Themenanzahl ermitteln. Dazu berechnest du Coherence-Scores für verschiedene Werte.

def compute_coherence_values(dictionary, doc_term_matrix, doc_clean, stop, start=2, step=3):
    """
    Input   : dictionary : Gensim dictionary
              corpus : Gensim corpus
              texts : List of input texts
              stop : Max num of topics
    purpose : Compute c_v coherence for various number of topics
    Output  : model_list : List of LSA topic models
              coherence_values : Coherence values corresponding to the LDA model with respective number of topics
    """
    coherence_values = []
    model_list = []
    for num_topics in range(start, stop, step):
        # generate LSA model
        model = LsiModel(doc_term_matrix, num_topics=number_of_topics, id2word = dictionary)  # train model
        model_list.append(model)
        coherencemodel = CoherenceModel(model=model, texts=doc_clean, dictionary=dictionary, coherence='c_v')
        coherence_values.append(coherencemodel.get_coherence())
    return model_list, coherence_values

Jetzt zeichnen wir die Coherence-Scores auf.

def plot_graph(doc_clean,start, stop, step):
    dictionary,doc_term_matrix=prepare_corpus(doc_clean)
    model_list, coherence_values = compute_coherence_values(dictionary, doc_term_matrix,doc_clean,
                                                            stop, start, step)
    # Show graph
    x = range(start, stop, step)
    plt.plot(x, coherence_values)
    plt.xlabel("Number of Topics")
    plt.ylabel("Coherence score")
    plt.legend(("coherence_values"), loc='best')
    plt.show()

start,stop,step=2,12,1
plot_graph(clean_text,start,stop,step)

Die Grafik ist leicht zu interpretieren. Auf der X-Achse siehst du die Anzahl der Themen, auf der Y-Achse den Coherence-Score. Von den getesteten Werten erreicht 7 den höchsten Score, also ist die optimale Themenanzahl hier 7.

Alle Funktionen ausführen

# LSA Model
number_of_topics=7
words=10
document_list,titles=load_data("","articles.txt")
clean_text=preprocess_data(document_list)
model=create_gensim_lsa_model(clean_text,number_of_topics,words)

Total Number of Documents: 4551
[(0, '0.361*"trump" + 0.272*"say" + 0.233*"said" + 0.166*"would" + 0.160*"clinton" + 0.140*"peopl" + 0.136*"one" + 0.126*"campaign" + 0.123*"year" + 0.110*"time"'), (1, '-0.389*"citi" + -0.370*"v" + -0.356*"h" + -0.355*"2016" + -0.354*"2017" + -0.164*"unit" + -0.159*"west" + -0.157*"manchest" + -0.116*"apr" + -0.112*"dec"'), (2, '0.612*"trump" + 0.264*"clinton" + -0.261*"eu" + -0.148*"say" + -0.137*"would" + 0.135*"donald" + -0.134*"leav" + -0.134*"uk" + 0.119*"republican" + -0.110*"cameron"'), (3, '-0.400*"min" + 0.261*"eu" + -0.183*"goal" + -0.152*"ball" + -0.132*"play" + 0.128*"said" + 0.128*"say" + -0.126*"leagu" + 0.122*"leav" + -0.122*"game"'), (4, '0.404*"bank" + -0.305*"eu" + -0.290*"min" + 0.189*"year" + -0.164*"leav" + -0.153*"cameron" + 0.143*"market" + 0.140*"rate" + -0.139*"vote" + -0.133*"say"'), (5, '0.310*"bank" + -0.307*"say" + -0.221*"peopl" + 0.203*"trump" + 0.166*"1" + 0.164*"min" + 0.163*"0" + 0.152*"eu" + 0.152*"market" + -0.138*"like"'), (6, '0.570*"say" + 0.237*"min" + -0.170*"vote" + 0.158*"govern" + -0.154*"poll" + 0.122*"tax" + 0.115*"statement" + 0.115*"bank" + 0.112*"budget" + -0.108*"one"')]

• Thema 1: "trump", "say", "said", "would", "clinton", "peopl", "one", "campaign", "year", "time" (US-Präsidentschaftswahl)
• Thema 2: "citi", "v", "h", "2016", "2017", "unit", "west", "manchest", "apr", "dec" (English Premier League)
• Thema 3: "trump", "clinton", "eu", "say", "would", "donald", "leav", "uk", "republican", "cameron" (US-Präsidentschaftswahl, Brexit)
• Thema 4: "min", "eu", "goal", "ball", "play", "said", "say", "leagu", "leav", "game" (English Premier League)
• Thema 5: "bank", "eu", "min", "year", "leav", "cameron", "market", "rate", "vote", "say" (Brexit und Marktentwicklung)
• Thema 6: "bank", "say", "peopl", "trump", "1", "min", "eu", "market", "like" (Politische Lage und Märkte)
• Thema 7: "say", "min", "vote", "govern", "poll", "tax", "statement", "bank", "budget", "one" (US-Wahl und Finanzplanung)

Hier wurden 7 Themen mit Latent Semantic Analysis entdeckt. Einige überschneiden sich thematisch. Um mehrere Bedeutungen mit höherer Genauigkeit abzubilden, solltest du LDA (Latent Dirichlet Allocation) ausprobieren. Das überlasse ich dir als Übung: Probiere es mit Gensim aus und teile deine Erfahrungen.

Vor- und Nachteile von LSA

Der LSA-Algorithmus ist einfach zu verstehen und zu implementieren. Gegenüber dem Vektorraummodell liefert er oft bessere Ergebnisse. Er ist zudem schneller als viele andere Verfahren, da lediglich eine Faktorisierung der Dokument-Term-Matrix erforderlich ist.

Die Dimension der latenten Themen hängt vom Rang der Matrix ab, dieser lässt sich nicht beliebig erweitern. Die durch LSA entstehenden Matrizen sind stark dicht besetzt, wodurch einzelne Dimensionen schwer zu indexieren sind. LSA kann mehrdeutige Wortbedeutungen nicht gut erfassen. Außerdem ist es im Vergleich zu LDA (Latent Dirichlet Allocation) weniger präzise.

Anwendungsfälle für Topic Modeling

Typische Anwendungen sind Dokumenten-Clusterings in der Textanalyse, Empfehlungssysteme und Information Retrieval. Ausgewählte Use Cases im Detail:

• Lebenslauf-Zusammenfassung: Recruiter können Lebensläufe auf einen Blick einschätzen und den Aufwand beim Vorsortieren stark reduzieren.
• Suchmaschinenoptimierung: Online-Artikel, Blogs und Dokumente lassen sich anhand identifizierter Themen und Keywords gezielt taggen, was Suchergebnisse verbessert.
• Optimierung von Empfehlungssystemen: Recommender-Systeme filtern Informationen und beraten basierend auf Nutzerprofil und Historie. Topic Modeling hilft, noch nicht besuchte, aber relevante Inhalte zu entdecken.
• Besserer Kundensupport: Relevante Themen und zugehörige Keywords in Beschwerden und Feedback identifizieren, z. B. zu Produkt- und Servicespezifikationen oder Zuständigkeiten. So landet ein Anliegen schneller bei der richtigen Abteilung.
• Healthcare: Aus unstrukturierten medizinischen Berichten lassen sich nützliche Informationen extrahieren, etwa für die Behandlung von Patientinnen und Patienten oder für die medizinische Forschung.

Fazit

In diesem Tutorial hast du einen umfassenden Überblick über Topic Modeling erhalten. Du weißt nun, was Topic Modeling ist, was Latent Semantic Analysis leistet, wie du entsprechende Modelle aufbaust und wie LSA Themen generiert. Außerdem hast du Grundlagen wie die Singulärwertzerlegung und den Topic-Coherence-Score kennengelernt.

Hoffentlich kannst du Topic Modeling jetzt auf deine eigenen Datensätze anwenden. Danke fürs Lesen!

Wenn du mehr über Python lernen möchtest, sieh dir den DataCamp-Kurs Case Studies in Statistical Thinking an.