Gensim - Kurzanleitung

Dieses Kapitel hilft Ihnen dabei, die Geschichte und Funktionen von Gensim sowie seine Verwendung und Vorteile zu verstehen.

Was ist Gensim?

Gensim = “Generate Similar”ist eine beliebte Open-Source-Bibliothek für die Verarbeitung natürlicher Sprache (NLP), die für die unbeaufsichtigte Themenmodellierung verwendet wird. Es verwendet akademische Spitzenmodelle und modernes statistisches maschinelles Lernen, um verschiedene komplexe Aufgaben auszuführen, wie z.

• Erstellen von Dokument- oder Wortvektoren
• Corpora
• Themenidentifikation durchführen
• Dokumentvergleich durchführen (semantisch ähnliche Dokumente abrufen)
• Analyse von Klartextdokumenten auf semantische Struktur

Neben der Ausführung der oben genannten komplexen Aufgaben wurde Gensim, das in Python und Cython implementiert ist, für die Verarbeitung großer Textsammlungen mithilfe von Daten-Streaming sowie inkrementellen Online-Algorithmen entwickelt. Dies unterscheidet es von den Softwarepaketen für maschinelles Lernen, die nur auf die In-Memory-Verarbeitung abzielen.

Geschichte

2008 startete Gensim als Sammlung verschiedener Python-Skripte für die tschechische digitale Mathematik. Dort diente es dazu, eine kurze Liste der Artikel zu erstellen, die einem bestimmten Artikel am ähnlichsten sind. Im Jahr 2009 veröffentlichte RARE Technologies Ltd. seine erste Version. Dann, später im Juli 2019, haben wir die stabile Version (3.8.0) erhalten.

Verschiedene Funktionen

Im Folgenden sind einige der von Gensim angebotenen Funktionen und Fähigkeiten aufgeführt:

Skalierbarkeit

Gensim kann mithilfe seiner inkrementellen Online-Trainingsalgorithmen problemlos große und webbasierte Korpora verarbeiten. Es ist von Natur aus skalierbar, da nicht der gesamte Eingabekorpus gleichzeitig vollständig im Arbeitsspeicher (RAM) gespeichert werden muss. Mit anderen Worten, alle seine Algorithmen sind in Bezug auf die Korpusgröße speicherunabhängig.

Robust

Gensim ist von Natur aus robust und wird seit über 4 Jahren von verschiedenen Personen und Organisationen in verschiedenen Systemen eingesetzt. Wir können problemlos unseren eigenen Eingabekorpus oder Datenstrom anschließen. Es ist auch sehr einfach, mit anderen Vektorraumalgorithmen zu erweitern.

Plattformunabhängig

Wie wir wissen, ist Python eine sehr vielseitige Sprache, da Python Gensim auf allen Plattformen (wie Windows, Mac OS, Linux) ausgeführt wird, die Python und Numpy unterstützen.

Effiziente Multicore-Implementierungen

Um die Verarbeitung und das Abrufen auf Maschinenclustern zu beschleunigen, bietet Gensim effiziente Multicore-Implementierungen verschiedener gängiger Algorithmen wie Latent Semantic Analysis (LSA), Latent Dirichlet Allocation (LDA), Random Projections (RP), Hierarchical Dirichlet Process (HDP).

Open Source und reichlich Community-Unterstützung

Gensim ist unter der von OSI genehmigten GNU LGPL-Lizenz lizenziert, mit der es sowohl für den persönlichen als auch für den kommerziellen Gebrauch kostenlos verwendet werden kann. Alle in Gensim vorgenommenen Änderungen sind wiederum Open-Source-Änderungen und werden auch von der Community reichlich unterstützt.

Verwendung von Gensim

Gensim wurde in über tausend kommerziellen und akademischen Anwendungen verwendet und zitiert. Es wird auch von verschiedenen Forschungsarbeiten und Abschlussarbeiten zitiert. Es enthält gestreamte parallelisierte Implementierungen der folgenden -

fastText

fastText verwendet ein neuronales Netzwerk für die Worteinbettung und ist eine Bibliothek zum Erlernen der Worteinbettung und der Textklassifizierung. Es wird vom FAIR-Labor (FAIR) von Facebook erstellt. Dieses Modell ermöglicht es uns grundsätzlich, einen überwachten oder unbeaufsichtigten Algorithmus zum Erhalten von Vektordarstellungen für Wörter zu erstellen.

Word2vec

Word2vec, das zur Erzeugung der Worteinbettung verwendet wird, ist eine Gruppe von flachen und zweischichtigen neuronalen Netzwerkmodellen. Die Modelle sind grundsätzlich darauf trainiert, sprachliche Wortkontexte zu rekonstruieren.

LSA (Latent Semantic Analysis)

Es ist eine Technik in NLP (Natural Language Processing), mit der wir die Beziehungen zwischen einer Reihe von Dokumenten und ihren enthaltenen Begriffen analysieren können. Dazu werden eine Reihe von Konzepten erstellt, die sich auf die Dokumente und Begriffe beziehen.

LDA (Latent Dirichlet Allocation)

Es ist eine Technik in NLP, mit der Beobachtungssätze von unbeobachteten Gruppen erklärt werden können. Diese unbeobachteten Gruppen erklären, warum einige Teile der Daten ähnlich sind. Das ist der Grund, es ist ein generatives statistisches Modell.

tf-idf (Begriff Frequenz-inverse Dokumentfrequenz)

tf-idf, eine numerische Statistik beim Abrufen von Informationen, gibt an, wie wichtig ein Wort für ein Dokument in einem Korpus ist. Es wird häufig von Suchmaschinen verwendet, um die Relevanz eines Dokuments bei einer Benutzerabfrage zu bewerten und zu bewerten. Es kann auch zur Filterung von Stoppwörtern bei der Zusammenfassung und Klassifizierung von Texten verwendet werden.

Alle werden in den nächsten Abschnitten ausführlich erläutert.

Vorteile

Gensim ist ein NLP-Paket, das Themenmodellierung durchführt. Die wichtigen Vorteile von Gensim sind folgende:

• Wir können die Möglichkeiten der Themenmodellierung und Worteinbettung in andere Pakete wie erhalten ‘scikit-learn’ und ‘R’Die von Gensim bereitgestellten Möglichkeiten zum Erstellen von Themenmodellen und zum Einbetten von Wörtern sind jedoch beispiellos. Es bietet auch bequemere Möglichkeiten für die Textverarbeitung.

• Ein weiterer wichtiger Vorteil von Gensim ist, dass wir damit große Textdateien verarbeiten können, auch ohne die gesamte Datei in den Speicher zu laden.

• Gensim erfordert keine kostspieligen Anmerkungen oder manuellen Kennzeichnungen von Dokumenten, da unbeaufsichtigte Modelle verwendet werden.

In diesem Kapitel werden die Voraussetzungen für die Installation von Gensim, seine Kernabhängigkeiten und Informationen zur aktuellen Version erläutert.

Voraussetzungen

Um Gensim installieren zu können, muss Python auf unseren Computern installiert sein. Sie können unter dem Link www.python.org/downloads/ die neueste Version für Ihr Betriebssystem auswählen, z. B. Windows und Linux / Unix. Unter dem Link www.tutorialspoint.com/python3/index.htm finden Sie ein grundlegendes Tutorial zu Python. Gensim wird für Linux, Windows und Mac OS X unterstützt.

Code-Abhängigkeiten

Gensim sollte auf jeder Plattform ausgeführt werden, die dies unterstützt Python 2.7 or 3.5+ und NumPy. Es hängt tatsächlich von der folgenden Software ab -

Python

Gensim wird mit den Python-Versionen 2.7, 3.5, 3.6 und 3.7 getestet.

Numpy

Wie wir wissen, ist NumPy ein Paket für wissenschaftliches Rechnen mit Python. Es kann auch als effizienter mehrdimensionaler Container mit generischen Daten verwendet werden. Gensim ist auf das NumPy-Paket angewiesen, um Zahlen zu ermitteln. Ein grundlegendes Tutorial zu Python finden Sie unter dem Link www.tutorialspoint.com/numpy/index.htm .

smart_open

smart_open, eine Python 2 & Python 3-Bibliothek, wird zum effizienten Streaming sehr großer Dateien verwendet. Es unterstützt das Streaming von / zu Speichern wie S3, HDFS, WebHDFS, HTTP, HTTPS, SFTP oder lokalen Dateisystemen. Gensim hängt davon absmart_open Python-Bibliothek zum transparenten Öffnen von Dateien im Remote-Speicher sowie komprimierten Dateien.

Aktuelle Version

Die aktuelle Version von Gensim ist 3.8.0 die im Juli 2019 veröffentlicht wurde.

Installation mit Terminal

Eine der einfachsten Möglichkeiten, Gensim zu installieren, besteht darin, den folgenden Befehl in Ihrem Terminal auszuführen:

pip install --upgrade gensim

Installation mit Conda Environment

Eine alternative Möglichkeit zum Herunterladen von Gensim ist die Verwendung condaUmgebung. Führen Sie den folgenden Befehl in Ihrem ausconda Terminal -

conda install –c conda-forge gensim

Installation über Quellcode - Paket

Angenommen, Sie haben das Quellpaket heruntergeladen und entpackt und müssen die folgenden Befehle ausführen:

python setup.py test
python setup.py install

Hier lernen wir die Kernkonzepte von Gensim kennen, wobei der Schwerpunkt auf den Dokumenten und dem Korpus liegt.

Kernkonzepte von Gensim

Im Folgenden sind die Kernkonzepte und -begriffe aufgeführt, die zum Verständnis und zur Verwendung von Gensim erforderlich sind:

• Document - ZIt bezieht sich auf einen Text.

• Corpus - Es bezieht sich auf eine Sammlung von Dokumenten.

• Vector - Die mathematische Darstellung eines Dokuments wird als Vektor bezeichnet.

• Model - Es bezieht sich auf einen Algorithmus, der zum Transformieren von Vektoren von einer Darstellung in eine andere verwendet wird.

Was ist ein Dokument?

Wie bereits erwähnt, bezieht es sich auf einen Text. Wenn wir ins Detail gehen, handelt es sich um ein Objekt vom Typ Textsequenz, das als bekannt ist‘str’ In Python 3. In Gensim kann ein Dokument beispielsweise Folgendes sein:

• Kurzer Tweet mit 140 Zeichen
• Einzelner Absatz, dh Zusammenfassung eines Artikels oder eines Forschungspapiers
• Nachrichtenartikel
• Book
• Novel
• Theses

Textsequenz

Ein Textsequenztyp ist allgemein bekannt als ‘str’ in Python 3. Wie wir wissen, werden Textdaten in Python mit Zeichenfolgen oder genauer behandelt ‘str’Objekte. Strings sind im Grunde unveränderliche Sequenzen von Unicode-Codepunkten und können auf folgende Arten geschrieben werden:

• Single quotes - Zum Beispiel ‘Hi! How are you?’. Es erlaubt uns auch, doppelte Anführungszeichen einzubetten. Zum Beispiel,‘Hi! “How” are you?’

• Double quotes - Zum Beispiel "Hi! How are you?". Es ermöglicht uns auch, einfache Anführungszeichen einzubetten. Zum Beispiel,"Hi! 'How' are you?"

• Triple quotes - Es kann entweder drei einfache Anführungszeichen haben wie: '''Hi! How are you?'''. oder drei doppelte Anführungszeichen wie,"""Hi! 'How' are you?"""

Alle Leerzeichen werden in das Zeichenfolgenliteral aufgenommen.

Beispiel

Es folgt ein Beispiel für ein Dokument in Gensim -

Document = “Tutorialspoint.com is the biggest online tutorials library and it’s all free also”

Was ist Korpus?

Ein Korpus kann als der große und strukturierte Satz maschinenlesbarer Texte definiert werden, die in einer natürlichen Kommunikationsumgebung erstellt werden. In Gensim wird eine Sammlung von Dokumentobjekten als Korpus bezeichnet. Der Plural von Korpus istcorpora.

Rolle des Korpus in Gensim

Ein Korpus in Gensim erfüllt die folgenden zwei Rollen:

Dient als Eingabe für das Training eines Modells

Die allererste und wichtigste Rolle, die ein Korpus in Gensim spielt, ist die Eingabe eines Modells. Um die internen Parameter des Modells zu initialisieren, sucht das Modell während des Trainings nach einigen allgemeinen Themen und Themen aus dem Trainingskorpus. Wie oben erläutert, konzentriert sich Gensim auf unbeaufsichtigte Modelle und erfordert daher keinerlei menschliches Eingreifen.

Dient als Topic Extractor

Sobald das Modell trainiert ist, kann es verwendet werden, um Themen aus den neuen Dokumenten zu extrahieren. Hier sind die neuen Dokumente diejenigen, die in der Schulungsphase nicht verwendet werden.

Beispiel

Der Korpus kann alle Tweets einer bestimmten Person, eine Liste aller Artikel einer Zeitung oder alle Forschungsarbeiten zu einem bestimmten Thema usw. enthalten.

Korpus sammeln

Es folgt ein Beispiel eines kleinen Korpus, der 5 Dokumente enthält. Hier ist jedes Dokument eine Zeichenfolge, die aus einem einzelnen Satz besteht.

t_corpus = [
   "A survey of user opinion of computer system response time",
   "Relation of user perceived response time to error measurement",
   "The generation of random binary unordered trees",
   "The intersection graph of paths in trees",
   "Graph minors IV Widths of trees and well quasi ordering",
]

Korpus vorverarbeiten

Sobald wir den Korpus gesammelt haben, sollten einige Vorverarbeitungsschritte unternommen werden, um den Korpus einfach zu halten. Wir können einfach einige häufig verwendete englische Wörter wie 'the' entfernen. Wir können auch Wörter entfernen, die nur einmal im Korpus vorkommen.

Das folgende Python-Skript wird beispielsweise verwendet, um jedes Dokument in Kleinbuchstaben zu schreiben, es durch Leerzeichen aufzuteilen und Stoppwörter herauszufiltern.

Beispiel

import pprint
t_corpus = [
   "A survey of user opinion of computer system response time", 
   "Relation of user perceived response time to error measurement", 
   "The generation of random binary unordered trees", 
   "The intersection graph of paths in trees", 
   "Graph minors IV Widths of trees and well quasi ordering",
]
stoplist = set('for a of the and to in'.split(' '))
processed_corpus = [[word for word in document.lower().split() if word not in stoplist]
   for document in t_corpus]
	
pprint.pprint(processed_corpus)
]

Ausgabe

[['survey', 'user', 'opinion', 'computer', 'system', 'response', 'time'],
['relation', 'user', 'perceived', 'response', 'time', 'error', 'measurement'],
['generation', 'random', 'binary', 'unordered', 'trees'],
['intersection', 'graph', 'paths', 'trees'],
['graph', 'minors', 'iv', 'widths', 'trees', 'well', 'quasi', 'ordering']]

Effektive Vorverarbeitung

Gensim bietet auch Funktionen für eine effektivere Vorverarbeitung des Korpus. Bei einer solchen Vorverarbeitung können wir ein Dokument in eine Liste von Token in Kleinbuchstaben konvertieren. Wir können auch Token ignorieren, die zu kurz oder zu lang sind. Eine solche Funktion istgensim.utils.simple_preprocess(doc, deacc=False, min_len=2, max_len=15).

gensim.utils.simple_preprocess() fucntion

Gensim bietet diese Funktion, um ein Dokument in eine Liste von Token in Kleinbuchstaben zu konvertieren und um zu kurze oder zu lange Token zu ignorieren. Es hat die folgenden Parameter -

doc (str)

Es bezieht sich auf das Eingabedokument, auf das die Vorverarbeitung angewendet werden soll.

deacc (bool, optional)

Dieser Parameter wird verwendet, um die Akzentmarkierungen von Token zu entfernen. Es verwendetdeaccent() um dies zu tun.

min_len (int, optional)

Mit Hilfe dieses Parameters können wir die Mindestlänge eines Tokens festlegen. Die Token, die kürzer als die definierte Länge sind, werden verworfen.

max_len (int, optional)

Mit Hilfe dieses Parameters können wir die maximale Länge eines Tokens festlegen. Die Token, die länger als die definierte Länge sind, werden verworfen.

Die Ausgabe dieser Funktion wären die aus dem Eingabedokument extrahierten Token.

Hier lernen wir die Kernkonzepte von Gensim kennen, wobei der Schwerpunkt auf dem Vektor und dem Modell liegt.

Was ist Vektor?

Was ist, wenn wir auf die latente Struktur in unserem Korpus schließen wollen? Dazu müssen wir die Dokumente so darstellen, dass wir sie mathematisch manipulieren können. Eine beliebte Art der Darstellung besteht darin, jedes Korpusdokument als Vektor von Merkmalen darzustellen. Deshalb können wir sagen, dass der Vektor eine mathematisch bequeme Darstellung eines Dokuments ist.

Um Ihnen ein Beispiel zu geben, stellen wir ein einzelnes Merkmal unseres oben verwendeten Korpus als QS-Paar dar -

Q - Wie oft kommt das Wort Hello im Dokument erscheinen?

A - Null (0).

Q - Wie viele Absätze enthält das Dokument?

A - Zwei (2)

Die Frage wird im Allgemeinen durch ihre Ganzzahl-ID dargestellt, daher besteht die Darstellung dieses Dokuments aus einer Reihe von Paaren wie (1, 0.0), (2, 2.0). Eine solche Vektordarstellung ist bekannt alsdenseVektor. Warumdense, weil es eine explizite Antwort auf alle oben geschriebenen Fragen enthält.

Die Darstellung kann einfach wie (0, 2) sein, wenn wir alle Fragen im Voraus kennen. Eine solche Reihenfolge der Antworten (natürlich, wenn die Fragen im Voraus bekannt sind) ist dievector für unser Dokument.

Eine andere beliebte Art der Darstellung ist die bag-of-word (BoW)Modell. Bei diesem Ansatz wird jedes Dokument im Wesentlichen durch einen Vektor dargestellt, der die Häufigkeit jedes Wortes im Wörterbuch enthält.

Nehmen wir als Beispiel an, wir haben ein Wörterbuch, das die Wörter ['Hallo', 'Wie', 'Sind', 'Du'] enthält. Ein Dokument, das aus der Zeichenfolge „Wie geht es Ihnen?“ Besteht, wird dann durch den Vektor [0, 2, 1, 1] dargestellt. Hier sind die Einträge des Vektors in der Reihenfolge des Auftretens von "Hallo", "Wie", "Sind" und "Sie".

Vektor versus Dokument

Aus der obigen Erklärung des Vektors wird die Unterscheidung zwischen einem Dokument und einem Vektor fast verstanden. Aber um es klarer zu machen,document ist Text und vectorist eine mathematisch bequeme Darstellung dieses Textes. Leider verwenden diese Begriffe manchmal von vielen Menschen synonym.

Nehmen wir zum Beispiel an, wir haben ein beliebiges Dokument A, anstatt zu sagen: "Der Vektor, der dem Dokument A entspricht", sagten sie "der Vektor A" oder "das Dokument A". Dies führt zu großer Mehrdeutigkeit. Eine weitere wichtige Sache, die hier zu beachten ist, ist, dass zwei verschiedene Dokumente dieselbe Vektordarstellung haben können.

Korpus in Vektorliste umwandeln

Bevor wir ein Implementierungsbeispiel für die Konvertierung des Korpus in die Liste der Vektoren nehmen, müssen wir jedem Wort im Korpus eine eindeutige Ganzzahl-ID zuordnen. Dazu erweitern wir das Beispiel aus dem obigen Kapitel.

Beispiel

from gensim import corpora
dictionary = corpora.Dictionary(processed_corpus)
print(dictionary)

Ausgabe

Dictionary(25 unique tokens: ['computer', 'opinion', 'response', 'survey', 'system']...)

Es zeigt, dass in unserem Korpus 25 verschiedene Token enthalten sind gensim.corpora.Dictionary.

Implementierungsbeispiel

Wir können das Wörterbuch verwenden, um Token-Dokumente wie folgt in diese 5-Diemsional-Vektoren umzuwandeln:

pprint.pprint(dictionary.token2id)

Ausgabe

{
   'binary': 11,
   'computer': 0,
   'error': 7,
   'generation': 12,
   'graph': 16,
   'intersection': 17,
   'iv': 19,
   'measurement': 8,
   'minors': 20,
   'opinion': 1,
   'ordering': 21,
   'paths': 18,
   'perceived': 9,
   'quasi': 22,
   'random': 13,
   'relation': 10,
   'response': 2,
   'survey': 3,
   'system': 4,
   'time': 5,
   'trees': 14,
   'unordered': 15,
   'user': 6,
   'well': 23,
   'widths': 24
}

In ähnlicher Weise können wir die Bag-of-Word-Darstellung für ein Dokument wie folgt erstellen:

BoW_corpus = [dictionary.doc2bow(text) for text in processed_corpus]
pprint.pprint(BoW_corpus)

Ausgabe

[
   [(0, 1), (1, 1), (2, 1), (3, 1), (4, 1), (5, 1), (6, 1)],
   [(2, 1), (5, 1), (6, 1), (7, 1), (8, 1), (9, 1), (10, 1)],
   [(11, 1), (12, 1), (13, 1), (14, 1), (15, 1)],
   [(14, 1), (16, 1), (17, 1), (18, 1)],
   [(14, 1), (16, 1), (19, 1), (20, 1), (21, 1), (22, 1), (23, 1), (24, 1)]
]

Was ist ein Modell?

Was passiert, wenn wir den Korpus vektorisiert haben? Jetzt können wir es mit Modellen transformieren. Das Modell kann auf einen Algorithmus bezogen werden, der zum Transformieren einer Dokumentdarstellung in eine andere verwendet wird.

Wie wir bereits besprochen haben, werden Dokumente in Gensim als Vektoren dargestellt, daher können wir sie zwar als Transformation zwischen zwei Vektorräumen modellieren. Es gibt immer eine Trainingsphase, in der Modelle die Details solcher Transformationen lernen. Das Modell liest den Trainingskorpus während der Trainingsphase.

Modell initialisieren

Lassen Sie uns initialisieren tf-idfModell. Dieses Modell transformiert Vektoren aus der BoW-Darstellung (Bag of Words) in einen anderen Vektorraum, in dem die Frequenzzählungen gemäß der relativen Seltenheit jedes Wortes im Korpus gewichtet werden.

Implementierungsbeispiel

Im folgenden Beispiel werden wir das initialisieren tf-idfModell. Wir werden es auf unserem Korpus trainieren und dann die Zeichenfolge "Baumdiagramm" transformieren.

Beispiel

from gensim import models
tfidf = models.TfidfModel(BoW_corpus)
words = "trees graph".lower().split()
print(tfidf[dictionary.doc2bow(words)])

Ausgabe

[(3, 0.4869354917707381), (4, 0.8734379353188121)]

Sobald wir das Modell erstellt haben, können wir den gesamten Korpus über tfidf transformieren und indizieren und die Ähnlichkeit unseres Abfragedokuments (wir geben das Abfragedokument 'Baumsystem' an) mit jedem Dokument im Korpus abfragen.

Beispiel

from gensim import similarities
index = similarities.SparseMatrixSimilarity(tfidf[BoW_corpus],num_features=5)
query_document = 'trees system'.split()
query_bow = dictionary.doc2bow(query_document)
simils = index[tfidf[query_bow]]
print(list(enumerate(simils)))

Ausgabe

[(0, 0.0), (1, 0.0), (2, 1.0), (3, 0.4869355), (4, 0.4869355)]

Aus der obigen Ausgabe geht hervor, dass Dokument 4 und Dokument 5 einen Ähnlichkeitswert von etwa 49% aufweisen.

Darüber hinaus können wir diese Ausgabe für eine bessere Lesbarkeit wie folgt sortieren:

Beispiel

for doc_number, score in sorted(enumerate(sims), key=lambda x: x[1], reverse=True):
   print(doc_number, score)

Ausgabe

2 1.0
3 0.4869355
4 0.4869355
0 0.0
1 0.0

Im letzten Kapitel, in dem wir über Vektor und Modell gesprochen haben, haben Sie eine Vorstellung vom Wörterbuch bekommen. Hier werden wir diskutierenDictionary Objekt etwas detaillierter.

Was ist ein Wörterbuch?

Bevor wir uns eingehend mit dem Konzept des Wörterbuchs befassen, wollen wir einige einfache NLP-Konzepte verstehen -

• Token - Ein Token bedeutet ein Wort.

• Document - Ein Dokument bezieht sich auf einen Satz oder Absatz.

• Corpus - Es bezieht sich auf eine Sammlung von Dokumenten als eine Tasche von Wörtern (BoW).

Für alle Dokumente enthält ein Korpus immer die Token-ID jedes Wortes zusammen mit der Häufigkeit im Dokument.

Kommen wir zum Konzept des Wörterbuchs in Gensim. Für die Arbeit an Textdokumenten benötigt Gensim auch die Wörter, dh Token müssen in ihre eindeutigen IDs konvertiert werden. Um dies zu erreichen, haben wir die MöglichkeitDictionary object, die jedes Wort ihrer eindeutigen Ganzzahl-ID zuordnet. Dazu wird der eingegebene Text in die Liste der Wörter konvertiert und anschließend an die übergebencorpora.Dictionary() Objekt.

Benötigen Sie ein Wörterbuch

Nun stellt sich die Frage, was eigentlich das Wörterbuchobjekt benötigt und wo es verwendet werden kann. In Gensim wird das Wörterbuchobjekt verwendet, um einen Korpus mit Wortbeuteln (BoW) zu erstellen, der auch als Eingabe für die Themenmodellierung und andere Modelle verwendet wird.

Formen von Texteingaben

Es gibt drei verschiedene Formen von Eingabetexten, die wir Gensim zur Verfügung stellen können:

• Wie die Sätze, die in Pythons nativem Listenobjekt gespeichert sind (bekannt als str in Python 3)

• Als eine einzige Textdatei (kann klein oder groß sein)

• Mehrere Textdateien

Erstellen eines Wörterbuchs mit Gensim

Wie bereits erwähnt, enthält das Wörterbuch in Gensim die Zuordnung aller Wörter, auch Token genannt, zu ihrer eindeutigen Ganzzahl-ID. Wir können ein Wörterbuch aus einer Liste von Sätzen, aus einer oder mehreren Textdateien (Textdatei mit mehreren Textzeilen) erstellen. Beginnen wir also damit, ein Wörterbuch mit einer Liste von Sätzen zu erstellen.

Aus einer Liste von Sätzen

Im folgenden Beispiel erstellen wir ein Wörterbuch aus einer Liste von Sätzen. Wenn wir eine Liste von Sätzen haben oder Sie mehrere Sätze sagen können, müssen wir jeden Satz in eine Liste von Wörtern umwandeln, und Verständnis ist eine der häufigsten Methoden, um dies zu tun.

Implementierungsbeispiel

Importieren Sie zunächst die erforderlichen und erforderlichen Pakete wie folgt:

import gensim
from gensim import corpora
from pprint import pprint

Erstellen Sie als Nächstes die Verständnisliste aus der Liste der Sätze / Dokumente, um das Wörterbuch zu erstellen.

doc = [
   "CNTK formerly known as Computational Network Toolkit",
   "is a free easy-to-use open-source commercial-grade toolkit",
   "that enable us to train deep learning algorithms to learn like the human brain."
]

Als nächstes müssen wir die Sätze in Wörter aufteilen. Es heißt Tokenisierung.

text_tokens = [[text for text in doc.split()] for doc in doc]

Jetzt können wir mit Hilfe des folgenden Skripts das Wörterbuch erstellen -

dict_LoS = corpora.Dictionary(text_tokens)

Lassen Sie uns nun weitere Informationen wie die Anzahl der Token im Wörterbuch abrufen.

print(dict_LoS)

Ausgabe

Dictionary(27 unique tokens: ['CNTK', 'Computational', 'Network', 'Toolkit', 'as']...)

Wir können das Wort für die eindeutige Ganzzahlzuordnung auch wie folgt sehen:

print(dict_LoS.token2id)

Ausgabe

{
   'CNTK': 0, 'Computational': 1, 'Network': 2, 'Toolkit': 3, 'as': 4, 
   'formerly': 5, 'known': 6, 'a': 7, 'commercial-grade': 8, 'easy-to-use': 9,
   'free': 10, 'is': 11, 'open-source': 12, 'toolkit': 13, 'algorithms': 14,
   'brain.': 15, 'deep': 16, 'enable': 17, 'human': 18, 'learn': 19, 'learning': 20,
   'like': 21, 'that': 22, 'the': 23, 'to': 24, 'train': 25, 'us': 26
}

Vollständiges Implementierungsbeispiel

import gensim
from gensim import corpora
from pprint import pprint
doc = [
   "CNTK formerly known as Computational Network Toolkit",
   "is a free easy-to-use open-source commercial-grade toolkit",
   "that enable us to train deep learning algorithms to learn like the human brain."
]
text_tokens = [[text for text in doc.split()] for doc in doc]
dict_LoS = corpora.Dictionary(text_tokens)
print(dict_LoS.token2id)

Aus einer einzelnen Textdatei

Im folgenden Beispiel erstellen wir ein Wörterbuch aus einer einzelnen Textdatei. In ähnlicher Weise können wir auch ein Wörterbuch aus mehr als einer Textdatei (dh einem Verzeichnis von Dateien) erstellen.

Zu diesem Zweck haben wir das im vorherigen Beispiel verwendete Dokument in der genannten Textdatei gespeichert doc.txt. Gensim liest die Datei zeilenweise und verarbeitet sie zeilenweise mitsimple_preprocess. Auf diese Weise muss nicht die gesamte Datei auf einmal in den Speicher geladen werden.

Implementierungsbeispiel

Importieren Sie zunächst die erforderlichen und erforderlichen Pakete wie folgt:

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

In der nächsten Codezeile wird das Gensim-Wörterbuch mithilfe der einzelnen Textdatei mit dem Namen doc.txt erstellt.

dict_STF = corpora.Dictionary(
   simple_preprocess(line, deacc =True) for line in open(‘doc.txt’, encoding=’utf-8’)
)

Lassen Sie uns nun weitere Informationen wie die Anzahl der Token im Wörterbuch abrufen.

print(dict_STF)

Ausgabe

Dictionary(27 unique tokens: ['CNTK', 'Computational', 'Network', 'Toolkit', 'as']...)

Wir können das Wort für die eindeutige Ganzzahlzuordnung auch wie folgt sehen:

print(dict_STF.token2id)

Ausgabe

{
   'CNTK': 0, 'Computational': 1, 'Network': 2, 'Toolkit': 3, 'as': 4, 
   'formerly': 5, 'known': 6, 'a': 7, 'commercial-grade': 8, 'easy-to-use': 9, 
   'free': 10, 'is': 11, 'open-source': 12, 'toolkit': 13, 'algorithms': 14, 
   'brain.': 15, 'deep': 16, 'enable': 17, 'human': 18, 'learn': 19, 
   'learning': 20, 'like': 21, 'that': 22, 'the': 23, 'to': 24, 'train': 25, 'us': 26
}

Vollständiges Implementierungsbeispiel

import gensim
from gensim import corpora
from pprint import pprint
from gensim.utils import simple_preprocess
from smart_open import smart_open
import os
dict_STF = corpora.Dictionary(
   simple_preprocess(line, deacc =True) for line in open(‘doc.txt’, encoding=’utf-8’)
)
dict_STF = corpora.Dictionary(text_tokens)
print(dict_STF.token2id)

Aus mehreren Textdateien

Erstellen wir nun ein Wörterbuch aus mehreren Dateien, dh mehr als einer Textdatei, die im selben Verzeichnis gespeichert ist. Für dieses Beispiel haben wir nämlich drei verschiedene Textdateien erstelltfirst.txt, second.txt und third.txtMit den drei Zeilen aus der Textdatei (doc.txt) haben wir das vorherige Beispiel verwendet. Alle diese drei Textdateien werden in einem Verzeichnis mit dem Namen gespeichertABC.

Implementierungsbeispiel

Um dies zu implementieren, müssen wir eine Klasse mit einer Methode definieren, die alle drei Textdateien (First, Second und Third.txt) im Verzeichnis (ABC) durchlaufen und die verarbeitete Liste der Wort-Token liefern kann.

Definieren wir die benannte Klasse Read_files mit einer Methode namens __iteration__ () wie folgt -

class Read_files(object):
   def __init__(self, directoryname):
      elf.directoryname = directoryname
   def __iter__(self):
      for fname in os.listdir(self.directoryname):
         for line in open(os.path.join(self.directoryname, fname), encoding='latin'):
   yield simple_preprocess(line)

Als nächstes müssen wir den Pfad des Verzeichnisses wie folgt angeben:

path = "ABC"

#provide the path as per your computer system where you saved the directory.

Die nächsten Schritte sind ähnlich wie in den vorherigen Beispielen. In der nächsten Codezeile wird das Gensim-Verzeichnis erstellt, indem das Verzeichnis mit drei Textdateien verwendet wird.

dict_MUL = corpora.Dictionary(Read_files(path))

Ausgabe

Dictionary(27 unique tokens: ['CNTK', 'Computational', 'Network', 'Toolkit', 'as']...)

Jetzt können wir das Wort für die eindeutige Ganzzahlzuordnung auch wie folgt sehen:

print(dict_MUL.token2id)

Ausgabe

{
   'CNTK': 0, 'Computational': 1, 'Network': 2, 'Toolkit': 3, 'as': 4, 
   'formerly': 5, 'known': 6, 'a': 7, 'commercial-grade': 8, 'easy-to-use': 9, 
   'free': 10, 'is': 11, 'open-source': 12, 'toolkit': 13, 'algorithms': 14, 
   'brain.': 15, 'deep': 16, 'enable': 17, 'human': 18, 'learn': 19, 
   'learning': 20, 'like': 21, 'that': 22, 'the': 23, 'to': 24, 'train': 25, 'us': 26
}

Speichern und Laden eines Gensim-Wörterbuchs

Gensim unterstützen ihre eigenen Eingeborenen save() Methode zum Speichern des Wörterbuchs auf der Festplatte und load() Methode zum Zurückladen des Wörterbuchs von der Festplatte.

Zum Beispiel können wir das Wörterbuch mit Hilfe des folgenden Skripts speichern -

Gensim.corpora.dictionary.save(filename)

#provide the path where you want to save the dictionary.

Ebenso können wir das gespeicherte Wörterbuch mithilfe der load () -Methode laden. Das folgende Skript kann dies tun -

Gensim.corpora.dictionary.load(filename)

#provide the path where you have saved the dictionary.

Wir haben verstanden, wie man ein Wörterbuch aus einer Liste von Dokumenten und aus Textdateien (aus einer sowie aus mehreren) erstellt. In diesem Abschnitt erstellen wir nun einen BoW-Korpus (Bag-of-Words). Um mit Gensim arbeiten zu können, ist es eines der wichtigsten Objekte, mit denen wir uns vertraut machen müssen. Grundsätzlich ist es der Korpus, der die Wort-ID und ihre Häufigkeit in jedem Dokument enthält.

BoW Corpus erstellen

Wie bereits erwähnt, enthält der Korpus in Gensim in jedem Dokument das Wort id und seine Häufigkeit. Wir können einen BoW-Korpus aus einer einfachen Liste von Dokumenten und aus Textdateien erstellen. Was wir tun müssen, ist, die tokenisierte Liste von Wörtern an das benannte Objekt zu übergebenDictionary.doc2bow(). Beginnen wir also mit der Erstellung eines BoW-Korpus anhand einer einfachen Liste von Dokumenten.

Aus einer einfachen Liste von Sätzen

Im folgenden Beispiel erstellen wir einen BoW-Korpus aus einer einfachen Liste mit drei Sätzen.

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() objectwie folgt -

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

Endlich können wir Bag of Word Corpus drucken -

print(BoW_corpus)

Ausgabe

[
   [(0, 1), (1, 1), (2, 1), (3, 1)], 
   [(2, 1), (3, 1), (4, 2)], [(0, 2), (3, 3), (5, 2), (6, 1), (7, 2), (8, 1)]
]

Die obige Ausgabe zeigt, dass das Wort mit id = 0 im ersten Dokument einmal vorkommt (weil wir (0,1) in der Ausgabe haben) und so weiter.

Die obige Ausgabe ist für Menschen irgendwie nicht lesbar. Wir können diese IDs auch in Wörter konvertieren, aber dafür benötigen wir unser Wörterbuch, um die Konvertierung wie folgt durchzuführen:

id_words = [[(dictionary[id], count) for id, count in line] for line in BoW_corpus]
print(id_words)

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)]
]

Jetzt ist die obige Ausgabe irgendwie von Menschen lesbar.

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]
print(BoW_corpus)
id_words = [[(dictionary[id], count) for id, count in line] for line in BoW_corpus]
print(id_words)

Aus einer Textdatei

Im folgenden Beispiel erstellen wir einen BoW-Korpus aus einer Textdatei. Zu diesem Zweck haben wir das im vorherigen Beispiel verwendete Dokument in der genannten Textdatei gespeichertdoc.txt..

Gensim liest die Datei zeilenweise und verarbeitet sie zeilenweise mit simple_preprocess. Auf diese Weise muss nicht die gesamte Datei auf einmal in den Speicher geladen werden.

Implementierungsbeispiel

Importieren Sie zunächst die erforderlichen und erforderlichen Pakete wie folgt:

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

In der folgenden Codezeile werden die Dokumente aus doc.txt gelesen und mit einem Token versehen.

doc_tokenized = [
   simple_preprocess(line, deacc =True) for line in open(‘doc.txt’, encoding=’utf-8’)
]
dictionary = corpora.Dictionary()

Jetzt müssen wir diese symbolisierten Wörter weitergeben dictionary.doc2bow() Objekt (wie im vorherigen Beispiel)

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

Ausgabe

[
   [(9, 1), (10, 1), (11, 1), (12, 1), (13, 1), (14, 1), (15, 1)], 
   [
      (15, 1), (16, 1), (17, 1), (18, 1), (19, 1), (20, 1), (21, 1), 
      (22, 1), (23, 1), (24, 1)
   ], 
   [
      (23, 2), (25, 1), (26, 1), (27, 1), (28, 1), (29, 1), 
      (30, 1), (31, 1), (32, 1), (33, 1), (34, 1), (35, 1), (36, 1)
   ], 
   [(3, 1), (18, 1), (37, 1), (38, 1), (39, 1), (40, 1), (41, 1), (42, 1), (43, 1)], 
   [
      (18, 1), (27, 1), (31, 2), (32, 1), (38, 1), (41, 1), (43, 1), 
      (44, 1), (45, 1), (46, 1), (47, 1), (48, 1), (49, 1), (50, 1), (51, 1), (52, 1)
   ]
]

Das doc.txt Datei haben den folgenden Inhalt -

CNTK, früher bekannt als Computational Network Toolkit, ist ein kostenloses, benutzerfreundliches Open-Source-Toolkit für kommerzielle Zwecke, mit dem wir Deep-Learning-Algorithmen trainieren können, um wie das menschliche Gehirn zu lernen.

Das kostenlose Tutorial finden Sie auf tutorialspoint.com. Außerdem finden Sie kostenlos die besten technischen Tutorials zu Technologien wie AI Deep Learning Machine Learning.

Vollständiges Implementierungsbeispiel

import gensim
from gensim import corpora
from pprint import pprint
from gensim.utils import simple_preprocess
from smart_open import smart_open
import os
doc_tokenized = [
   simple_preprocess(line, deacc =True) for line in open(‘doc.txt’, encoding=’utf-8’)
]
dictionary = corpora.Dictionary()
BoW_corpus = [dictionary.doc2bow(doc, allow_update=True) for doc in doc_tokenized]
print(BoW_corpus)

Speichern und Laden eines Gensim-Korpus

Wir können den Korpus mit Hilfe des folgenden Skripts speichern -

corpora.MmCorpus.serialize(‘/Users/Desktop/BoW_corpus.mm’, bow_corpus)

#provide the path and the name of the corpus. The name of corpus is BoW_corpus and we saved it in Matrix Market format.

Ebenso können wir den gespeicherten Korpus mithilfe des folgenden Skripts laden:

corpus_load = corpora.MmCorpus(‘/Users/Desktop/BoW_corpus.mm’)
for line in corpus_load:
print(line)

Dieses Kapitel hilft Ihnen dabei, die verschiedenen Transformationen in Gensim kennenzulernen. Beginnen wir mit dem Verständnis der transformierenden Dokumente.

Dokumente transformieren

Dokumente transformieren bedeutet, das Dokument so darzustellen, dass das Dokument mathematisch bearbeitet werden kann. Neben der Ableitung der latenten Struktur des Korpus dient die Transformation von Dokumenten auch den folgenden Zielen:

• Es entdeckt die Beziehung zwischen Wörtern.

• Es bringt die verborgene Struktur im Korpus zum Vorschein.

• Es beschreibt die Dokumente auf eine neue und semantischere Weise.

• Dadurch wird die Darstellung der Dokumente kompakter.

• Dies verbessert die Effizienz, da neue Darstellungen weniger Ressourcen verbrauchen.

• Dies verbessert die Wirksamkeit, da in neuen Darstellungen Randdatentrends ignoriert werden.

• Das Rauschen wird auch bei der Darstellung neuer Dokumente reduziert.

Sehen wir uns die Implementierungsschritte zum Transformieren der Dokumente von einer Vektorraumdarstellung in eine andere an.

Implementierungsschritte

Um Dokumente zu transformieren, müssen wir die folgenden Schritte ausführen:

Schritt 1: Erstellen des Korpus

Der allererste und grundlegende Schritt besteht darin, den Korpus aus den Dokumenten zu erstellen. Wir haben den Korpus bereits in früheren Beispielen erstellt. Lassen Sie uns ein weiteres mit einigen Verbesserungen erstellen (Entfernen allgemeiner Wörter und der Wörter, die nur einmal vorkommen) -

import gensim
import pprint
from collections import defaultdict
from gensim import corpora

Stellen Sie nun die Dokumente zum Erstellen des Korpus bereit -

t_corpus = ["CNTK, früher bekannt als Computational Network Toolkit", "ist ein kostenloses, benutzerfreundliches Open-Source-Toolkit für kommerzielle Zwecke", "mit dem wir Deep-Learning-Algorithmen trainieren können, um wie das menschliche Gehirn zu lernen.", " Das kostenlose Tutorial finden Sie auf tutorialspoint.com "," Tutorialspoint.com bietet auch die besten technischen Tutorials zu Technologien wie AI Deep Learning Machine Learning kostenlos "]

Als nächstes müssen wir Tokenise machen und zusammen damit werden wir auch die gebräuchlichen Wörter entfernen -

stoplist = set('for a of the and to in'.split(' '))
processed_corpus = [
   [
      word for word in document.lower().split() if word not in stoplist
   ]
	for document in t_corpus
]

Das folgende Skript entfernt nur die Wörter, die angezeigt werden -

frequency = defaultdict(int)
for text in processed_corpus:
   for token in text:
      frequency[token] += 1
   processed_corpus = [
      [token for token in text if frequency[token] > 1] 
      for text in processed_corpus
   ]
pprint.pprint(processed_corpus)

Ausgabe

[
   ['toolkit'],
   ['free', 'toolkit'],
   ['deep', 'learning', 'like'],
   ['free', 'on', 'tutorialspoint.com'],
   ['tutorialspoint.com', 'on', 'like', 'deep', 'learning', 'learning', 'free']
]

Jetzt gib es an die corpora.dictionary() Objekt, um die einzigartigen Objekte in unserem Korpus zu erhalten -

dictionary = corpora.Dictionary(processed_corpus)
print(dictionary)

Ausgabe

Dictionary(7 unique tokens: ['toolkit', 'free', 'deep', 'learning', 'like']...)

Als nächstes erstellt die folgende Codezeile das Bag of Word-Modell für unseren Korpus -

BoW_corpus = [dictionary.doc2bow(text) for text in processed_corpus]
pprint.pprint(BoW_corpus)

Ausgabe

[
   [(0, 1)],
   [(0, 1), (1, 1)],
   [(2, 1), (3, 1), (4, 1)],
   [(1, 1), (5, 1), (6, 1)],
   [(1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1)]
]

Schritt 2: Erstellen einer Transformation

Die Transformationen sind einige Standard-Python-Objekte. Wir können diese Transformationen, dh Python-Objekte, mithilfe eines trainierten Korpus initialisieren. Hier werden wir verwendentf-idf Modell, um eine Transformation unseres trainierten Korpus zu schaffen, dh BoW_corpus.

Zuerst müssen wir das Modellpaket von gensim importieren.

from gensim import models

Jetzt müssen wir das Modell wie folgt initialisieren:

tfidf = models.TfidfModel(BoW_corpus)

Schritt 3: Transformieren von Vektoren

In diesem letzten Schritt werden die Vektoren von der alten Darstellung in die neue Darstellung konvertiert. Da wir das tfidf-Modell im obigen Schritt initialisiert haben, wird das tfidf nun als schreibgeschütztes Objekt behandelt. Hier konvertieren wir mit diesem tfidf-Objekt unseren Vektor von einer Tasche mit Wortdarstellung (alte Darstellung) in Tfidf-Realwerte (neue Darstellung).

doc_BoW = [(1,1),(3,1)]
print(tfidf[doc_BoW]

Ausgabe

[(1, 0.4869354917707381), (3, 0.8734379353188121)]

Wir haben die Transformation auf zwei Korpuswerte angewendet, können sie aber auch wie folgt auf den gesamten Korpus anwenden:

corpus_tfidf = tfidf[BoW_corpus]
for doc in corpus_tfidf:
   print(doc)

Ausgabe

[(0, 1.0)]
[(0, 0.8734379353188121), (1, 0.4869354917707381)]
[(2, 0.5773502691896257), (3, 0.5773502691896257), (4, 0.5773502691896257)]
[(1, 0.3667400603126873), (5, 0.657838022678017), (6, 0.657838022678017)]
[
   (1, 0.19338287240886842), (2, 0.34687949360312714), (3, 0.6937589872062543), 
   (4, 0.34687949360312714), (5, 0.34687949360312714), (6, 0.34687949360312714)
]

Vollständiges Implementierungsbeispiel

import gensim
import pprint
from collections import defaultdict
from gensim import corpora
t_corpus = [
   "CNTK formerly known as Computational Network Toolkit", 
   "is a free easy-to-use open-source commercial-grade toolkit", 
   "that enable us to train deep learning algorithms to learn like the human brain.", 
   "You can find its free tutorial on tutorialspoint.com", 
   "Tutorialspoint.com also provide best technical tutorials on 
   technologies like AI deep learning machine learning for free"
]
stoplist = set('for a of the and to in'.split(' '))
processed_corpus = [
   [word for word in document.lower().split() if word not in stoplist]
   for document in t_corpus
]
frequency = defaultdict(int)
for text in processed_corpus:
   for token in text:
      frequency[token] += 1
   processed_corpus = [
      [token for token in text if frequency[token] > 1] 
      for text in processed_corpus
   ]
pprint.pprint(processed_corpus)
dictionary = corpora.Dictionary(processed_corpus)
print(dictionary)
BoW_corpus = [dictionary.doc2bow(text) for text in processed_corpus]
pprint.pprint(BoW_corpus)
   from gensim import models
   tfidf = models.TfidfModel(BoW_corpus)
   doc_BoW = [(1,1),(3,1)]
   print(tfidf[doc_BoW])
   corpus_tfidf = tfidf[BoW_corpus]
   for doc in corpus_tfidf:
print(doc)

Verschiedene Transformationen in Gensim

Mit Gensim können wir verschiedene gängige Transformationen implementieren, dh Vector Space Model-Algorithmen. Einige von ihnen sind wie folgt -

Tf-Idf (Term Frequenz-Inverse Dokumentfrequenz)

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 andere 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. Es folgt die Syntax der Tf-idf-Transformation -

Model=models.TfidfModel(corpus, normalize=True)

LSI (Latent Semantic Indexing)

Der LSI-Modellalgorithmus kann Dokumente entweder aus einem ganzzahligen Vektormodell (z. B. einem Bag-of-Words-Modell) oder einem Tf-Idf-gewichteten Raum in einen latenten Raum umwandeln. Der Ausgabevektor hat eine geringere Dimensionalität. Es folgt die Syntax der LSI-Transformation:

Model=models.LsiModel(tfidf_corpus, id2word=dictionary, num_topics=300)

LDA (Latent Dirichlet Allocation)

Der LDA-Modellalgorithmus ist ein weiterer Algorithmus, der Dokumente aus dem Bag-of-Words-Modellraum in einen Themenraum umwandelt. Der Ausgabevektor ist von geringerer Dimensionalität. Es folgt die Syntax der LSI-Transformation:

Model=models.LdaModel(corpus, id2word=dictionary, num_topics=100)

Zufällige Projektionen (RP)

RP, ein sehr effizienter Ansatz, zielt darauf ab, die Dimensionalität des Vektorraums zu reduzieren. Dieser Ansatz entspricht im Wesentlichen den Tf-Idf-Abständen zwischen den Dokumenten. Dies geschieht durch ein wenig Zufälligkeit.

Model=models.RpModel(tfidf_corpus, num_topics=500)

Hierarchischer Dirichlet-Prozess (HDP)

HDP ist eine nicht parametrische Bayes'sche Methode, die neu in Gensim ist. Wir sollten vorsichtig sein müssen, wenn wir es benutzen.

Model=models.HdpModel(corpus, id2word=dictionary

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 Wortsackmodell 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.

Dieses Kapitel befasst sich mit der Themenmodellierung in Bezug auf Gensim.

Um unsere Daten zu kommentieren und die Satzstruktur zu verstehen, besteht eine der besten Methoden darin, rechnergestützte sprachliche Algorithmen zu verwenden. Zweifellos können wir mit Hilfe dieser rechnergestützten Sprachalgorithmen einige feinere Details über unsere Daten verstehen, aber

• Können wir wissen, welche Wörter in unserem Korpus häufiger vorkommen als andere?

• Können wir unsere Daten gruppieren?

• Können wir unseren Daten zugrunde liegende Themen sein?

All dies könnten wir mit Hilfe der Themenmodellierung erreichen. Tauchen wir also tief in das Konzept der Themenmodelle ein.

Was sind Themenmodelle?

Ein Themenmodell kann als Wahrscheinlichkeitsmodell definiert werden, das Informationen zu Themen in unserem Text enthält. Hier stellen sich jedoch zwei wichtige Fragen:

Zuerst, what exactly a topic is?

Das Thema sind, wie der Name schon sagt, zugrunde liegende Ideen oder die in unserem Text dargestellten Themen. Um Ihnen ein Beispiel zu geben, enthält der Korpusnewspaper articles hätte die Themen im Zusammenhang mit finance, weather, politics, sports, various states news und so weiter.

Zweite, what is the importance of topic models in text processing?

Da wir wissen, dass wir, um Ähnlichkeiten im Text zu identifizieren, mithilfe von Wörtern Informationen abrufen und suchen können. Mithilfe von Themenmodellen können wir unsere Textdateien jetzt nach Themen und nicht nach Wörtern suchen und anordnen.

In diesem Sinne können wir sagen, dass Themen die probabilistische Verteilung von Wörtern sind. Aus diesem Grund können wir mithilfe von Themenmodellen unsere Dokumente als probabilistische Verteilung von Themen beschreiben.

Ziele von Themenmodellen

Wie oben erläutert, liegt der Schwerpunkt der Themenmodellierung auf zugrunde liegenden Ideen und Themen. Seine Hauptziele sind wie folgt:

• Themenmodelle können zur Textzusammenfassung verwendet werden.

• Sie können zum Organisieren der Dokumente verwendet werden. Zum Beispiel können wir die Themenmodellierung verwenden, um Nachrichtenartikel in einem organisierten / miteinander verbundenen Abschnitt zusammenzufassen, z. B. um alle Nachrichtenartikel zu organisieren, die sich auf diese beziehencricket.

• Sie können das Suchergebnis verbessern. Wie? Bei einer Suchabfrage können wir Themenmodelle verwenden, um das Dokument mit einer Mischung aus verschiedenen Schlüsselwörtern anzuzeigen, die jedoch ungefähr dieselbe Idee haben.

• Das Konzept der Empfehlungen ist sehr nützlich für das Marketing. Es wird von verschiedenen Online-Shopping-Websites, Nachrichten-Websites und vielem mehr verwendet. Themenmodelle helfen dabei, Empfehlungen zu geben, was zu kaufen ist, was als nächstes zu lesen ist usw. Sie tun dies, indem sie Materialien finden, die ein gemeinsames Thema in der Liste haben.

Themenmodellierungsalgorithmen in Gensim

Zweifellos ist Gensim das beliebteste Toolkit zur Themenmodellierung. Die kostenlose Verfügbarkeit und die Verfügbarkeit in Python machen es immer beliebter. In diesem Abschnitt werden einige der beliebtesten Algorithmen zur Themenmodellierung erläutert. Hier konzentrieren wir uns eher auf das Was als auf das Wie, weil Gensim sie für uns sehr gut abstrahiert.

Latent Dirichlet Allocation (LDA)

Latent Dirichlet Allocation (LDA) ist die häufigste und beliebteste Technik, die derzeit für die Themenmodellierung verwendet wird. Es ist das, was die Facebook-Forscher in ihrem 2013 veröffentlichten Forschungspapier verwendet haben. Es wurde erstmals 2003 von David Blei, Andrew Ng und Michael Jordan vorgeschlagen. Sie schlugen LDA in ihrem einfach betitelten Papier vorLatent Dirichlet allocation.

Eigenschaften von LDA

Lassen Sie uns mehr über diese wunderbare Technik durch ihre Eigenschaften wissen -

Probabilistic topic modeling technique

LDA ist eine probabilistische Themenmodellierungstechnik. Wie oben erläutert, gehen wir bei der Themenmodellierung davon aus, dass in jeder Sammlung miteinander verbundener Dokumente (z. B. wissenschaftliche Artikel, Zeitungsartikel, Facebook-Beiträge, Tweets, E-Mails usw.) einige Kombinationen von Themen in jedem Dokument enthalten sind .

Das Hauptziel der probabilistischen Themenmodellierung besteht darin, die verborgene Themenstruktur für die Sammlung miteinander verbundener Dokumente zu entdecken. Die folgenden drei Dinge sind im Allgemeinen in einer Themenstruktur enthalten:

• Topics

• Statistische Verteilung der Themen auf die Dokumente

• Wörter in einem Dokument, das das Thema umfasst

Work in an unsupervised way

LDA arbeitet unbeaufsichtigt. Dies liegt daran, dass LDA bedingte Wahrscheinlichkeiten verwendet, um die verborgene Themenstruktur zu ermitteln. Es wird davon ausgegangen, dass die Themen in der Sammlung miteinander verbundener Dokumente ungleich verteilt sind.

Very easy to create it in Gensim

In Gensim ist es sehr einfach, ein LDA-Modell zu erstellen. Wir müssen nur den Korpus, die Wörterbuchzuordnung und die Anzahl der Themen angeben, die wir in unserem Modell verwenden möchten.

Model=models.LdaModel(corpus, id2word=dictionary, num_topics=100)

May face computationally intractable problem

Die Berechnung der Wahrscheinlichkeit jeder möglichen Themenstruktur ist eine rechnerische Herausforderung für die LDA. Es ist eine Herausforderung, weil es die Wahrscheinlichkeit jedes beobachteten Wortes unter jeder möglichen Themenstruktur berechnen muss. Wenn wir eine große Anzahl von Themen und Wörtern haben, kann LDA mit rechnerisch unlösbaren Problemen konfrontiert sein.

Latent Semantic Indexing (LSI)

Die Themenmodellierungsalgorithmen, die erstmals in Gensim mit implementiert wurden Latent Dirichlet Allocation (LDA) ist Latent Semantic Indexing (LSI). Es wird auch genanntLatent Semantic Analysis (LSA).

Es wurde 1988 von Scott Deerwester, Susan Dumais, George Furnas, Richard Harshman, Thomas Landaur, Karen Lochbaum und Lynn Streeter patentiert. In diesem Abschnitt werden wir unser LSI-Modell einrichten. Dies kann auf die gleiche Weise wie beim Einrichten des LDA-Modells erfolgen. Wir müssen das LSI-Modell aus importierengensim.models.

Rolle von LSI

Tatsächlich ist LSI eine NLP-Technik, insbesondere in der Verteilungssemantik. Es analysiert die Beziehung zwischen einer Reihe von Dokumenten und den Begriffen, die diese Dokumente enthalten. Wenn wir über seine Funktionsweise sprechen, erstellt es eine Matrix, die aus einem großen Textstück die Anzahl der Wörter pro Dokument enthält.

Nach der Erstellung verwendet das LSI-Modell eine mathematische Technik, die als Singular Value Decomposition (SVD) bezeichnet wird, um die Anzahl der Zeilen zu verringern. Neben der Reduzierung der Anzahl der Zeilen bleibt auch die Ähnlichkeitsstruktur zwischen den Spalten erhalten. In der Matrix repräsentieren die Zeilen eindeutige Wörter und die Spalten jedes Dokument. Es funktioniert basierend auf einer Verteilungshypothese, dh es wird angenommen, dass die Wörter, deren Bedeutung nahe beieinander liegt, in derselben Art von Text vorkommen.

Model=models.LsiModel(corpus, id2word=dictionary, num_topics=100)

Hierarchischer Dirichlet-Prozess (HDP)

Themenmodelle wie LDA und LSI helfen bei der Zusammenfassung und Organisation großer Textarchive, die nicht von Hand analysiert werden können. Neben LDA und LSI ist HDP (Hierarchical Dirichlet Process) ein weiteres leistungsstarkes Themenmodell in Gensim. Grundsätzlich handelt es sich um ein Modell mit gemischter Mitgliedschaft für die unbeaufsichtigte Analyse gruppierter Daten. Im Gegensatz zu LDA (dem endlichen Gegenstück) leitet HDP die Anzahl der Themen aus den Daten ab.

Model=models.HdpModel(corpus, id2word=dictionary

In diesem Kapitel erfahren Sie, wie Sie ein LDA-Themenmodell (Latent Dirichlet Allocation) in Gensim erstellen.

Automatisches Extrahieren von Informationen zu Themen aus einer großen Anzahl von Texten in einer der Hauptanwendungen von NLP (Natural Language Processing). Eine große Anzahl von Texten kann Feeds aus Hotelbewertungen, Tweets, Facebook-Posts, Feeds aus anderen Social-Media-Kanälen, Filmkritiken, Nachrichten, Benutzer-Feedbacks, E-Mails usw. sein.

In diesem digitalen Zeitalter kann es für Unternehmen, politische Kampagnen und Administratoren von großem Wert sein, zu wissen, worüber Menschen / Kunden sprechen, ihre Meinungen und Probleme zu verstehen. Aber ist es möglich, so große Textmengen manuell durchzulesen und dann die Informationen aus Themen zu extrahieren?

Nein, ist es nicht. Es erfordert einen automatischen Algorithmus, der diese große Menge an Textdokumenten lesen und automatisch die erforderlichen Informationen / Themen daraus extrahieren kann.

Rolle der LDA

Der Ansatz von LDA zur Themenmodellierung besteht darin, Text in einem Dokument einem bestimmten Thema zuzuordnen. Als Dirichlet-Distribution modelliert, baut LDA -

• Ein Thema pro Dokumentmodell und
• Wörter pro Themenmodell

Nachdem der LDA-Themenmodellalgorithmus bereitgestellt wurde, ordnet er Folgendes neu an, um eine gute Zusammensetzung der Verteilung der Themenschlüsselwörter zu erhalten.

• Die Themenverteilungen innerhalb des Dokuments und
• Schlüsselwortverteilung innerhalb der Themen

Während der Verarbeitung sind einige der von LDA getroffenen Annahmen:

• Jedes Dokument wird als Multi-Nominal-Verteilung von Themen modelliert.
• Jedes Thema wird als multinominale Wortverteilung modelliert.
• Wir sollten den richtigen Datenbestand auswählen müssen, da LDA davon ausgeht, dass jeder Textabschnitt die zugehörigen Wörter enthält.
• LDA geht auch davon aus, dass die Dokumente aus einer Mischung von Themen erstellt werden.

Implementierung mit Gensim

Hier werden wir LDA (Latent Dirichlet Allocation) verwenden, um die natürlich diskutierten Themen aus dem Datensatz zu extrahieren.

Datensatz wird geladen

Der Datensatz, den wir verwenden werden, ist der Datensatz von ’20 Newsgroups’mit Tausenden von Nachrichtenartikeln aus verschiedenen Abschnitten eines Nachrichtenberichts. Es ist verfügbar unterSklearnDatensätze. Wir können einfach mit Hilfe des folgenden Python-Skripts herunterladen -

from sklearn.datasets import fetch_20newsgroups
newsgroups_train = fetch_20newsgroups(subset='train')

Schauen wir uns einige der Beispielnachrichten mit Hilfe des folgenden Skripts an:

newsgroups_train.data[:4]

["From: [email protected] (where's my thing)\nSubject: 
WHAT car is this!?\nNntp-Posting-Host: rac3.wam.umd.edu\nOrganization: 
University of Maryland, College Park\nLines: 
15\n\n I was wondering if anyone out there could enlighten me on this car 
I saw\nthe other day. It was a 2-door sports car, looked to be from the 
late 60s/\nearly 70s. It was called a Bricklin. The doors were really small. 
In addition,\nthe front bumper was separate from the rest of the body. 
This is \nall I know. If anyone can tellme a model name, 
engine specs, years\nof production, where this car is made, history, or 
whatever info you\nhave on this funky looking car, please e-mail.\n\nThanks,
\n- IL\n ---- brought to you by your neighborhood Lerxst ----\n\n\n\n\n",

"From: [email protected] (Guy Kuo)\nSubject: SI Clock Poll - Final 
Call\nSummary: Final call for SI clock reports\nKeywords: 
SI,acceleration,clock,upgrade\nArticle-I.D.: shelley.1qvfo9INNc3s\nOrganization: 
University of Washington\nLines: 11\nNNTP-Posting-Host: carson.u.washington.edu\n\nA 
fair number of brave souls who upgraded their SI clock oscillator have\nshared their 
experiences for this poll. Please send a brief message detailing\nyour experiences with 
the procedure. Top speed attained, CPU rated speed,\nadd on cards and adapters, heat 
sinks, hour of usage per day, floppy disk\nfunctionality with 800 and 1.4 m floppies 
are especially requested.\n\nI will be summarizing in the next two days, so please add 
to the network\nknowledge base if you have done the clock upgrade and haven't answered 
this\npoll. Thanks.\n\nGuy Kuo <;[email protected]>\n",

'From: [email protected] (Thomas E Willis)\nSubject: 
PB questions...\nOrganization: Purdue University Engineering 
Computer Network\nDistribution: usa\nLines: 36\n\nwell folks, 
my mac plus finally gave up the ghost this weekend after\nstarting 
life as a 512k way back in 1985. sooo, i\'m in the market for 
a\nnew machine a bit sooner than i intended to be...\n\ni\'m looking 
into picking up a powerbook 160 or maybe 180 and have a bunch\nof 
questions that (hopefully) somebody can answer:\n\n* does anybody 
know any dirt on when the next round of powerbook\nintroductions 
are expected? i\'d heard the 185c was supposed to make an\nappearence 
"this summer" but haven\'t heard anymore on it - and since i\ndon\'t 
have access to macleak, i was wondering if anybody out there had\nmore 
info...\n\n* has anybody heard rumors about price drops to the powerbook 
line like the\nones the duo\'s just went through recently?\n\n* what\'s 
the impression of the display on the 180? i could probably swing\na 180 
if i got the 80Mb disk rather than the 120, but i don\'t really have\na 
feel for how much "better" the display is (yea, it looks great in the\nstore, 
but is that all "wow" or is it really that good?). could i solicit\nsome 
opinions of people who use the 160 and 180 day-to-day on if its
worth\ntaking the disk size and money hit to get the active display? 
(i realize\nthis is a real subjective question, but i\'ve only played around 
with the\nmachines in a computer store breifly and figured the opinions 
of somebody\nwho actually uses the machine daily might prove helpful).\n\n* 
how well does hellcats perform? ;)\n\nthanks a bunch in advance for any info - 
if you could email, i\'ll post a\nsummary (news reading time is at a premium 
with finals just around the\ncorner... :
( )\n--\nTom Willis \\ [email protected] \\ Purdue Electrical 
Engineering\n---------------------------------------------------------------------------\
n"Convictions are more dangerous enemies of truth than lies." - F. W.\nNietzsche\n',

'From: jgreen@amber (Joe Green)\nSubject: Re: Weitek P9000 ?\nOrganization: 
Harris Computer Systems Division\nLines: 14\nDistribution: world\nNNTP-Posting-Host: 
amber.ssd.csd.harris.com\nX-Newsreader: TIN [version 1.1 PL9]\n\nRobert 
J.C. Kyanko ([email protected]) wrote:\n >[email protected] writes in article 
<[email protected] >:\n> > Anyone know about the 
Weitek P9000 graphics chip?\n > As far as the low-level stuff goes, it looks 
pretty nice. It\'s got this\n> quadrilateral fill command that requires just 
the four points.\n\nDo you have Weitek\'s address/phone number? I\'d like to get 
some information\nabout this chip.\n\n--\nJoe Green\t\t\t\tHarris 
Corporation\[email protected]\t\t\tComputer Systems Division\n"The only 
thing that really scares me is a person with no sense of humor.
"\n\t\t\t\t\t\t-- Jonathan Winters\n']

Voraussetzung

Wir brauchen Stoppwörter von NLTK und ein englisches Modell von Scapy. Beide können wie folgt heruntergeladen werden:

import nltk;
nltk.download('stopwords')
nlp = spacy.load('en_core_web_md', disable=['parser', 'ner'])

Notwendige Pakete importieren

Um ein LDA-Modell zu erstellen, müssen wir das folgende erforderliche Paket importieren:

import re
import numpy as np
import pandas as pd
from pprint import pprint
import gensim
import gensim.corpora as corpora
from gensim.utils import simple_preprocess
from gensim.models import CoherenceModel
import spacy
import pyLDAvis
import pyLDAvis.gensim
import matplotlib.pyplot as plt

Stoppwörter vorbereiten

Jetzt müssen wir die Stoppwörter importieren und verwenden -

from nltk.corpus import stopwords
stop_words = stopwords.words('english')
stop_words.extend(['from', 'subject', 're', 'edu', 'use'])

Bereinigen Sie den Text

Nun, mit Hilfe von Gensim simple_preprocess()Wir müssen jeden Satz in eine Liste von Wörtern umwandeln. Wir sollten auch die Interpunktionen und unnötigen Zeichen entfernen. Zu diesem Zweck erstellen wir eine Funktion mit dem Namensent_to_words() - -

def sent_to_words(sentences):
   for sentence in sentences:
      yield(gensim.utils.simple_preprocess(str(sentence), deacc=True))
data_words = list(sent_to_words(data))

Erstellen von Bigram- und Trigram-Modellen

Wie wir wissen, sind Bigramme zwei Wörter, die im Dokument häufig zusammen vorkommen, und Trigramm sind drei Wörter, die im Dokument häufig zusammen vorkommen. Mit Hilfe von GensimPhrases Modell können wir das tun -

bigram = gensim.models.Phrases(data_words, min_count=5, threshold=100)
trigram = gensim.models.Phrases(bigram[data_words], threshold=100)
bigram_mod = gensim.models.phrases.Phraser(bigram)
trigram_mod = gensim.models.phrases.Phraser(trigram)

Stoppwörter herausfiltern

Als nächstes müssen wir die Stoppwörter herausfiltern. Daneben werden wir auch Funktionen zur Herstellung von Bigrams, Trigrammen und zur Lemmatisierung erstellen -

def remove_stopwords(texts):
   return [[word for word in simple_preprocess(str(doc))
if word not in stop_words] for doc in texts]
def make_bigrams(texts):
   return [bigram_mod[doc] for doc in texts]
def make_trigrams(texts):
   return [trigram_mod[bigram_mod[doc]] for doc in texts]
def lemmatization(texts, allowed_postags=['NOUN', 'ADJ', 'VERB', 'ADV']):
   texts_out = []
   for sent in texts:
     doc = nlp(" ".join(sent))
     texts_out.append([token.lemma_ for token in doc if token.pos_ in allowed_postags])
   return texts_out

Erstellen von Wörterbuch und Korpus für das Themenmodell

Wir müssen jetzt das Wörterbuch und den Korpus erstellen. Wir haben es auch in den vorherigen Beispielen gemacht -

id2word = corpora.Dictionary(data_lemmatized)
texts = data_lemmatized
corpus = [id2word.doc2bow(text) for text in texts]

Erstellen eines LDA-Themenmodells

Wir haben bereits alles implementiert, was zum Trainieren des LDA-Modells erforderlich ist. Jetzt ist es an der Zeit, das LDA-Themenmodell zu erstellen. Für unser Implementierungsbeispiel kann dies mithilfe der folgenden Codezeile erfolgen:

lda_model = gensim.models.ldamodel.LdaModel(
   corpus=corpus, id2word=id2word, num_topics=20, random_state=100, 
   update_every=1, chunksize=100, passes=10, alpha='auto', per_word_topics=True
)

Implementierungsbeispiel

Sehen wir uns das vollständige Implementierungsbeispiel zum Erstellen eines LDA-Themenmodells an.

import re
import numpy as np
import pandas as pd
from pprint import pprint
import gensim
import gensim.corpora as corpora
from gensim.utils import simple_preprocess
from gensim.models import CoherenceModel
import spacy
import pyLDAvis
import pyLDAvis.gensim
import matplotlib.pyplot as plt
from nltk.corpus import stopwords
stop_words = stopwords.words('english')
stop_words.extend(['from', 'subject', 're', 'edu', 'use'])
from sklearn.datasets import fetch_20newsgroups
newsgroups_train = fetch_20newsgroups(subset='train')
data = newsgroups_train.data
data = [re.sub('\S*@\S*\s?', '', sent) for sent in data]
data = [re.sub('\s+', ' ', sent) for sent in data]
data = [re.sub("\'", "", sent) for sent in data]
print(data_words[:4]) #it will print the data after prepared for stopwords
bigram = gensim.models.Phrases(data_words, min_count=5, threshold=100)
trigram = gensim.models.Phrases(bigram[data_words], threshold=100)
bigram_mod = gensim.models.phrases.Phraser(bigram)
trigram_mod = gensim.models.phrases.Phraser(trigram)
def remove_stopwords(texts):
   return [[word for word in simple_preprocess(str(doc)) 
   if word not in stop_words] for doc in texts]
def make_bigrams(texts):
   return [bigram_mod[doc] for doc in texts]
def make_trigrams(texts):
   [trigram_mod[bigram_mod[doc]] for doc in texts]
def lemmatization(texts, allowed_postags=['NOUN', 'ADJ', 'VERB', 'ADV']):
   texts_out = []
   for sent in texts:
      doc = nlp(" ".join(sent))
      texts_out.append([token.lemma_ for token in doc if token.pos_ in allowed_postags])
   return texts_out
data_words_nostops = remove_stopwords(data_words)
data_words_bigrams = make_bigrams(data_words_nostops)
nlp = spacy.load('en_core_web_md', disable=['parser', 'ner'])
data_lemmatized = lemmatization(data_words_bigrams, allowed_postags=[
   'NOUN', 'ADJ', 'VERB', 'ADV'
])
print(data_lemmatized[:4]) #it will print the lemmatized data.
id2word = corpora.Dictionary(data_lemmatized)
texts = data_lemmatized
corpus = [id2word.doc2bow(text) for text in texts]
print(corpus[:4]) #it will print the corpus we created above.
[[(id2word[id], freq) for id, freq in cp] for cp in corpus[:4]] 
#it will print the words with their frequencies.
lda_model = gensim.models.ldamodel.LdaModel(
   corpus=corpus, id2word=id2word, num_topics=20, random_state=100, 
   update_every=1, chunksize=100, passes=10, alpha='auto', per_word_topics=True
)

Wir können jetzt das oben erstellte LDA-Modell verwenden, um die Themen abzurufen und die Modell-Ratlosigkeit zu berechnen.

In diesem Kapitel erfahren Sie, wie Sie das Themenmodell Latent Dirichlet Allocation (LDA) verwenden.

Anzeigen von Themen im LDA-Modell

Das oben erstellte LDA-Modell (lda_model) kann verwendet werden, um die Themen aus den Dokumenten anzuzeigen. Dies kann mit Hilfe des folgenden Skripts erfolgen:

pprint(lda_model.print_topics())
doc_lda = lda_model[corpus]

Ausgabe

[
   (0, 
   '0.036*"go" + 0.027*"get" + 0.021*"time" + 0.017*"back" + 0.015*"good" + '
   '0.014*"much" + 0.014*"be" + 0.013*"car" + 0.013*"well" + 0.013*"year"'),
   (1,
   '0.078*"screen" + 0.067*"video" + 0.052*"character" + 0.046*"normal" + '
   '0.045*"mouse" + 0.034*"manager" + 0.034*"disease" + 0.031*"processor" + '
   '0.028*"excuse" + 0.028*"choice"'),
   (2,
   '0.776*"ax" + 0.079*"_" + 0.011*"boy" + 0.008*"ticket" + 0.006*"red" + '
   '0.004*"conservative" + 0.004*"cult" + 0.004*"amazing" + 0.003*"runner" + '
   '0.003*"roughly"'),
   (3,
   '0.086*"season" + 0.078*"fan" + 0.072*"reality" + 0.065*"trade" + '
   '0.045*"concept" + 0.040*"pen" + 0.028*"blow" + 0.025*"improve" + '
   '0.025*"cap" + 0.021*"penguin"'),
   (4,
   '0.027*"group" + 0.023*"issue" + 0.016*"case" + 0.016*"cause" + '
   '0.014*"state" + 0.012*"whole" + 0.012*"support" + 0.011*"government" + '
   '0.010*"year" + 0.010*"rate"'),
   (5,
   '0.133*"evidence" + 0.047*"believe" + 0.044*"religion" + 0.042*"belief" + '
   '0.041*"sense" + 0.041*"discussion" + 0.034*"atheist" + 0.030*"conclusion" +
   '
   '0.029*"explain" + 0.029*"claim"'),
   (6,
   '0.083*"space" + 0.059*"science" + 0.031*"launch" + 0.030*"earth" + '
   '0.026*"route" + 0.024*"orbit" + 0.024*"scientific" + 0.021*"mission" + '
   '0.018*"plane" + 0.017*"satellite"'),
   (7,
   '0.065*"file" + 0.064*"program" + 0.048*"card" + 0.041*"window" + '
   '0.038*"driver" + 0.037*"software" + 0.034*"run" + 0.029*"machine" + '
   '0.029*"entry" + 0.028*"version"'),
   (8,
   '0.078*"publish" + 0.059*"mount" + 0.050*"turkish" + 0.043*"armenian" + '
   '0.027*"western" + 0.026*"russian" + 0.025*"locate" + 0.024*"proceed" + '
   '0.024*"electrical" + 0.022*"terrorism"'),
   (9,
   '0.023*"people" + 0.023*"child" + 0.021*"kill" + 0.020*"man" + 0.019*"death" '
   '+ 0.015*"die" + 0.015*"live" + 0.014*"attack" + 0.013*"age" + '
   '0.011*"church"'),
   (10,
   '0.092*"cpu" + 0.085*"black" + 0.071*"controller" + 0.039*"white" + '
   '0.028*"water" + 0.027*"cold" + 0.025*"solid" + 0.024*"cool" + 0.024*"heat" '
   '+ 0.023*"nuclear"'),
   (11,
   '0.071*"monitor" + 0.044*"box" + 0.042*"option" + 0.041*"generate" + '
   '0.038*"vote" + 0.032*"battery" + 0.029*"wave" + 0.026*"tradition" + '
   '0.026*"fairly" + 0.025*"task"'),
   (12,
   '0.048*"send" + 0.045*"mail" + 0.036*"list" + 0.033*"include" + '
   '0.032*"price" + 0.031*"address" + 0.027*"email" + 0.026*"receive" + '
   '0.024*"book" + 0.024*"sell"'),
   (13,
   '0.515*"drive" + 0.052*"laboratory" + 0.042*"blind" + 0.020*"investment" + '
   '0.011*"creature" + 0.010*"loop" + 0.005*"dialog" + 0.000*"slave" + '
   '0.000*"jumper" + 0.000*"sector"'),
   (14,
   '0.153*"patient" + 0.066*"treatment" + 0.062*"printer" + 0.059*"doctor" + '

   '0.036*"medical" + 0.031*"energy" + 0.029*"study" + 0.029*"probe" + '
   '0.024*"mph" + 0.020*"physician"'),
   (15,
   '0.068*"law" + 0.055*"gun" + 0.039*"government" + 0.036*"right" + '
   '0.029*"state" + 0.026*"drug" + 0.022*"crime" + 0.019*"person" + '
   '0.019*"citizen" + 0.019*"weapon"'),
   (16,
   '0.107*"team" + 0.102*"game" + 0.078*"play" + 0.055*"win" + 0.052*"player" + '
   '0.051*"year" + 0.030*"score" + 0.025*"goal" + 0.023*"wing" + 0.023*"run"'),
   (17,
   '0.031*"say" + 0.026*"think" + 0.022*"people" + 0.020*"make" + 0.017*"see" + '
   '0.016*"know" + 0.013*"come" + 0.013*"even" + 0.013*"thing" + 0.013*"give"'),
   (18,
   '0.039*"system" + 0.034*"use" + 0.023*"key" + 0.016*"bit" + 0.016*"also" + '
   '0.015*"information" + 0.014*"source" + 0.013*"chip" + 0.013*"available" + '
   '0.010*"provide"'),
   (19,
   '0.085*"line" + 0.073*"write" + 0.053*"article" + 0.046*"organization" + '
   '0.034*"host" + 0.023*"be" + 0.023*"know" + 0.017*"thank" + 0.016*"want" + '
   '0.014*"help"')
]

Rechenmodell Ratlosigkeit

Das oben erstellte LDA-Modell (lda_model) kann verwendet werden, um die Ratlosigkeit des Modells zu berechnen, dh wie gut das Modell ist. Je niedriger die Punktzahl, desto besser wird das Modell. Dies kann mit Hilfe des folgenden Skripts erfolgen:

print('\nPerplexity: ', lda_model.log_perplexity(corpus))

Ausgabe

Perplexity: -12.338664984332151

Berechnung des Kohärenzwerts

Das LDA-Modell (lda_model)Wir haben oben erstellt, dass der Kohärenzwert des Modells berechnet werden kann, dh der Durchschnitt / Median der paarweisen Wortähnlichkeitswerte der Wörter im Thema. Dies kann mit Hilfe des folgenden Skripts erfolgen:

coherence_model_lda = CoherenceModel(
   model=lda_model, texts=data_lemmatized, dictionary=id2word, coherence='c_v'
)
coherence_lda = coherence_model_lda.get_coherence()
print('\nCoherence Score: ', coherence_lda)

Ausgabe

Coherence Score: 0.510264381411751

Visualisierung der Topics-Keywords

Das LDA-Modell (lda_model)Wir haben oben erstellt, um die produzierten Themen und die zugehörigen Schlüsselwörter zu untersuchen. Es kann mit visualisiert werdenpyLDAvisPaket wie folgt -

pyLDAvis.enable_notebook()
vis = pyLDAvis.gensim.prepare(lda_model, corpus, id2word)
vis

Ausgabe

Aus der obigen Ausgabe geht hervor, dass die Blasen auf der linken Seite ein Thema darstellen. Je größer die Blase, desto häufiger ist dieses Thema. Das Themenmodell ist gut, wenn das Themenmodell große, nicht überlappende Blasen im Diagramm verteilt hat.

In diesem Kapitel wird erläutert, was ein LDA-Mallet-Modell (Latent Dirichlet Allocation) ist und wie Sie dasselbe in Gensim erstellen.

Im vorherigen Abschnitt haben wir das LDA-Modell implementiert und die Themen aus Dokumenten des 20Newsgroup-Datasets abgerufen. Das war Gensims eingebaute Version des LDA-Algorithmus. Es gibt auch eine Mallet-Version von Gensim, die eine bessere Qualität der Themen bietet. Hier wenden wir Mallets LDA auf das vorherige Beispiel an, das wir bereits implementiert haben.

Was ist das LDA Mallet-Modell?

Mallet, ein Open-Source-Toolkit, wurde von Andrew McCullum geschrieben. Es handelt sich im Grunde genommen um ein Java-basiertes Paket, das für NLP, Dokumentklassifizierung, Clustering, Themenmodellierung und viele andere maschinelle Lernanwendungen für Text verwendet wird. Es bietet uns das Mallet Topic Modeling Toolkit, das effiziente, stichprobenbasierte Implementierungen von LDA sowie Hierarchical LDA enthält.

Mallet2.0 ist die aktuelle Version von MALLET, dem Java-Toolkit zur Modellierung von Themen. Bevor wir es mit Gensim für LDA verwenden, müssen wir das Paket mallet-2.0.8.zip auf unser System herunterladen und entpacken. Setzen Sie nach der Installation und dem Entpacken die Umgebungsvariable% MALLET_HOME% entweder manuell oder anhand des von uns bereitgestellten Codes auf den Punkt im MALLET-Verzeichnis, während Sie als Nächstes den LDA mit Mallet implementieren.

Gensim Wrapper

Python bietet Gensim-Wrapper für Latent Dirichlet Allocation (LDA). Die Syntax dieses Wrappers lautetgensim.models.wrappers.LdaMallet. Dieses Modul, kollabierte Gibbs-Stichproben aus MALLET, ermöglicht die LDA-Modellschätzung aus einem Schulungskorpus und den Rückschluss auf die Themenverteilung auch auf neue, unsichtbare Dokumente.

Implementierungsbeispiel

Wir werden LDA Mallet für ein zuvor erstelltes LDA-Modell verwenden und den Leistungsunterschied durch Berechnung des Kohärenzwerts überprüfen.

Bereitstellung des Pfads zur Mallet-Datei

Bevor wir das Mallet LDA-Modell auf unseren im vorherigen Beispiel erstellten Korpus anwenden, müssen wir die Umgebungsvariablen aktualisieren und den Pfad für die Mallet-Datei angeben. Dies kann mit Hilfe des folgenden Codes erfolgen:

import os
from gensim.models.wrappers import LdaMallet
os.environ.update({'MALLET_HOME':r'C:/mallet-2.0.8/'}) 
#You should update this path as per the path of Mallet directory on your system.
mallet_path = r'C:/mallet-2.0.8/bin/mallet' 
#You should update this path as per the path of Mallet directory on your system.

Nachdem wir den Pfad zur Mallet-Datei angegeben haben, können wir ihn jetzt auf dem Korpus verwenden. Dies kann mit Hilfe von geschehenldamallet.show_topics() Funktion wie folgt -

ldamallet = gensim.models.wrappers.LdaMallet(
   mallet_path, corpus=corpus, num_topics=20, id2word=id2word
)
pprint(ldamallet.show_topics(formatted=False))

Ausgabe

[
   (4,
   [('gun', 0.024546225966016102),
   ('law', 0.02181426826996709),
   ('state', 0.017633545129043606),
   ('people', 0.017612848479831116),
   ('case', 0.011341763768445888),
   ('crime', 0.010596684396796159),
   ('weapon', 0.00985160502514643),
   ('person', 0.008671896020034356),
   ('firearm', 0.00838214293105946),
   ('police', 0.008257963035784506)]),
   (9,
   [('make', 0.02147966482730431),
   ('people', 0.021377478029838543),
   ('work', 0.018557122419783363),
   ('money', 0.016676885346413244),
   ('year', 0.015982015123646026),
   ('job', 0.012221540976905783),
   ('pay', 0.010239117106069897),
   ('time', 0.008910688739014919),
   ('school', 0.0079092581238504),
   ('support', 0.007357449417535254)]),
   (14,
   [('power', 0.018428398507941996),
   ('line', 0.013784244460364121),
   ('high', 0.01183271164249895),
   ('work', 0.011560979224821522),
   ('ground', 0.010770484918850819),
   ('current', 0.010745781971789235),
   ('wire', 0.008399002000938712),
   ('low', 0.008053160742076529),
   ('water', 0.006966231071366814),
   ('run', 0.006892122230182061)]),
   (0,
   [('people', 0.025218349201353372),
   ('kill', 0.01500904870564167),
   ('child', 0.013612400660948935),
   ('armenian', 0.010307655991816822),
   ('woman', 0.010287984892595798),
   ('start', 0.01003226060272248),
   ('day', 0.00967818081674404),
   ('happen', 0.009383114328428673),
   ('leave', 0.009383114328428673),
   ('fire', 0.009009363443229208)]),
   (1,
   [('file', 0.030686386604212003),
   ('program', 0.02227713642901929),
   ('window', 0.01945561169918489),
   ('set', 0.015914874783314277),
   ('line', 0.013831003577619592),
   ('display', 0.013794120901412606),
   ('application', 0.012576992586582082),
   ('entry', 0.009275993066056873),
   ('change', 0.00872275292295209),
   ('color', 0.008612104894331132)]),
   (12,
   [('line', 0.07153810971508515),
   ('buy', 0.02975597944523662),
   ('organization', 0.026877236406682988),
   ('host', 0.025451316957679788),
   ('price', 0.025182275552207485),
   ('sell', 0.02461728860071565),
   ('mail', 0.02192687454599263),
   ('good', 0.018967419085797303),
   ('sale', 0.017998870026097017),
   ('send', 0.013694207538540181)]),
   (11,
   [('thing', 0.04901329901329901),
   ('good', 0.0376018876018876),
   ('make', 0.03393393393393394),
   ('time', 0.03326898326898327),
   ('bad', 0.02664092664092664),
   ('happen', 0.017696267696267698),
   ('hear', 0.015615615615615615),
   ('problem', 0.015465465465465466),
   ('back', 0.015143715143715144),
   ('lot', 0.01495066495066495)]),
   (18,
   [('space', 0.020626317374284855),
   ('launch', 0.00965716006366413),
   ('system', 0.008560244332602057),
   ('project', 0.008173097603991913),
   ('time', 0.008108573149223556),
   ('cost', 0.007764442723792318),
   ('year', 0.0076784101174345075),
   ('earth', 0.007484836753129436),
   ('base', 0.0067535595990880545),
   ('large', 0.006689035144319697)]),
   (5,
   [('government', 0.01918437232469453),
   ('people', 0.01461203206475212),
   ('state', 0.011207097828624796),
   ('country', 0.010214802708381975),
   ('israeli', 0.010039691804809714),
   ('war', 0.009436532025838587),
   ('force', 0.00858043427504086),
   ('attack', 0.008424780138532182),
   ('land', 0.0076659662230523775),
   ('world', 0.0075103120865437)]),
   (2,
   [('car', 0.041091194044470564),
   ('bike', 0.015598981291017729),
   ('ride', 0.011019688510138114),
   ('drive', 0.010627877363110981),
   ('engine', 0.009403467528651191),
   ('speed', 0.008081104907434616),
   ('turn', 0.007738270153785875),
   ('back', 0.007738270153785875),
   ('front', 0.007468899990204721),
   ('big', 0.007370947203447938)])
]

Leistung bewerten

Jetzt können wir auch die Leistung bewerten, indem wir den Kohärenzwert wie folgt berechnen:

ldamallet = gensim.models.wrappers.LdaMallet(
   mallet_path, corpus=corpus, num_topics=20, id2word=id2word
)
pprint(ldamallet.show_topics(formatted=False))

Ausgabe

Coherence Score: 0.5842762900901401

In diesem Kapitel werden die Dokumente und das LDA-Modell in Gensim erläutert.

Finden der optimalen Anzahl von Themen für LDA

Wir können die optimale Anzahl von Themen für LDA finden, indem wir viele LDA-Modelle mit verschiedenen Werten von Themen erstellen. Unter diesen LDAs können wir einen mit dem höchsten Kohärenzwert auswählen.

Folgende Funktion benannt coherence_values_computation()trainiert mehrere LDA-Modelle. Außerdem werden die Modelle sowie die entsprechende Kohärenzbewertung bereitgestellt.

def coherence_values_computation(dictionary, corpus, texts, limit, start=2, step=3):
   coherence_values = []
   model_list = []
   for num_topics in range(start, limit, step):
      model = gensim.models.wrappers.LdaMallet(
         mallet_path, corpus=corpus, num_topics=num_topics, id2word=id2word
      )
      model_list.append(model)
   coherencemodel = CoherenceModel(
      model=model, texts=texts, dictionary=dictionary, coherence='c_v'
   )
   coherence_values.append(coherencemodel.get_coherence())
return model_list, coherence_values

Mit Hilfe des folgenden Codes können wir nun die optimale Anzahl von Themen erhalten, die wir auch mithilfe eines Diagramms anzeigen können -

model_list, coherence_values = coherence_values_computation (
   dictionary=id2word, corpus=corpus, texts=data_lemmatized, 
   start=1, limit=50, step=8
)
limit=50; start=1; step=8;
x = range(start, limit, step)
plt.plot(x, coherence_values)
plt.xlabel("Num Topics")
plt.ylabel("Coherence score")
plt.legend(("coherence_values"), loc='best')
plt.show()

Ausgabe

Als nächstes können wir die Kohärenzwerte für verschiedene Themen wie folgt drucken:

for m, cv in zip(x, coherence_values):
   print("Num Topics =", m, " is having Coherence Value of", round(cv, 4))

Ausgabe

Num Topics = 1 is having Coherence Value of 0.4866
Num Topics = 9 is having Coherence Value of 0.5083
Num Topics = 17 is having Coherence Value of 0.5584
Num Topics = 25 is having Coherence Value of 0.5793
Num Topics = 33 is having Coherence Value of 0.587
Num Topics = 41 is having Coherence Value of 0.5842
Num Topics = 49 is having Coherence Value of 0.5735

Nun stellt sich die Frage, welches Modell wir jetzt auswählen sollen. Eine der bewährten Methoden besteht darin, das Modell auszuwählen, das vor dem Schmeicheln den höchsten Kohärenzwert ergibt. Deshalb wählen wir das Modell mit 25 Themen aus, das in der obigen Liste auf Platz 4 steht.

optimal_model = model_list[3]
model_topics = optimal_model.show_topics(formatted=False)
pprint(optimal_model.print_topics(num_words=10))

[
   (0,
   '0.018*"power" + 0.011*"high" + 0.010*"ground" + 0.009*"current" + '
   '0.008*"low" + 0.008*"wire" + 0.007*"water" + 0.007*"work" + 0.007*"design" '
   '+ 0.007*"light"'),
   (1,
   '0.036*"game" + 0.029*"team" + 0.029*"year" + 0.028*"play" + 0.020*"player" '
   '+ 0.019*"win" + 0.018*"good" + 0.013*"season" + 0.012*"run" + 0.011*"hit"'),
   (2,
   '0.020*"image" + 0.019*"information" + 0.017*"include" + 0.017*"mail" + '
   '0.016*"send" + 0.015*"list" + 0.013*"post" + 0.012*"address" + '
   '0.012*"internet" + 0.012*"system"'),
   (3,
   '0.986*"ax" + 0.002*"_" + 0.001*"tm" + 0.000*"part" + 0.000*"biz" + '
   '0.000*"mb" + 0.000*"mbs" + 0.000*"pne" + 0.000*"end" + 0.000*"di"'),
   (4,
   '0.020*"make" + 0.014*"work" + 0.013*"money" + 0.013*"year" + 0.012*"people" '
   '+ 0.011*"job" + 0.010*"group" + 0.009*"government" + 0.008*"support" + '
   '0.008*"question"'),
   (5,
   '0.011*"study" + 0.011*"drug" + 0.009*"science" + 0.008*"food" + '
   '0.008*"problem" + 0.008*"result" + 0.008*"effect" + 0.007*"doctor" + '
   '0.007*"research" + 0.007*"patient"'),
   (6,
   '0.024*"gun" + 0.024*"law" + 0.019*"state" + 0.015*"case" + 0.013*"people" + '
   '0.010*"crime" + 0.010*"weapon" + 0.010*"person" + 0.008*"firearm" + '
   '0.008*"police"'),
   (7,
   '0.012*"word" + 0.011*"question" + 0.011*"exist" + 0.011*"true" + '
   '0.010*"religion" + 0.010*"claim" + 0.008*"argument" + 0.008*"truth" + '
   '0.008*"life" + 0.008*"faith"'),
   (8,
   '0.077*"time" + 0.029*"day" + 0.029*"call" + 0.025*"back" + 0.021*"work" + '
   '0.019*"long" + 0.015*"end" + 0.015*"give" + 0.014*"year" + 0.014*"week"'),
   (9,
   '0.048*"thing" + 0.041*"make" + 0.038*"good" + 0.037*"people" + '
   '0.028*"write" + 0.019*"bad" + 0.019*"point" + 0.018*"read" + 0.018*"post" + '
   '0.016*"idea"'),
   (10,
   '0.022*"book" + 0.020*"_" + 0.013*"man" + 0.012*"people" + 0.011*"write" + '
   '0.011*"find" + 0.010*"history" + 0.010*"armenian" + 0.009*"turkish" + '
   '0.009*"number"'),
   (11,
   '0.064*"line" + 0.030*"buy" + 0.028*"organization" + 0.025*"price" + '
   '0.025*"sell" + 0.023*"good" + 0.021*"host" + 0.018*"sale" + 0.017*"mail" + '
   '0.016*"cost"'),
   (12,
   '0.041*"car" + 0.015*"bike" + 0.011*"ride" + 0.010*"engine" + 0.009*"drive" '
   '+ 0.008*"side" + 0.008*"article" + 0.007*"turn" + 0.007*"front" + '
   '0.007*"speed"'),
   (13,
   '0.018*"people" + 0.011*"attack" + 0.011*"state" + 0.011*"israeli" + '
   '0.010*"war" + 0.010*"country" + 0.010*"government" + 0.009*"live" + '
   '0.009*"give" + 0.009*"land"'),
   (14,
   '0.037*"file" + 0.026*"line" + 0.021*"read" + 0.019*"follow" + '
   '0.018*"number" + 0.015*"program" + 0.014*"write" + 0.012*"entry" + '
   '0.012*"give" + 0.011*"check"'),
   (15,
   '0.196*"write" + 0.172*"line" + 0.165*"article" + 0.117*"organization" + '
   '0.086*"host" + 0.030*"reply" + 0.010*"university" + 0.008*"hear" + '
   '0.007*"post" + 0.007*"news"'),
   (16,
   '0.021*"people" + 0.014*"happen" + 0.014*"child" + 0.012*"kill" + '
   '0.011*"start" + 0.011*"live" + 0.010*"fire" + 0.010*"leave" + 0.009*"hear" '
   '+ 0.009*"home"'),
   (17,
   '0.038*"key" + 0.018*"system" + 0.015*"space" + 0.015*"technology" + '
   '0.014*"encryption" + 0.010*"chip" + 0.010*"bit" + 0.009*"launch" + '
   '0.009*"public" + 0.009*"government"'),
   (18,
   '0.035*"drive" + 0.031*"system" + 0.027*"problem" + 0.027*"card" + '
   '0.020*"driver" + 0.017*"bit" + 0.017*"work" + 0.016*"disk" + '
   '0.014*"monitor" + 0.014*"machine"'),
   (19,
   '0.031*"window" + 0.020*"run" + 0.018*"color" + 0.018*"program" + '
   '0.017*"application" + 0.016*"display" + 0.015*"set" + 0.015*"version" + '
   '0.012*"screen" + 0.012*"problem"')
]

Dominante Themen in Sätzen finden

Das Finden dominanter Themen in Sätzen ist eine der nützlichsten praktischen Anwendungen der Themenmodellierung. Es bestimmt, um welches Thema es sich bei einem bestimmten Dokument handelt. Hier finden wir die Themennummer, die den höchsten prozentualen Beitrag in diesem bestimmten Dokument hat. Um die Informationen in einer Tabelle zusammenzufassen, erstellen wir eine Funktion mit dem Namendominant_topics() - -

def dominant_topics(ldamodel=lda_model, corpus=corpus, texts=data):
   sent_topics_df = pd.DataFrame()

Als nächstes werden wir die Hauptthemen in jedem Dokument erhalten -

for i, row in enumerate(ldamodel[corpus]):
   row = sorted(row, key=lambda x: (x[1]), reverse=True)

Als nächstes erhalten wir das dominante Thema, den Perc-Beitrag und die Schlüsselwörter für jedes Dokument -

for j, (topic_num, prop_topic) in enumerate(row):
   if j == 0: # => dominant topic
      wp = ldamodel.show_topic(topic_num)
      topic_keywords = ", ".join([word for word, prop in wp])
sent_topics_df = sent_topics_df.append(
   pd.Series([int(topic_num), round(prop_topic,4), topic_keywords]), ignore_index=True
)
   else:
      break
sent_topics_df.columns = ['Dominant_Topic', 'Perc_Contribution', 'Topic_Keywords']

Mit Hilfe des folgenden Codes fügen wir den Originaltext am Ende der Ausgabe hinzu -

contents = pd.Series(texts)
   sent_topics_df = pd.concat([sent_topics_df, contents], axis=1)
   return(sent_topics_df)
df_topic_sents_keywords = dominant_topics(
   ldamodel=optimal_model, corpus=corpus, texts=data
)

Führen Sie nun die Formatierung der Themen in den Sätzen wie folgt durch:

df_dominant_topic = df_topic_sents_keywords.reset_index()
df_dominant_topic.columns = [
   'Document_No', 'Dominant_Topic', 'Topic_Perc_Contrib', 'Keywords', 'Text'
]

Schließlich können wir die dominierenden Themen wie folgt zeigen:

df_dominant_topic.head(15)

Suche nach dem repräsentativsten Dokument

Um mehr über das Thema zu erfahren, können wir auch die Dokumente finden, zu denen ein bestimmtes Thema am meisten beigetragen hat. Wir können dieses Thema ableiten, indem wir diese bestimmten Dokumente lesen.

sent_topics_sorteddf_mallet = pd.DataFrame()
sent_topics_outdf_grpd = df_topic_sents_keywords.groupby('Dominant_Topic')
for i, grp in sent_topics_outdf_grpd:
   sent_topics_sorteddf_mallet = pd.concat([sent_topics_sorteddf_mallet,
grp.sort_values(['Perc_Contribution'], ascending=[0]).head(1)], axis=0)
sent_topics_sorteddf_mallet.reset_index(drop=True, inplace=True)
sent_topics_sorteddf_mallet.columns = [
   'Topic_Number', "Contribution_Perc", "Keywords", "Text"
]
sent_topics_sorteddf_mallet.head()

Ausgabe

Umfang & Verteilung der Themen

Manchmal möchten wir auch beurteilen, wie weit das Thema in Dokumenten diskutiert wird. Dazu müssen wir das Volumen und die Verteilung der Themen auf die Dokumente verstehen.

Berechnen Sie zunächst die Anzahl der Dokumente für jedes Thema wie folgt:

topic_counts = df_topic_sents_keywords['Dominant_Topic'].value_counts()

Berechnen Sie als Nächstes den Prozentsatz der Dokumente für jedes Thema wie folgt:

topic_contribution = round(topic_counts/topic_counts.sum(), 4)

Suchen Sie nun das Thema Nummer und Stichwörter wie folgt:

topic_num_keywords = df_topic_sents_keywords[['Dominant_Topic', 'Topic_Keywords']]

Verketten Sie nun die Spalte wie folgt:

df_dominant_topics = pd.concat(
   [topic_num_keywords, topic_counts, topic_contribution], axis=1
)

Als nächstes werden wir die Spaltennamen wie folgt ändern:

df_dominant_topics.columns = [
   'Dominant-Topic', 'Topic-Keywords', 'Num_Documents', 'Perc_Documents'
]
df_dominant_topics

Ausgabe

Dieses Kapitel befasst sich mit der Erstellung des Themenmodells Latent Semantic Indexing (LSI) und Hierarchical Dirichlet Process (HDP) in Bezug auf Gensim.

Das Thema Modellierungsalgorithmen, das erstmals in Gensim mit Latent Dirichlet Allocation (LDA) implementiert wurde, ist Latent Semantic Indexing (LSI). Es wird auch genanntLatent Semantic Analysis (LSA). Es wurde 1988 von Scott Deerwester, Susan Dumais, George Furnas, Richard Harshman, Thomas Landaur, Karen Lochbaum und Lynn Streeter patentiert.

In diesem Abschnitt werden wir unser LSI-Modell einrichten. Dies kann auf die gleiche Weise wie beim Einrichten des LDA-Modells erfolgen. Wir müssen das LSI-Modell aus importierengensim.models.

Rolle von LSI

Tatsächlich ist LSI eine NLP-Technik, insbesondere in der Verteilungssemantik. Es analysiert die Beziehung zwischen einer Reihe von Dokumenten und den Begriffen, die diese Dokumente enthalten. Wenn wir über seine Funktionsweise sprechen, erstellt es eine Matrix, die aus einem großen Textstück die Anzahl der Wörter pro Dokument enthält.

Nach der Erstellung verwendet das LSI-Modell eine mathematische Technik, die als Singular Value Decomposition (SVD) bezeichnet wird, um die Anzahl der Zeilen zu verringern. Neben der Reduzierung der Anzahl der Zeilen bleibt auch die Ähnlichkeitsstruktur zwischen den Spalten erhalten.

In der Matrix repräsentieren die Zeilen eindeutige Wörter und die Spalten jedes Dokument. Es funktioniert basierend auf einer Verteilungshypothese, dh es wird davon ausgegangen, dass die Wörter, deren Bedeutung nahe beieinander liegt, in derselben Art von Text vorkommen.

Implementierung mit Gensim

Hier werden wir LSI (Latent Semantic Indexing) verwenden, um die natürlich diskutierten Themen aus dem Datensatz zu extrahieren.

Datensatz wird geladen

Der Datensatz, den wir verwenden werden, ist der Datensatz von ’20 Newsgroups’mit Tausenden von Nachrichtenartikeln aus verschiedenen Abschnitten eines Nachrichtenberichts. Es ist verfügbar unterSklearnDatensätze. Wir können einfach mit Hilfe des folgenden Python-Skripts herunterladen -

from sklearn.datasets import fetch_20newsgroups
newsgroups_train = fetch_20newsgroups(subset='train')

Schauen wir uns einige der Beispielnachrichten mit Hilfe des folgenden Skripts an:

newsgroups_train.data[:4]
["From: [email protected] (where's my thing)\nSubject: 
WHAT car is this!?\nNntp-Posting-Host: rac3.wam.umd.edu\nOrganization: 
University of Maryland, College Park\nLines: 15\n\n 
I was wondering if anyone out there could enlighten me on this car 
I saw\nthe other day. It was a 2-door sports car,
looked to be from the late 60s/\nearly 70s. It was called a Bricklin. 
The doors were really small. In addition,\nthe front bumper was separate from 
the rest of the body. This is \nall I know. If anyone can tellme a model name, 
engine specs, years\nof production, where this car is made, history, or 
whatever info you\nhave on this funky looking car, 
please e-mail.\n\nThanks,\n- IL\n ---- brought to you by your neighborhood 
Lerxst ----\n\n\n\n\n",

"From: [email protected] (Guy Kuo)\nSubject: 
SI Clock Poll - Final Call\nSummary: Final call for SI clock reports\nKeywords: 
SI,acceleration,clock,upgrade\nArticle-I.D.: shelley.1qvfo9INNc3s\nOrganization: 
University of Washington\nLines: 11\nNNTP-Posting-Host: carson.u.washington.edu\n\nA 
fair number of brave souls who upgraded their SI clock oscillator have\nshared their 
experiences for this poll. Please send a brief message detailing\nyour experiences with 
the procedure. Top speed attained, CPU rated speed,\nadd on cards and adapters, heat 
sinks, hour of usage per day, floppy disk\nfunctionality with 800 and 1.4 m floppies 
are especially requested.\n\nI will be summarizing in the next two days, so please add 
to the network\nknowledge base if you have done the clock upgrade and haven't answered 
this\npoll. Thanks.\n\nGuy Kuo <[email protected]>\n",

'From: [email protected] (Thomas E Willis)\nSubject: 
PB questions...\nOrganization: Purdue University Engineering Computer 
Network\nDistribution: usa\nLines: 36\n\nwell folks, my mac plus finally gave up the 
ghost this weekend after\nstarting life as a 512k way back in 1985. sooo, i\'m in the 
market for a\nnew machine a bit sooner than i intended to be...\n\ni\'m looking into 
picking up a powerbook 160 or maybe 180 and have a bunch\nof questions that (hopefully) 
somebody can answer:\n\n* does anybody know any dirt on when the next round of 
powerbook\nintroductions are expected? i\'d heard the 185c was supposed to make 
an\nappearence "this summer" but haven\'t heard anymore on it - and since i\ndon\'t 
have access to macleak, i was wondering if anybody out there had\nmore info...\n\n* has 
anybody heard rumors about price drops to the powerbook line like the\nones the duo\'s 
just went through recently?\n\n* what\'s the impression of the display on the 180? i 
could probably swing\na 180 if i got the 80Mb disk rather than the 120, but i don\'t 
really have\na feel for how much "better" the display is (yea, it looks great in 
the\nstore, but is that all "wow" or is it really that good?). could i solicit\nsome 
opinions of people who use the 160 and 180 day-to-day on if its worth\ntaking the disk 
size and money hit to get the active display? (i realize\nthis is a real subjective 
question, but i\'ve only played around with the\nmachines in a computer store breifly 
and figured the opinions of somebody\nwho actually uses the machine daily might prove 
helpful).\n\n* how well does hellcats perform? ;)\n\nthanks a bunch in advance for any 
info - if you could email, i\'ll post a\nsummary (news reading time is at a premium 
with finals just around the\ncorner... :( )\n--\nTom Willis \\ [email protected] 
\\ Purdue Electrical 
Engineering\n---------------------------------------------------------------------------\
n"Convictions are more dangerous enemies of truth than lies." - F. W.\nNietzsche\n',

'From: jgreen@amber (Joe Green)\nSubject: Re: Weitek P9000 ?\nOrganization: Harris 
Computer Systems Division\nLines: 14\nDistribution: world\nNNTP-Posting-Host: 
amber.ssd.csd.harris.com\nX-Newsreader: TIN [version 1.1 PL9]\n\nRobert J.C. Kyanko 
([email protected]) wrote:\n > [email protected] writes in article <
[email protected]>:\n> > Anyone know about the Weitek P9000 
graphics chip?\n > As far as the low-level stuff goes, it looks pretty nice. It\'s 
got this\n > quadrilateral fill command that requires just the four
points.\n\nDo you have Weitek\'s address/phone number? I\'d like to get some 
information\nabout this chip.\n\n--\nJoe Green\t\t\t\tHarris 
Corporation\[email protected]\t\t\tComputer Systems Division\n"The only thing that 
really scares me is a person with no sense of humor."\n\t\t\t\t\t\t-- Jonathan 
Winters\n']

Voraussetzung

Wir brauchen Stoppwörter von NLTK und ein englisches Modell von Scapy. Beide können wie folgt heruntergeladen werden:

import nltk;
nltk.download('stopwords')
nlp = spacy.load('en_core_web_md', disable=['parser', 'ner'])

Notwendige Pakete importieren

Um ein LSI-Modell zu erstellen, müssen wir das folgende erforderliche Paket importieren:

import re
import numpy as np
import pandas as pd
from pprint import pprint
import gensim
import gensim.corpora as corpora
from gensim.utils import simple_preprocess
from gensim.models import CoherenceModel
import spacy
import matplotlib.pyplot as plt

Stoppwörter vorbereiten

Jetzt müssen wir die Stoppwörter importieren und verwenden -

from nltk.corpus import stopwords
stop_words = stopwords.words('english')
stop_words.extend(['from', 'subject', 're', 'edu', 'use'])

Bereinigen Sie den Text

Nun, mit Hilfe von Gensim simple_preprocess()Wir müssen jeden Satz in eine Liste von Wörtern umwandeln. Wir sollten auch die Interpunktionen und unnötigen Zeichen entfernen. Zu diesem Zweck erstellen wir eine Funktion mit dem Namensent_to_words() - -

def sent_to_words(sentences):
   for sentence in sentences:
      yield(gensim.utils.simple_preprocess(str(sentence), deacc=True))
data_words = list(sent_to_words(data))

Erstellen von Bigram- und Trigram-Modellen

Wie wir wissen, sind Bigramme zwei Wörter, die im Dokument häufig zusammen vorkommen, und Trigramm sind drei Wörter, die im Dokument häufig zusammen vorkommen. Mit Hilfe von Gensims Phrasenmodell können wir dies tun -

bigram = gensim.models.Phrases(data_words, min_count=5, threshold=100)
trigram = gensim.models.Phrases(bigram[data_words], threshold=100)
bigram_mod = gensim.models.phrases.Phraser(bigram)
trigram_mod = gensim.models.phrases.Phraser(trigram)

Stoppwörter herausfiltern

Als nächstes müssen wir die Stoppwörter herausfiltern. Daneben werden wir auch Funktionen zur Herstellung von Bigrams, Trigrammen und zur Lemmatisierung erstellen -

def remove_stopwords(texts):
   return [[word for word in simple_preprocess(str(doc)) 
   if word not in stop_words] for doc in texts]
def make_bigrams(texts):
   return [bigram_mod[doc] for doc in texts]
def make_trigrams(texts):
   return [trigram_mod[bigram_mod[doc]] for doc in texts]
def lemmatization(texts, allowed_postags=['NOUN', 'ADJ', 'VERB', 'ADV']):
   texts_out = []
   for sent in texts:
      doc = nlp(" ".join(sent))
      texts_out.append([token.lemma_ for token in doc if token.pos_ in allowed_postags])
   return texts_out

Erstellen von Wörterbuch und Korpus für das Themenmodell

Wir müssen jetzt das Wörterbuch und den Korpus erstellen. Wir haben es auch in den vorherigen Beispielen gemacht -

id2word = corpora.Dictionary(data_lemmatized)
texts = data_lemmatized
corpus = [id2word.doc2bow(text) for text in texts]

Erstellen eines LSI-Themenmodells

Wir haben bereits alles implementiert, was zum Trainieren des LSI-Modells erforderlich ist. Jetzt ist es an der Zeit, das LSI-Themenmodell zu erstellen. Für unser Implementierungsbeispiel kann dies mithilfe der folgenden Codezeile erfolgen:

lsi_model = gensim.models.lsimodel.LsiModel(
   corpus=corpus, id2word=id2word, num_topics=20,chunksize=100
)

Implementierungsbeispiel

Sehen wir uns das vollständige Implementierungsbeispiel zum Erstellen eines LDA-Themenmodells an.

import re
import numpy as np
import pandas as pd
from pprint import pprint
import gensim
import gensim.corpora as corpora
from gensim.utils import simple_preprocess
from gensim.models import CoherenceModel
import spacy
import matplotlib.pyplot as plt
from nltk.corpus import stopwords
stop_words = stopwords.words('english')
stop_words.extend(['from', 'subject', 're', 'edu', 'use'])
from sklearn.datasets import fetch_20newsgroups
newsgroups_train = fetch_20newsgroups(subset='train')
data = newsgroups_train.data
data = [re.sub('\S*@\S*\s?', '', sent) for sent in data]
data = [re.sub('\s+', ' ', sent) for sent in data]
data = [re.sub("\'", "", sent) for sent in data]
print(data_words[:4]) #it will print the data after prepared for stopwords
bigram = gensim.models.Phrases(data_words, min_count=5, threshold=100)
trigram = gensim.models.Phrases(bigram[data_words], threshold=100)
bigram_mod = gensim.models.phrases.Phraser(bigram)
trigram_mod = gensim.models.phrases.Phraser(trigram)
def remove_stopwords(texts):
   return [[word for word in simple_preprocess(str(doc)) 
   if word not in stop_words] for doc in texts]
def make_bigrams(texts):
   return [bigram_mod[doc] for doc in texts]
def make_trigrams(texts):
   return [trigram_mod[bigram_mod[doc]] for doc in texts]
def lemmatization(texts, allowed_postags=['NOUN', 'ADJ', 'VERB', 'ADV']):
   texts_out = []
   for sent in texts:
      doc = nlp(" ".join(sent))
      texts_out.append([token.lemma_ for token in doc if token.pos_ in allowed_postags])
return texts_out
data_words_nostops = remove_stopwords(data_words)
data_words_bigrams = make_bigrams(data_words_nostops)
nlp = spacy.load('en_core_web_md', disable=['parser', 'ner'])
data_lemmatized = lemmatization(
   data_words_bigrams, allowed_postags=['NOUN', 'ADJ', 'VERB', 'ADV']
)
print(data_lemmatized[:4]) #it will print the lemmatized data.
id2word = corpora.Dictionary(data_lemmatized)
texts = data_lemmatized
corpus = [id2word.doc2bow(text) for text in texts]
print(corpus[:4]) #it will print the corpus we created above.
[[(id2word[id], freq) for id, freq in cp] for cp in corpus[:4]] 
#it will print the words with their frequencies.
lsi_model = gensim.models.lsimodel.LsiModel(
   corpus=corpus, id2word=id2word, num_topics=20,chunksize=100
)

Wir können jetzt das oben erstellte LSI-Modell verwenden, um die Themen abzurufen.

Anzeigen von Themen im LSI-Modell

Das LSI-Modell (lsi_model)Wir haben oben erstellt, um die Themen aus den Dokumenten anzuzeigen. Dies kann mit Hilfe des folgenden Skripts erfolgen:

pprint(lsi_model.print_topics())
doc_lsi = lsi_model[corpus]

Ausgabe

[
   (0,
   '1.000*"ax" + 0.001*"_" + 0.000*"tm" + 0.000*"part" +    0.000*"pne" + '
   '0.000*"biz" + 0.000*"mbs" + 0.000*"end" + 0.000*"fax" + 0.000*"mb"'),
   (1,
   '0.239*"say" + 0.222*"file" + 0.189*"go" + 0.171*"know" + 0.169*"people" + '
   '0.147*"make" + 0.140*"use" + 0.135*"also" + 0.133*"see" + 0.123*"think"')
]

Hierarchischer Dirichlet-Prozess (HPD)

Themenmodelle wie LDA und LSI helfen bei der Zusammenfassung und Organisation großer Textarchive, die nicht von Hand analysiert werden können. Neben LDA und LSI ist HDP (Hierarchical Dirichlet Process) ein weiteres leistungsstarkes Themenmodell in Gensim. Grundsätzlich handelt es sich um ein Modell mit gemischter Mitgliedschaft für die unbeaufsichtigte Analyse gruppierter Daten. Im Gegensatz zu LDA (dem endlichen Gegenstück) leitet HDP die Anzahl der Themen aus den Daten ab.

Implementierung mit Gensim

Für die Implementierung von HDP in Gensim müssen wir Korpus und Wörterbuch trainieren (wie in den obigen Beispielen bei der Implementierung von LDA- und LSI-Themenmodellen). HDP-Themenmodell, das wir aus gensim.models.HdpModel importieren können. Auch hier werden wir das HDP-Themenmodell für 20Newsgroup-Daten implementieren und die Schritte sind ebenfalls gleich.

Für unseren Korpus und unser Wörterbuch (erstellt in den obigen Beispielen für das LSI- und LDA-Modell) können wir HdpModel wie folgt importieren:

Hdp_model = gensim.models.hdpmodel.HdpModel(corpus=corpus, id2word=id2word)

Anzeigen von Themen im LSI-Modell

Das HDP-Modell (Hdp_model)kann verwendet werden, um die Themen aus den Dokumenten anzuzeigen. Dies kann mit Hilfe des folgenden Skripts erfolgen:

pprint(Hdp_model.print_topics())

Ausgabe

[
   (0,
   '0.009*line + 0.009*write + 0.006*say + 0.006*article + 0.006*know + '
   '0.006*people + 0.005*make + 0.005*go + 0.005*think + 0.005*be'),
   (1,
   '0.016*line + 0.011*write + 0.008*article + 0.008*organization + 0.006*know '
   '+ 0.006*host + 0.006*be + 0.005*get + 0.005*use + 0.005*say'),
   (2,
   '0.810*ax + 0.001*_ + 0.000*tm + 0.000*part + 0.000*mb + 0.000*pne + '
   '0.000*biz + 0.000*end + 0.000*wwiz + 0.000*fax'),
   (3,
   '0.015*line + 0.008*write + 0.007*organization + 0.006*host + 0.006*know + '
   '0.006*article + 0.005*use + 0.005*thank + 0.004*get + 0.004*problem'),
   (4,
   '0.004*line + 0.003*write + 0.002*believe + 0.002*think + 0.002*article + '
   '0.002*belief + 0.002*say + 0.002*see + 0.002*look + 0.002*organization'),
   (5,
   '0.005*line + 0.003*write + 0.003*organization + 0.002*article + 0.002*time '
   '+ 0.002*host + 0.002*get + 0.002*look + 0.002*say + 0.001*number'),
   (6,
   '0.003*line + 0.002*say + 0.002*write + 0.002*go + 0.002*gun + 0.002*get + '
   '0.002*organization + 0.002*bill + 0.002*article + 0.002*state'),
   (7,
   '0.003*line + 0.002*write + 0.002*article + 0.002*organization + 0.001*none '
   '+ 0.001*know + 0.001*say + 0.001*people + 0.001*host + 0.001*new'),
   (8,
   '0.004*line + 0.002*write + 0.002*get + 0.002*team + 0.002*organization + '
   '0.002*go + 0.002*think + 0.002*know + 0.002*article + 0.001*well'),
   (9,
   '0.004*line + 0.002*organization + 0.002*write + 0.001*be + 0.001*host + '
   '0.001*article + 0.001*thank + 0.001*use + 0.001*work + 0.001*run'),
   (10,
   '0.002*line + 0.001*game + 0.001*write + 0.001*get + 0.001*know + '
   '0.001*thing + 0.001*think + 0.001*article + 0.001*help + 0.001*turn'),
   (11,
   '0.002*line + 0.001*write + 0.001*game + 0.001*organization + 0.001*say + '
   '0.001*host + 0.001*give + 0.001*run + 0.001*article + 0.001*get'),
   (12,
   '0.002*line + 0.001*write + 0.001*know + 0.001*time + 0.001*article + '
   '0.001*get + 0.001*think + 0.001*organization + 0.001*scope + 0.001*make'),
   (13,
   '0.002*line + 0.002*write + 0.001*article + 0.001*organization + 0.001*make '
   '+ 0.001*know + 0.001*see + 0.001*get + 0.001*host + 0.001*really'),
   (14,
   '0.002*write + 0.002*line + 0.002*know + 0.001*think + 0.001*say + '
   '0.001*article + 0.001*argument + 0.001*even + 0.001*card + 0.001*be'),
   (15,
   '0.001*article + 0.001*line + 0.001*make + 0.001*write + 0.001*know + '
   '0.001*say + 0.001*exist + 0.001*get + 0.001*purpose + 0.001*organization'),
   (16,
   '0.002*line + 0.001*write + 0.001*article + 0.001*insurance + 0.001*go + '
   '0.001*be + 0.001*host + 0.001*say + 0.001*organization + 0.001*part'),
   (17,
   '0.001*line + 0.001*get + 0.001*hit + 0.001*go + 0.001*write + 0.001*say + '
   '0.001*know + 0.001*drug + 0.001*see + 0.001*need'),
   (18,
   '0.002*option + 0.001*line + 0.001*flight + 0.001*power + 0.001*software + '
   '0.001*write + 0.001*add + 0.001*people + 0.001*organization + 0.001*module'),
   (19,
   '0.001*shuttle + 0.001*line + 0.001*roll + 0.001*attitude + 0.001*maneuver + '
   '0.001*mission + 0.001*also + 0.001*orbit + 0.001*produce + 0.001*frequency')
]

Das Kapitel wird uns helfen, die Entwicklung der Worteinbettung in Gensim zu verstehen.

Die Worteinbettung, ein Ansatz zur Darstellung von Wörtern und Dokumenten, ist eine dichte Vektordarstellung für Text, bei der Wörter mit derselben Bedeutung eine ähnliche Darstellung haben. Im Folgenden sind einige Merkmale der Worteinbettung aufgeführt:

• Es ist eine Klasse von Techniken, die die einzelnen Wörter als reelle Vektoren in einem vordefinierten Vektorraum darstellen.

• Diese Technik wird häufig in das Feld des DL (Deep Learning) zusammengefasst, da jedes Wort einem Vektor zugeordnet wird und die Vektorwerte auf die gleiche Weise wie ein NN (Neural Networks) gelernt werden.

• Der Schlüsselansatz der Worteinbettungstechnik ist eine dicht verteilte Darstellung für jedes Wort.

Verschiedene Methoden / Algorithmen zum Einbetten von Wörtern

Wie oben diskutiert, lernen Worteinbettungsmethoden / -algorithmen eine reelle Vektordarstellung aus einem Textkorpus. Dieser Lernprozess kann entweder mit dem NN-Modell für Aufgaben wie die Klassifizierung von Dokumenten verwendet werden oder ist ein unbeaufsichtigter Prozess wie die Dokumentenstatistik. Hier werden wir zwei Methoden / Algorithmen diskutieren, die verwendet werden können, um ein Wort zu lernen, das aus Text eingebettet wird -

Word2Vec von Google

Word2Vec, entwickelt von Tomas Mikolov et al. al. Bei Google im Jahr 2013 handelt es sich um eine statistische Methode zum effizienten Erlernen eines aus Textkorpus eingebetteten Wortes. Es wurde als Reaktion entwickelt, um das NN-basierte Training der Worteinbettung effizienter zu gestalten. Es ist zum De-facto-Standard für die Worteinbettung geworden.

Das Einbetten von Wörtern durch Word2Vec umfasst die Analyse der gelernten Vektoren sowie die Untersuchung der Vektormathematik zur Darstellung von Wörtern. Im Folgenden sind die zwei verschiedenen Lernmethoden aufgeführt, die als Teil der Word2Vec-Methode verwendet werden können:

• CBoW-Modell (Continuous Bag of Words)
• Kontinuierliches Skip-Gram-Modell

GloVe von Standford

GloVe (Globale Vektoren für die Wortdarstellung) ist eine Erweiterung der Word2Vec-Methode. Es wurde von Pennington et al. in Stanford. Der GloVe-Algorithmus ist eine Mischung aus beidem -

• Globale Statistik von Matrixfaktorisierungstechniken wie LSA (Latent Semantic Analysis)
• Lokales kontextbasiertes Lernen in Word2Vec.

Wenn wir über seine Funktionsweise sprechen, erstellt GloVe anstelle eines Fensters zur Definition des lokalen Kontexts eine explizite Matrix für das gleichzeitige Auftreten von Wörtern unter Verwendung von Statistiken über den gesamten Textkorpus.

Entwickeln der Word2Vec-Einbettung

Hier werden wir die Einbettung von Word2Vec mithilfe von Gensim entwickeln. Um mit einem Word2Vec-Modell arbeiten zu können, stellt uns Gensim zur VerfügungWord2Vec Klasse, aus der importiert werden kann models.word2vec. Für die Implementierung benötigt word2vec viel Text, z. B. den gesamten Amazon-Überprüfungskorpus. Aber hier werden wir dieses Prinzip auf Text mit kleinem Speicher anwenden.

Implementierungsbeispiel

Zuerst müssen wir die Word2Vec-Klasse wie folgt aus gensim.models importieren:

from gensim.models import Word2Vec

Als nächstes müssen wir die Trainingsdaten definieren. Anstatt eine große Textdatei zu verwenden, verwenden wir einige Sätze, um dieses Prinzip zu implementieren.

sentences = [
   ['this', 'is', 'gensim', 'tutorial', 'for', 'free'],
   ['this', 'is', 'the', 'tutorials' 'point', 'website'],
   ['you', 'can', 'read', 'technical','tutorials', 'for','free'],
   ['we', 'are', 'implementing','word2vec'],
   ['learn', 'full', 'gensim', 'tutorial']
]

Sobald die Trainingsdaten vorliegen, müssen wir das Modell trainieren. es kann wie folgt gemacht werden -

model = Word2Vec(sentences, min_count=1)

Wir können das Modell wie folgt zusammenfassen -;

print(model)

Wir können das Vokabular wie folgt zusammenfassen:

words = list(model.wv.vocab)
print(words)

Als nächstes greifen wir auf den Vektor für ein Wort zu. Wir machen es für das Wort "Tutorial".

print(model['tutorial'])

Als nächstes müssen wir das Modell speichern -

model.save('model.bin')

Als nächstes müssen wir das Modell laden -

new_model = Word2Vec.load('model.bin')

Drucken Sie das gespeicherte Modell abschließend wie folgt aus:

print(new_model)

Vollständiges Implementierungsbeispiel

from gensim.models import Word2Vec
sentences = [
   ['this', 'is', 'gensim', 'tutorial', 'for', 'free'],
   ['this', 'is', 'the', 'tutorials' 'point', 'website'],
   ['you', 'can', 'read', 'technical','tutorials', 'for','free'],
   ['we', 'are', 'implementing','word2vec'],
   ['learn', 'full', 'gensim', 'tutorial']
]
model = Word2Vec(sentences, min_count=1)
print(model)
words = list(model.wv.vocab)
print(words)
print(model['tutorial'])
model.save('model.bin')
new_model = Word2Vec.load('model.bin')
print(new_model)

Ausgabe

Word2Vec(vocab=20, size=100, alpha=0.025)
[
   'this', 'is', 'gensim', 'tutorial', 'for', 'free', 'the', 'tutorialspoint', 
   'website', 'you', 'can', 'read', 'technical', 'tutorials', 'we', 'are', 
   'implementing', 'word2vec', 'learn', 'full'
]
[
   -2.5256255e-03 -4.5352755e-03 3.9024993e-03 -4.9509313e-03
   -1.4255195e-03 -4.0217536e-03 4.9407515e-03 -3.5925603e-03
   -1.1933431e-03 -4.6682903e-03 1.5440651e-03 -1.4101702e-03
   3.5070938e-03 1.0914479e-03 2.3334436e-03 2.4452661e-03
   -2.5336299e-04 -3.9676363e-03 -8.5054158e-04 1.6443320e-03
   -4.9968651e-03 1.0974540e-03 -1.1123562e-03 1.5393364e-03
   9.8941079e-04 -1.2656028e-03 -4.4471184e-03 1.8309267e-03
   4.9302122e-03 -1.0032534e-03 4.6892050e-03 2.9563988e-03
   1.8730218e-03 1.5343715e-03 -1.2685956e-03 8.3664013e-04
   4.1721235e-03 1.9445885e-03 2.4097660e-03 3.7517555e-03
   4.9687522e-03 -1.3598346e-03 7.1032363e-04 -3.6595813e-03
   6.0000515e-04 3.0872561e-03 -3.2115565e-03 3.2270295e-03
   -2.6354722e-03 -3.4988276e-04 1.8574356e-04 -3.5757164e-03
   7.5391348e-04 -3.5205986e-03 -1.9795434e-03 -2.8321696e-03
   4.7155009e-03 -4.3349937e-04 -1.5320212e-03 2.7013756e-03
   -3.7055744e-03 -4.1658725e-03 4.8034848e-03 4.8594419e-03
   3.7129463e-03 4.2385766e-03 2.4612297e-03 5.4920948e-04
   -3.8912550e-03 -4.8226118e-03 -2.2763973e-04 4.5571579e-03
   -3.4609400e-03 2.7903817e-03 -3.2709218e-03 -1.1036445e-03
   2.1492650e-03 -3.0384419e-04 1.7709908e-03 1.8429896e-03
   -3.4038599e-03 -2.4872608e-03 2.7693063e-03 -1.6352943e-03
   1.9182395e-03 3.7772327e-03 2.2769428e-03 -4.4629495e-03
   3.3151123e-03 4.6509290e-03 -4.8521687e-03 6.7615538e-04
   3.1034781e-03 2.6369948e-05 4.1454583e-03 -3.6932561e-03
   -1.8769916e-03 -2.1958587e-04 6.3395966e-04 -2.4969708e-03
]
Word2Vec(vocab=20, size=100, alpha=0.025)

Visualisieren der Worteinbettung

Wir können auch die Worteinbettung mit Visualisierung untersuchen. Dies kann mithilfe einer klassischen Projektionsmethode (wie PCA) erfolgen, um die hochdimensionalen Wortvektoren auf 2D-Diagramme zu reduzieren. Einmal reduziert, können wir sie dann grafisch darstellen.

Zeichnen von Wortvektoren mit PCA

Zuerst müssen wir alle Vektoren aus einem trainierten Modell wie folgt abrufen:

Z = model[model.wv.vocab]

Als nächstes müssen wir ein 2-D-PCA-Modell von Wortvektoren erstellen, indem wir die PCA-Klasse wie folgt verwenden:

pca = PCA(n_components=2)
result = pca.fit_transform(Z)

Jetzt können wir die resultierende Projektion mithilfe der Matplotlib wie folgt zeichnen:

Pyplot.scatter(result[:,0],result[:,1])

Wir können die Punkte in der Grafik auch mit den Wörtern selbst versehen. Zeichnen Sie die resultierende Projektion mit der Matplotlib wie folgt:

words = list(model.wv.vocab)
for i, word in enumerate(words):
   pyplot.annotate(word, xy=(result[i, 0], result[i, 1]))

Vollständiges Implementierungsbeispiel

from gensim.models import Word2Vec
from sklearn.decomposition import PCA
from matplotlib import pyplot
sentences = [
   ['this', 'is', 'gensim', 'tutorial', 'for', 'free'],
	['this', 'is', 'the', 'tutorials' 'point', 'website'],
	['you', 'can', 'read', 'technical','tutorials', 'for','free'],
	['we', 'are', 'implementing','word2vec'],
	['learn', 'full', 'gensim', 'tutorial']
]
model = Word2Vec(sentences, min_count=1)
X = model[model.wv.vocab]
pca = PCA(n_components=2)
result = pca.fit_transform(X)
pyplot.scatter(result[:, 0], result[:, 1])
words = list(model.wv.vocab)
for i, word in enumerate(words):
   pyplot.annotate(word, xy=(result[i, 0], result[i, 1]))
pyplot.show()

Ausgabe

Das Doc2Vec-Modell wird im Gegensatz zum Word2Vec-Modell verwendet, um eine vektorisierte Darstellung einer Gruppe von Wörtern zu erstellen, die zusammen als eine Einheit betrachtet werden. Es gibt nicht nur den einfachen Durchschnitt der Wörter im Satz.

Erstellen von Dokumentvektoren mit Doc2Vec

Um Dokumentvektoren mit Doc2Vec zu erstellen, verwenden wir hier den Text8-Datensatz, der von heruntergeladen werden kann gensim.downloader.

Herunterladen des Datensatzes

Wir können den text8-Datensatz mit den folgenden Befehlen herunterladen:

import gensim
import gensim.downloader as api
dataset = api.load("text8")
data = [d for d in dataset]

Das Herunterladen des text8-Datensatzes dauert einige Zeit.

Trainiere den Doc2Vec

Um das Modell zu trainieren, benötigen wir das mit Tags versehene Dokument, das mithilfe von erstellt werden kann models.doc2vec.TaggedDcument() wie folgt -

def tagged_document(list_of_list_of_words):
   for i, list_of_words in enumerate(list_of_list_of_words):
      yield gensim.models.doc2vec.TaggedDocument(list_of_words, [i])
data_for_training = list(tagged_document(data))

Wir können den trainierten Datensatz wie folgt drucken:

print(data_for_training [:1])

Ausgabe

[TaggedDocument(words=['anarchism', 'originated', 'as', 'a', 'term', 'of',
'abuse', 'first', 'used', 'against', 'early', 'working', 'class', 'radicals',
'including', 'the', 'diggers', 'of', 'the', 'english', 'revolution', 
'and', 'the', 'sans', 'culottes', 'of', 'the', 'french', 'revolution',
'whilst', 'the', 'term', 'is', 'still', 'used', 'in', 'a', 'pejorative',
'way', 'to', 'describe', 'any', 'act', 'that', 'used', 'violent', 
'means', 'to', 'destroy',
'the', 'organization', 'of', 'society', 'it', 'has', 'also', 'been'
, 'taken', 'up', 'as', 'a', 'positive', 'label', 'by', 'self', 'defined',
'anarchists', 'the', 'word', 'anarchism', 'is', 'derived', 'from', 'the',
'greek', 'without', 'archons', 'ruler', 'chief', 'king', 'anarchism', 
'as', 'a', 'political', 'philosophy', 'is', 'the', 'belief', 'that', 
'rulers', 'are', 'unnecessary', 'and', 'should', 'be', 'abolished',
'although', 'there', 'are', 'differing', 'interpretations', 'of', 
'what', 'this', 'means', 'anarchism', 'also', 'refers', 'to', 
'related', 'social', 'movements', 'that', 'advocate', 'the', 
'elimination', 'of', 'authoritarian', 'institutions', 'particularly',
'the', 'state', 'the', 'word', 'anarchy', 'as', 'most', 'anarchists', 
'use', 'it', 'does', 'not', 'imply', 'chaos', 'nihilism', 'or', 'anomie',
'but', 'rather', 'a', 'harmonious', 'anti', 'authoritarian', 'society', 
'in', 'place', 'of', 'what', 'are', 'regarded', 'as', 'authoritarian',
'political', 'structures', 'and', 'coercive', 'economic', 'institutions', 
'anarchists', 'advocate', 'social', 'relations', 'based', 'upon', 'voluntary',
'association', 'of', 'autonomous', 'individuals', 'mutual', 'aid', 'and', 
'self', 'governance', 'while', 'anarchism', 'is', 'most', 'easily', 'defined',
'by', 'what', 'it', 'is', 'against', 'anarchists', 'also', 'offer', 
'positive', 'visions', 'of', 'what', 'they', 'believe', 'to', 'be', 'a',
'truly', 'free', 'society', 'however', 'ideas', 'about', 'how', 'an', 'anarchist',
'society', 'might', 'work', 'vary', 'considerably', 'especially', 'with',
'respect', 'to', 'economics', 'there', 'is', 'also', 'disagreement', 'about', 
'how', 'a', 'free', 'society', 'might', 'be', 'brought', 'about', 'origins', 
'and', 'predecessors', 'kropotkin', 'and', 'others', 'argue', 'that', 'before',
'recorded', 'history', 'human', 'society', 'was', 'organized', 'on', 'anarchist', 
'principles', 'most', 'anthropologists', 'follow', 'kropotkin', 'and', 'engels', 
'in', 'believing', 'that', 'hunter', 'gatherer', 'bands', 'were', 'egalitarian',
'and', 'lacked', 'division', 'of', 'labour', 'accumulated', 'wealth', 'or', 'decreed',
'law', 'and', 'had', 'equal', 'access', 'to', 'resources', 'william', 'godwin', 
'anarchists', 'including', 'the', 'the', 'anarchy', 'organisation', 'and', 'rothbard',
'find', 'anarchist', 'attitudes', 'in', 'taoism', 'from', 'ancient', 'china', 
'kropotkin', 'found', 'similar', 'ideas', 'in', 'stoic', 'zeno', 'of', 'citium', 
'according', 'to', 'kropotkin', 'zeno', 'repudiated', 'the', 'omnipotence', 'of',
'the', 'state', 'its', 'intervention', 'and', 'regimentation', 'and', 'proclaimed',
'the', 'sovereignty', 'of', 'the', 'moral', 'law', 'of', 'the', 'individual', 'the',
'anabaptists', 'of', 'one', 'six', 'th', 'century', 'europe', 'are', 'sometimes',
'considered', 'to', 'be', 'religious', 'forerunners', 'of', 'modern', 'anarchism',
'bertrand', 'russell', 'in', 'his', 'history', 'of', 'western', 'philosophy', 
'writes', 'that', 'the', 'anabaptists', 'repudiated', 'all', 'law', 'since', 
'they', 'held', 'that', 'the', 'good', 'man', 'will', 'be', 'guided', 'at', 
'every', 'moment', 'by', 'the', 'holy', 'spirit', 'from', 'this', 'premise',
'they', 'arrive', 'at', 'communism', 'the', 'diggers', 'or', 'true', 'levellers', 
'were', 'an', 'early', 'communistic', 'movement',
(truncated…)

Initialisieren Sie das Modell

Einmal trainiert, müssen wir jetzt das Modell initialisieren. es kann wie folgt gemacht werden -

model = gensim.models.doc2vec.Doc2Vec(vector_size=40, min_count=2, epochs=30)

Bauen Sie nun den Wortschatz wie folgt auf:

model.build_vocab(data_for_training)

Lassen Sie uns nun das Doc2Vec-Modell wie folgt trainieren:

model.train(data_for_training, total_examples=model.corpus_count, epochs=model.epochs)

Analyse der Ausgabe

Schließlich können wir die Ausgabe mithilfe von model.infer_vector () wie folgt analysieren:

print(model.infer_vector(['violent', 'means', 'to', 'destroy', 'the','organization']))

Vollständiges Implementierungsbeispiel

import gensim
import gensim.downloader as api
dataset = api.load("text8")
data = [d for d in dataset]
def tagged_document(list_of_list_of_words):
   for i, list_of_words in enumerate(list_of_list_of_words):
      yield gensim.models.doc2vec.TaggedDocument(list_of_words, [i])
data_for_training = list(tagged_document(data))
print(data_for_training[:1])
model = gensim.models.doc2vec.Doc2Vec(vector_size=40, min_count=2, epochs=30)
model.build_vocab(data_training)
model.train(data_training, total_examples=model.corpus_count, epochs=model.epochs)
print(model.infer_vector(['violent', 'means', 'to', 'destroy', 'the','organization']))

Ausgabe

[
   -0.2556166 0.4829361 0.17081228 0.10879577 0.12525807 0.10077011
   -0.21383236 0.19294572 0.11864349 -0.03227958 -0.02207291 -0.7108424
   0.07165232 0.24221905 -0.2924459 -0.03543589 0.21840079 -0.1274817
   0.05455418 -0.28968817 -0.29146606 0.32885507 0.14689675 -0.06913587
   -0.35173815 0.09340707 -0.3803535 -0.04030455 -0.10004586 0.22192696
   0.2384828 -0.29779273 0.19236489 -0.25727913 0.09140676 0.01265439
   0.08077634 -0.06902497 -0.07175519 -0.22583418 -0.21653089 0.00347822
   -0.34096122 -0.06176808 0.22885063 -0.37295452 -0.08222228 -0.03148199
   -0.06487323 0.11387568
]