Python Bag of Words Model: Ein vollständiger Leitfaden

Bag of Words (BoW) ist eine Technik der natürlichen Sprachverarbeitung (NLP). Sie wird häufig verwendet, um Textdaten in ein maschinenlesbares Format umzuwandeln, insbesondere Zahlenwerte, ohne dabei Grammatik und Wortreihenfolge zu berücksichtigen. Das Verständnis von BoW ist für jeden wichtig, der mit Textdaten arbeitet. Python bietet mehrere Werkzeuge und Bibliotheken, um Bag of Words effektiv zu implementieren.

In diesem Tutorium werden wir in BoW eintauchen, seine Konzepte vorstellen, seine Einsatzmöglichkeiten erläutern und eine detaillierte Implementierung in Python durchgehen. Am Ende dieses Tutorials wirst du in der Lage sein, das Bag of Words-Modell auf reale Probleme anzuwenden. Wenn du neu im Bereich NLP bist, schau dir unseren Natural Language Processing in Python um mehr zu erfahren.

Was ist Bag of Words?

Bag of Words ist eine Technik zur Extraktion von Merkmalen aus Textdaten für Aufgaben des maschinellen Lernens, wie z.B. Textklassifizierung und Sentimentanalyse. Das ist wichtig, weil Algorithmen für maschinelles Lernen keine Textdaten verarbeiten können. Der Prozess der Umwandlung des Textes in Zahlen wird als Merkmalsextraktion oder Merkmalskodierung bezeichnet.

Ein Bag of Words basiert auf dem Vorkommen von Wörtern in einem Dokument. Der Prozess beginnt damit, die Vokabeln im Text zu finden und ihr Vorkommen zu messen. Man nennt es einen Sack, weil die Reihenfolge und Struktur der Wörter nicht berücksichtigt wird, sondern nur ihr Vorkommen. 

Das Bag of Words-Modell unterscheidet sich vom Continuous Bag of Words-Modell (CBOW), das dichte Worteinbettungen lernt, indem es umliegende Wörter zur Vorhersage eines Zielworts verwendet und semantische Beziehungen zwischen Wörtern erfasst. CBOW erfordert das Training auf einem großen Korpus und erzeugt niedrigdimensionale Vektoren, die für komplexe NLP-Anwendungen, bei denen der Wortkontext wichtig ist, wertvoll sind.

Warum Bag of Words verwenden?

Bag of Words ist nützlich für viele NLP-AufgabenEinige Gründe für seine Verwendung sind:

• Merkmalsextraktion: Es wandelt unstrukturierte Textdaten in strukturierte Daten um, die als Input für verschiedene maschinelle Lernalgorithmen verwendet werden können.
• Einfachheit und Effizienz: BoW ist rechnerisch einfach zu implementieren und funktioniert gut für kleine bis mittelgroße Textkorpora.
• Ähnlichkeit der Dokumente: Sie kann verwendet werden, um die Ähnlichkeit zwischen Textdokumenten mit Techniken wie der Kosinusähnlichkeit zu berechnen.
• Textklassifizierung: In Kombination mit Techniken wie Naive Bayes ist BoW effektiv für Textklassifizierungsaufgaben wie Spam-Klassifizierung und Stimmungsanalyse.

Es gibt jedoch auch Nachteile, wie z.B. die Nichtberücksichtigung der Semantik, der Wortstruktur oder der Wortreihenfolge.

Schritte zur Implementierung von Bag of Words in Python

Um ein Bag-of-Words-Modell zu erstellen, nehmen wir alle Wörter in einem Korpus und erstellen eine Spalte mit jedem Wort. Die Zeilen stellen die Sätze dar. Wenn ein bestimmtes Wort im Satz vorkommt, wird es durch eine 1 dargestellt, und wenn das Wort nicht vorkommt, wird es durch eine 0 dargestellt. Jedes Wort in der Spalte steht für ein einzelnes Merkmal.

Am Ende erhalten wir eine spärliche Matrix. Eine dünnbesetzte Matrix ist eine Matrix mit vielen Nullen. 

Vorverarbeitung der Daten

Um ein Bag of Words-Modell in Python zu erstellen, müssen wir ein paar Vorverarbeitungsschritte durchführen. Diese Schritte umfassen die Tokenisierung und das Entfernen von Stoppwörtern.

Bei der Tokenisierung wird ein Text in kleinere Einheiten, in der Regel Wörter, zerlegt. Du kannst die Tokenisierung mit NLTK.

Stoppwörter sind im Englischen gebräuchliche Wörter, wie "the", "that" und "a", die nicht zur Polarität eines Satzes beitragen.

import nltk
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize

# Download stopwords and tokenizer if you haven't already
nltk.download("punkt")
nltk.download("stopwords")

# Example sentence
sentence = "This is an example showing how to remove stop words from a sentence."

# Tokenize the sentence into words
words = word_tokenize(sentence)

# Get the list of stop words in English
stop_words = set(stopwords.words("english"))

# Remove stop words from the sentence
filtered_sentence = [word for word in words if word.lower() not in stop_words]

# Join the words back into a sentence
filtered_sentence = " ".join(filtered_sentence)
print(filtered_sentence)

Ausgabe:

example showing remove stop words sentence.

Ein Vokabular erstellen

Ein Vokabular ist eine Sammlung von einzigartigen Wörtern, die in einem Textkorpus gefunden werden. Um ein Vokabular zu erstellen, müssen alle einzigartigen Wörter aus dem Korpus gesammelt und ihre Vorkommen gezählt werden. Dieses Vokabular ist für verschiedene NLP-Aufgaben wie Sprachmodellierung, Worteinbettung und Textklassifizierung nützlich.

Der folgende Code erstellt eine einfache Häufigkeitsverteilung der Wörter im Korpus, die für grundlegende NLP-Aufgaben wie den Aufbau eines Wortschatzes oder das Verstehen von Textinhalten nützlich ist:

• Die Variable enthält ein paar Beispielsätze. In realen Anwendungen würde dies größere, vielfältigere Textdaten enthalten.
• vocab = defaultdict(int) vereinfacht das Zählen der Worthäufigkeit, indem es jedes neue Wort automatisch mit dem Wert 0 initialisiert und so ein direktes Inkrementieren ohne Überprüfung ermöglicht.
• Jeder Satz wird tokenisiert, indem er in Kleinbuchstaben umgewandelt wird und Wörter mit regulären Ausdrücken extrahiert werden. Das Muster \b\w+\b identifiziert nur Wörter mit alphanumerischen Zeichen und ignoriert Interpunktion und andere Symbole.
• Die Anzahl der Wörter wird in der vocab wörterbuch aktualisiert.
• Die Vokabeln sind nach Häufigkeit absteigend sortiert, so dass die häufigsten Wörter ganz oben stehen und zum Nachschlagen angezeigt werden.

import re  
# Import the regular expressions module to help with text processing
from collections import (
    defaultdict,
)  

# Import defaultdict to easily handle word frequency counting

# Sample corpus of text - a small dataset of sentences to analyze
corpus = [
    "Tokenization is the process of breaking text into words.",
    "Vocabulary is the collection of unique words.",
    "The process of tokenizing is essential in NLP.",
]

# Initialize a defaultdict with integer values to store word frequencies

# defaultdict(int) initializes each new key with a default integer value of 0
vocab = defaultdict(int)

# Loop through each sentence in the corpus to tokenize and normalize
for sentence in corpus:
    # Convert the sentence to lowercase to ensure consistency in counting (e.g., 'Tokenization' and 'tokenization' are treated as the same word)
    # Use regular expressions to find words composed of alphanumeric characters only
    words = re.findall(r"\b\w+\b", sentence.lower())
    # For each word found, increment its count in the vocab dictionary
    for word in words:
        vocab[word] += 1

# Convert the defaultdict vocab to a regular dictionary for easier handling and sorting

# Sort the dictionary by word frequency in descending order and convert it to a new dictionary
sorted_vocab = dict(sorted(vocab.items(), key=lambda x: x[1], reverse=True))

# Display the sorted vocabulary with each word and its frequency count
print("Vocabulary with Frequencies:", sorted_vocab)

Ausgabe:

Vocabulary with Frequencies: {'is': 3, 'the': 3, 'of': 3, 'process': 2, 'words': 2, 'tokenization': 1, 'breaking': 1, 'text': 1, 'into': 1, 'vocabulary': 1, 'collection': 1, 'unique': 1, 'tokenizing': 1, 'essential': 1, 'in': 1, 'nlp': 1}

Der manuelle Aufbau eines Vokabulars kann zeitaufwändig sein, besonders bei großen Korpora. Der CountVectorizer von Scikit-learn automatisiert diesen Prozess und ermöglicht eine flexiblere Textverarbeitung, wie wir später sehen werden. 

Bag of Words Implementierung mit Python (von Grund auf)

Beginnen wir mit einer einfachen Implementierung von Bag of Words von Grund auf in Python. Das wird dir helfen, die Bausteine und Mechanismen zu verstehen, wie es unter der Haube funktioniert.

Manuelle Umsetzung

Schritt 1: Vorverarbeitung der Textdaten

Wir beginnen mit der Definition einer einfachen Funktion zur Verarbeitung von Text, einschließlich Tokenisierung, Kleinschreibung und Entfernen von Satzzeichen.

from collections import defaultdict
import string

# Sample text data: sentences
corpus = [
    "Python is amazing and fun.",
    "Python is not just fun but also powerful.",
    "Learning Python is fun!",
]
# Function to preprocess text
def preprocess(text):
    # Convert to lowercase
    text = text.lower()
    # Remove punctuation
    text = text.translate(str.maketrans("", "", string.punctuation))
    # Tokenize: split the text into words
    tokens = text.split()
    return tokens

# Apply preprocessing to the sample corpus
processed_corpus = [preprocess(sentence) for sentence in corpus]
print(processed_corpus)

Ausgabe:

[['python', 'is', 'amazing', 'and', 'fun'], ['python', 'is', 'not', 'just', 'fun', 'but', 'also', 'powerful'], ['learning', 'python', 'is', 'fun']]

Schritt 2: Wortschatz aufbauen

Jetzt müssen wir alle Dokumente durchsuchen und eine vollständige Liste mit eindeutigen Wörtern erstellen, das ist unser Vokabular.

# Initialize an empty set for the vocabulary
vocabulary = set()

# Build the vocabulary
for sentence in processed_corpus:
    vocabulary.update(sentence)

# Convert to a sorted list
vocabulary = sorted(list(vocabulary))
print("Vocabulary:", vocabulary)

Schritt 3: Worthäufigkeiten berechnen und vektorisieren

Wir berechnen nun die Häufigkeit jedes Wortes im Vokabular für jedes Dokument im bearbeiteten Korpus.

def create_bow_vector(sentence, vocab):
    vector = [0] * len(vocab)  # Initialize a vector of zeros
    for word in sentence:
        if word in vocab:
            idx = vocab.index(word)  # Find the index of the word in the vocabulary
            vector[idx] += 1  # Increment the count at that index
    return vector

An diesem Punkt hast du eine Bag of Words-Darstellung für jedes Dokument in deinem Korpus erstellt.

# Create BoW vector for each sentence in the processed corpus
bow_vectors = [create_bow_vector(sentence, vocabulary) for sentence in processed_corpus]
print("Bag of Words Vectors:")
for vector in bow_vectors:
    print(vector)

Ausgabe:

Bag of Words Vectors:
[0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1]
[1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1]
[0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1]

Den CountVectorizer von Scikit-learn verwenden

Die manuelle Erstellung eines Bag of Words-Modells ist gut zum Lernen, aber für Produktionsanwendungen solltest du effiziente, optimierte Bibliotheken wie Scikit-learn.

Die Python-Funktion, die wir für die Tokenisierung verwenden, ist CountVectorizerdie von sklearn.feature_extraction.text importiert wird. Eine der Funktionen von CountVectorizer ist max_features, die die maximale Anzahl der Wörter angibt, die du im Bag of Words-Modell haben möchtest. In diesem Fall verwenden wir None, was bedeutet, dass alle Funktionen verwendet werden. 

Nachdem du eine Instanz von CountVectorizer erstellt hast, verwende die Methode .fit_transform(), um das Bag-of-Words-Modell zu erstellen. Als Nächstes wandelst du das Bag-of-Words-Modell mit .toarray() in Numpy-Arrays um, die du in ein Machine-Learning-Modell einspeisen kannst.

Nach der Anpassung hat der CountVectorizer ein Wörterbuch mit Merkmalsindizes erstellt. Der Indexwert eines Wortes im Vokabular ist mit seiner Häufigkeit im gesamten Trainingskorpus verknüpft.

from sklearn.feature_extraction.text import CountVectorizer
# Original corpus
corpus = [
    "Python is amazing and fun.",
    "Python is not just fun but also powerful.",
    "Learning Python is fun!",
]
# Create a CountVectorizer Object
vectorizer = CountVectorizer()
# Fit and transform the corpus
X = vectorizer.fit_transform(corpus)
# Print the generated vocabulary
print("Vocabulary:", vectorizer.get_feature_names_out())
# Print the Bag-of-Words matrix
print("BoW Representation:")
print(X.toarray())

Ausgabe:

markdownVocabulary: ['also' 'amazing' 'and' 'but' 'fun' 'is' 'just' 'learning' 'not'

 'powerful' 'python']

BoW Representation:

[[0 1 1 0 1 1 0 0 0 0 1]

 [1 0 0 1 1 1 1 0 1 1 1]

 [0 0 0 0 1 1 0 1 0 0 1]]

Beispiel: Beutel mit Wörtern anwenden

Wenden wir nun das BoW-Modell auf einen kleinen Textkorpus an, der aus drei Filmkritiken besteht, um den gesamten Prozess zu veranschaulichen. 

Wir werden den CountVectorizer von Scikit-learn verwenden, um das BoW-Modell auf diesen kleinen Textkorpus anzuwenden.

Hier sind die Schritte, die wir unternehmen werden:

• CountVectorizer tokenisiert den Text, entfernt Satzzeichen und schreibt die Wörter automatisch klein.
• .fit_transform(corpus) wandelt den Korpus in eine Dokument-Term-Matrix um, bei der jede Zeile für ein Dokument und jede Spalte für ein Wort aus dem Vokabular steht.
• X_dense ist die dichte Matrix, die die Häufigkeit jedes Worts in jedem Dokument darstellt.

from sklearn.feature_extraction.text import CountVectorizer
# Sample corpus of movie reviews
corpus = [
    "I loved the movie, it was fantastic!",
    "The movie was okay, but not great.",
    "I hated the movie, it was terrible.",
]

# Initialize the CountVectorizer
vectorizer = CountVectorizer()

# Fit and transform the corpus to a document-term matrix
X = vectorizer.fit_transform(corpus)

# Convert the document-term matrix into a dense format (optional for visualization)
X_dense = X.toarray()

# Get the vocabulary (mapping of words to index positions)
vocab = vectorizer.get_feature_names_out()

# Print the vocabulary and document-term matrix
print("Vocabulary:", vocab)
print("Document-Term Matrix:\n", X_dense)

Ausgabe:

Vocabulary: ['but' 'fantastic' 'great' 'hated' 'it' 'loved' 'movie' 'not' 'okay' 'terrible' 'the' 'was']
Document-Term Matrix:
 [[0 1 0 0 1 1 1 0 0 0 1 1]  # First review: "I loved the movie, it was fantastic!"
  [1 0 1 0 1 0 1 1 1 0 1 1]  # Second review: "The movie was okay, but not great."
  [0 0 0 1 1 0 1 0 0 1 1 1]] # Third review: "I hated the movie, it was terrible."

Hier ist, wie wir die obige Ausgabe interpretieren können:

• Jedem einzelnen Wort im Korpus wird ein Index zugewiesen, und die Wörter werden alphabetisch geordnet. Zum Beispiel steht "aber" bei Index 0, "fantastisch" bei Index 1, "Film" bei Index 6 und so weiter.
•  Jede Zeile in der Dokumentenmatrix steht für eine Filmkritik, und jede Spalte entspricht einem Wort aus dem Vokabular. Die Werte in der Matrix stellen die Häufigkeit jedes Worts in diesem bestimmten Dokument dar.
• Erste Überprüfung: [0 1 0 0 1 1 1 0 0 0 1 1] zeigt an, dass:
• Das Wort "fantastisch" erscheint einmal (1 bei Index 1),
• Das Wort "geliebt" erscheint einmal (1 bei Index 5),
• Das Wort "Film" erscheint einmal (1 bei Index 6),
• Das Wort "es" erscheint einmal (1 bei Index 4),
• Und so weiter.

Der BoW-Vektor kann wie folgt interpretiert werden:

• Jedes Dokument ist ein Vektor von Zahlen, die die Anzahl der Wörter darstellen. Die Dimensionen des Vektors sind gleich der Größe des Vokabulars. In diesem Fall hat das Vokabular 12 Wörter, also wird jede Rezension in einen 12-dimensionalen Vektor umgewandelt.
• Die meisten Wörter in jeder Zeile sind Nullen, weil nicht jedes Dokument jedes Wort aus dem Vokabular enthält. Daher sind BoW-Modelle oft spärlich, das heißt, sie haben viele Nullen.

Vorteile und Grenzen von Bag of Words

Gehen wir nun auf einige der Vorteile und Grenzen des Bag of Words-Modells ein.

Vorteile

1. Einfach zu implementieren und zu interpretieren: Das Bag of Words-Modell ist eine der einfachsten Textdarstellungstechniken und daher ideal für Anfänger. Seine Einfachheit ermöglicht eine schnelle Umsetzung, ohne dass komplexe Vorverarbeitungen oder spezielle Modelle erforderlich sind.
2. Einfach zu verwenden für Textklassifizierungsaufgaben: Bag of Words eignet sich gut für grundlegende Aufgaben wie Textklassifizierung, Stimmungsanalyse und Spam-Erkennung. Diese Aufgaben erfordern oft keine ausgefeilten Sprachmodelle, so dass eine BOW-Darstellung ausreichend und effizient ist.

Einschränkungen

1. Die Größe des Wortschatzes beeinflusst die Sparsamkeit der Repräsentationen: Je größer der Wortschatz ist, desto spärlicher und hochdimensionaler wird die Darstellung. Diese Spärlichkeit kann es den Modellen erschweren, effektiv zu lernen und erfordert eine sorgfältige Abstimmung der Vokabelgröße, um übermäßige Rechenkosten zu vermeiden.
2. Erzeugt spärliche Matrizen, die rechenaufwändig sind: Da jedes Dokument durch die Häufigkeit jedes Worts in einem potenziell großen Vokabular repräsentiert wird, sind die resultierenden Matrizen oft größtenteils Nullen, was bei der Speicherung und Verarbeitung in Machine-Learning-Pipelines ineffizient sein kann. Dünne Matrizen verbrauchen viel Speicherplatz und erfordern oft spezielle Tools und Bibliotheken für eine effiziente Speicherung und Berechnung, insbesondere bei großen Datensätzen.
3. Verliert Bedeutung und Kontext: BOW missachtet die Wortfolge und die Satzstruktur, wodurch grammatikalische Zusammenhänge und der Sinn verloren gehen. Diese Einschränkung macht sie weniger geeignet für Aufgaben, bei denen Kontext, Nuancen und Wortreihenfolge eine Rolle spielen, wie z. B. bei der Übersetzung oder der Erkennung von Stimmungen in komplexen Sätzen.

Die folgenden Strategien können eingesetzt werden, um den Wortschatz im Bag of Words zu verkleinern:

• Fall ignorieren. 
• Entfernen von Interpunktionen.
• Entfernen von Stoppwörtern, d.h. gebräuchlichen Wörtern wie das und a. 
• Sicherstellen, dass alle Wörter richtig geschrieben sind. 
• Stemming-Techniken anwenden, um Wörter auf ihre Stammform zu reduzieren.

Nächste Schritte: Jenseits der Worthülsen

Eine Einschränkung des Bag of Words-Modells ist, dass es alle Wörter gleich behandelt. Leider kann dies dazu führen, dass einige Wörter mehr Bedeutung erhalten, nur weil sie häufig vorkommen. 

TF-IDF (Term Frequency-Inverse Document Frequency) ist eine Lösung für dieses Problem, da es die Gewichtung von Wörtern danach anpasst, wie häufig sie in allen Dokumenten vorkommen.

TF-IDF: Eine Erweiterung zu Bag of Words

Die Termfrequenz (TF) gibt die Häufigkeit eines Terms in einem Dokument an. Die inverse Dokumentenhäufigkeit (IDF) reduziert den Einfluss häufig vorkommender Wörter in mehreren Dokumenten. Der TF-IDF-Score wird durch Multiplikation der beiden Metriken berechnet. 

Nehmen wir ein Dokument mit 200 Wörtern, in dem das Wort Liebe 5 Mal vorkommt. Die TF für Liebe ist dann (5 / 200) = 0,025. Angenommen, wir haben eine Million Dokumente und das Wort Liebe kommt in eintausend davon vor, dann berechnet sich die inverse Dokumentenhäufigkeit (IDF) als log(1000000 / 1000) = 3. Das TF-IDF-Gewicht ist das Produkt aus diesen Größen: 0.025 * 3 = 0.075.

In Scikit-learn ist dies mit der Klasse TfidfVectorizer relativ einfach zu berechnen.

from sklearn.feature_extraction.text import TfidfVectorizer
# Sample corpus
corpus = [
    "Python is amazing and fun.",
    "Python is not just fun but also powerful.",
    "Learning Python is fun!",
]

# Create the Tf-idf vectorizer
tfidf_vectorizer = TfidfVectorizer()

# Fit and transform the corpus
X_tfidf = tfidf_vectorizer.fit_transform(corpus)

# Show the Vocabulary
print("Vocabulary:", tfidf_vectorizer.get_feature_names_out())

# Show the TF-IDF Matrix
print("TF-IDF Representation:")
print(X_tfidf.toarray())

Ausgabe:

Vocabulary: ['also' 'amazing' 'and' 'but' 'fun' 'is' 'just' 'learning' 'not'
 'powerful' 'python']
TF-IDF Representation:
[[0.         0.57292883 0.57292883 0.         0.338381   0.338381
  0.         0.         0.         0.         0.338381  ]
 [0.40667606 0.         0.         0.40667606 0.24018943 0.24018943
  0.40667606 0.         0.40667606 0.40667606 0.24018943]
 [0.         0.         0.         0.         0.41285857 0.41285857
  0.         0.69903033 0.         0.         0.41285857]]

Die oben implementierte TF-IDF-Matrix liefert dir ein gewichtetes Maß anstelle der reinen Häufigkeiten.

Obwohl das Bag of Words-Modell seine Grenzen hat, insbesondere bei größeren und komplexeren Datensätzen, ist es immer noch ein wichtiger Baustein in vielen NLP-Anwendungen. Wenn du sie verstehst, hilft dir das bei der Erkundung fortgeschrittener Modelle wie Word Embeddings und Transformers.

Von hier aus kannst du mit BoW in deinen Projekten experimentieren, z.B. bei der Spam-Erkennung, der Sentiment-Analyse, dem Clustering von Dokumenten und mehr.

Wenn du dich über Bag of Words hinaus verbessern willst, kannst du Methoden wie Word2Vec und GloVe oder Deep Learning-Modelle wie BERT ausprobieren.

Schlussgedanken

Die Bag of Words-Technik ist eine grundlegende Technik, die in der natürlichen Sprachverarbeitung eingesetzt wird. Es ist eine einfache und effektive Methode, um unstrukturierten Text in numerische Merkmale umzuwandeln, die von Algorithmen für maschinelles Lernen genutzt werden können. In diesem Tutorium haben wir uns damit beschäftigt:

• Was ist das Bag of Words (BoW)-Modell?
• Die Vorteile des Bag of Word-Modells beim Aufbau von Machine Learning-Modellen.
• Wie man das Bag of Words-Modell in Python implementiert.
•  Vorteile und Grenzen von Bag of Words.
• Die Theorie und Motivation hinter dem Bag of Words-Modell.
• Die Einführung von TF-IDF als Verbesserung des traditionellen Bag of Words-Ansatzes.

Schau dir unseren Natural Language Processing in Python Skill Track an, um tief in die Verarbeitung natürlicher Sprache einzutauchen.