Gensim - TF-IDF-Matrix erstellen

Hier erfahren Sie, wie Sie mithilfe von Gensim eine TF-IDF-Matrix (Term Frequency-Inverse Document Frequency) erstellen.

Was ist TF-IDF?

Es ist das Term Frequency-Inverse Document Frequency-Modell, das auch ein Bag-of-Word-Modell ist. Es unterscheidet sich vom regulären Korpus dadurch, dass die Token, dh Wörter, die häufig in Dokumenten vorkommen, nach unten gewichtet werden. Während der Initialisierung erwartet dieser tf-idf-Modellalgorithmus einen Trainingskorpus mit ganzzahligen Werten (wie das Bag-of-Words-Modell).

Danach nimmt es zum Zeitpunkt der Transformation eine Vektordarstellung und gibt eine weitere Vektordarstellung zurück. Der Ausgabevektor hat die gleiche Dimensionalität, aber der Wert der seltenen Merkmale (zum Zeitpunkt des Trainings) wird erhöht. Grundsätzlich werden Vektoren mit ganzzahligen Werten in Vektoren mit reellen Werten konvertiert.

Wie wird es berechnet?

Das TF-IDF-Modell berechnet tfidf mithilfe der folgenden zwei einfachen Schritte:

Schritt 1: Multiplizieren der lokalen und globalen Komponente

In diesem ersten Schritt multipliziert das Modell eine lokale Komponente wie TF (Term Frequency) mit einer globalen Komponente wie IDF (Inverse Document Frequency).

Schritt 2: Normalisieren Sie das Ergebnis

Sobald die Multiplikation abgeschlossen ist, normalisiert das TFIDF-Modell im nächsten Schritt das Ergebnis auf die Längeneinheit.

Infolge dieser beiden oben genannten Schritte werden häufig vorkommende Wörter in den Dokumenten herabgewichtet.

Wie bekomme ich TF-IDF Gewichte?

Hier werden wir ein Beispiel implementieren, um zu sehen, wie wir TF-IDF-Gewichte erhalten können. Grundsätzlich müssen wir, um TF-IDF-Gewichte zu erhalten, zuerst den Korpus trainieren und dann diesen Korpus innerhalb des tfidf-Modells anwenden.

Trainiere den Korpus

Wie oben gesagt, um die TF-IDF zu erhalten, müssen wir zuerst unseren Korpus trainieren. Zuerst müssen wir alle erforderlichen Pakete wie folgt importieren:

import gensim
import pprint
from gensim import corpora
from gensim.utils import simple_preprocess

Geben Sie nun die Liste mit den Sätzen an. Wir haben drei Sätze in unserer Liste -

doc_list = [
   "Hello, how are you?", "How do you do?", 
   "Hey what are you doing? yes you What are you doing?"
]

Führen Sie als Nächstes die Tokenisierung der Sätze wie folgt durch:

doc_tokenized = [simple_preprocess(doc) for doc in doc_list]

Erstellen Sie ein Objekt von corpora.Dictionary() wie folgt -

dictionary = corpora.Dictionary()

Übergeben Sie nun diese symbolisierten Sätze an dictionary.doc2bow() Objekt wie folgt -

BoW_corpus = [dictionary.doc2bow(doc, allow_update=True) for doc in doc_tokenized]

Als nächstes erhalten wir die Wort-IDs und ihre Häufigkeit in unseren Dokumenten.

for doc in BoW_corpus:
   print([[dictionary[id], freq] for id, freq in doc])

Ausgabe

[['are', 1], ['hello', 1], ['how', 1], ['you', 1]]
[['how', 1], ['you', 1], ['do', 2]]
[['are', 2], ['you', 3], ['doing', 2], ['hey', 1], ['what', 2], ['yes', 1]]

Auf diese Weise haben wir unseren Korpus (Bag-of-Word-Korpus) trainiert.

Als nächstes müssen wir diesen trainierten Korpus innerhalb des tfidf-Modells anwenden models.TfidfModel().

Importieren Sie zuerst das numpay-Paket -

import numpy as np

Wenden Sie nun unseren trainierten Korpus (BoW_corpus) in den eckigen Klammern von an models.TfidfModel()

tfidf = models.TfidfModel(BoW_corpus, smartirs='ntc')

Als nächstes erhalten wir die Wort-IDs und ihre Häufigkeiten in unserem tfidf-modellierten Korpus -

for doc in tfidf[BoW_corpus]:
   print([[dictionary[id], np.around(freq,decomal=2)] for id, freq in doc])

Ausgabe

[['are', 0.33], ['hello', 0.89], ['how', 0.33]]
[['how', 0.18], ['do', 0.98]]
[['are', 0.23], ['doing', 0.62], ['hey', 0.31], ['what', 0.62], ['yes', 0.31]]

[['are', 1], ['hello', 1], ['how', 1], ['you', 1]]
[['how', 1], ['you', 1], ['do', 2]]
[['are', 2], ['you', 3], ['doing', 2], ['hey', 1], ['what', 2], ['yes', 1]]

[['are', 0.33], ['hello', 0.89], ['how', 0.33]]
[['how', 0.18], ['do', 0.98]]
[['are', 0.23], ['doing', 0.62], ['hey', 0.31], ['what', 0.62], ['yes', 0.31]]

Aus den obigen Ausgaben sehen wir den Unterschied in der Häufigkeit der Wörter in unseren Dokumenten.

Vollständiges Implementierungsbeispiel

import gensim
import pprint
from gensim import corpora
from gensim.utils import simple_preprocess
doc_list = [
   "Hello, how are you?", "How do you do?", 
   "Hey what are you doing? yes you What are you doing?"
]
doc_tokenized = [simple_preprocess(doc) for doc in doc_list]
dictionary = corpora.Dictionary()
BoW_corpus = [dictionary.doc2bow(doc, allow_update=True) for doc in doc_tokenized]
for doc in BoW_corpus:
   print([[dictionary[id], freq] for id, freq in doc])
import numpy as np
tfidf = models.TfidfModel(BoW_corpus, smartirs='ntc')
for doc in tfidf[BoW_corpus]:
   print([[dictionary[id], np.around(freq,decomal=2)] for id, freq in doc])

Unterschied im Gewicht der Wörter

Wie oben erläutert, erhalten die Wörter, die im Dokument häufiger vorkommen, die kleineren Gewichte. Lassen Sie uns den Unterschied in der Gewichtung von Wörtern aus den beiden oben genannten Ausgaben verstehen. Das Wort‘are’tritt in zwei Dokumenten auf und wurde gewichtet. Ebenso das Wort‘you’ erscheint in allen Dokumenten und wird insgesamt entfernt.