Die Punktdarstellung ist eine Art Sachdemonstration zum Auffinden der eindeutigen “Themen”, die in einer Reihe von Datensätzen vorkommen. Der inaktive Dirichlet-Abschnitt (LDA) ist ein Fall von Punktmodell und wird verwendet, um Nachrichten in einem Archiv zu einem bestimmten Thema zu ordnen. Es stellt einen Punkt für jedes Archivmodell und Wörter pro Themenmodell zusammen, die als Dirichlet-Dispersionen angezeigt werden.

Die Informationen

Die Informationssammlung, die wir verwenden werden, ist ein Überblick über mehr als eine Million Nachrichtenbeiträge, die über einen Zeitraum von 15 Jahren verteilt wurden und von Kaggle heruntergeladen werden können.

Pandas als pd importieren

Daten = pd.read_csv(‘abcnews-date-text.csv’, error_bad_lines=False);

Daten_Text = Daten[[[‘Überschrift_Text’]]]

daten_text[‘index’] = daten_text.index

Dokumente = Daten_Text

Werfen Sie einen Blick auf die Daten.

drucken(len(dokumente))

Drucken(Dokumente[:5])

Informationen vorbereiten

Wir werden die damit einhergehenden Fortschritte ausspielen:

Tokenisierung: Teilen Sie den Inhalt in Sätze und die Sätze in Wörter auf. Verkleinern Sie die Wörter und entfernen Sie die Akzentuierung.

Wörter, die weniger als 3 Zeichen haben, werden evakuiert.

Alle Stoppwörter werden ausgeschlossen.

Wörter werden lemmatisiert – Wörter in der dritten Person werden in die erste Person umgewandelt und Aktionswörter in Vergangenheits- und Zukunftszeiten werden in die Gegenwart umgewandelt.

Worte werden gestielt – Worte werden auf ihre Wurzelstruktur reduziert.

Laden von gensim- und nltk-Bibliotheken

Einfuhr gensim

aus gensim.utils importieren simple_preprocess

aus gensim.parsing.preprocessing importieren STOPWORDS

aus nltk.stem importieren WordNetLemmatizer, SnowballStemmer

aus nltk.stem.porter importieren *

numpy als np importieren

np.random.seed(2018)

importieren nltk

nltk.herunterladen (‘wordnet’)

[nltk_data] Herunterladen von Paketwordnet auf

C:\Benutzer\SusanLi\AppData\Roaming\nltk_data…

[nltk_data] Das Paket wordnet ist bereits auf dem neuesten Stand!

Wahr

Schreiben Sie eine Funktion, um Lemmatisierungs- und Stammvorverarbeitungsschritte auf dem Datensatz auszuführen.

def lemmatize_stemming(text):

    liefert stemmer.stem(WordNetLemmatizer().lemmatize(text, pos=’v’))

def-Vorverarbeitung(Text):

    Ergebnis = []

    für Token in gensim.utils.simple_preprocess(text):

        wenn Token nicht in gensim.parsing.preprocessing.STOPWORDS und len(token) > 3:

            result.append(lemmatize_stemming(token))

    Rückgabeergebnis

Wählen Sie ein Dokument aus, das nach der Vorverarbeitung in der Vorschau angezeigt werden soll.

doc_sample = dokumente[dokumente[‘index’] == 4310].werte[0][0]

drucken (‘Originaldokument: ‘)

Wörter = []

für Wort in doc_sample.split(‘ ‘):

    words.append(wort)

drucken(Wörter)

drucken (‘\n\n\n tokenisiertes und lemmatisiertes Dokument: ‘)

Drucken(Vorprozess(doc_sample))

Originaldokument:

[‘Regen’, ‘hilft’, ‘dämpfen’, ‘Buschfeuer’]

tokenisiertes und lemmatisiertes Dokument:

[‘Regen’, ‘Hilfe’, ‘Dämpfen’, ‘Buschfeuer’]

den Überschriftentext vorverarbeiten und die Ergebnisse als ‘processed_docs’ speichern

processed_docs = Dokumente[‘headline_text’].map(Vorprozess)

verarbeitete_docs[:10]

Wortpaket auf dem Informationsindex

Erstellen Sie ein Lexikon aus ‘processed_docs’, das die Gelegenheiten enthält, bei denen ein Wort im Vorbereitungssatz auftaucht.

Wörterbuch = gensim.corpora.Wörterbuch(processed_docs)

Anzahl = 0

für k, v in wörterbuch.iteritems():

    drucken(k, v)

    Anzahl += 1

    wenn Anzahl > 10:

        Pause

0 Ausstrahlung

1 Gemeinschaft

2 dezid

3 Lizenz

4 Krieg

5 verleumden

6 Witz

7 Anruf

8 Infrastruktur

9 schützen

10-Gipfel

Gensim filter_extremes

Weniger als 15 Berichte (höchste Zahl) oder

mehr als 0,5 Berichte (Teil des Gesamtkorpusumfangs, nicht eine Gesamtzahl).

Behalten Sie nach den mehr als zwei Stufen nur die anfänglichen 100000 kontinuierlichsten Marken.

dictionary.filter_extremes(no_below=15, no_above=0.5, keep_n=100000)

Gensim doc2bow

Für jedes Dokument erstellen wir ein Wörterbuch, das angibt, wie viele

Wörter und wie oft diese Wörter vorkommen. Speichern Sie dies unter ‘bow_corpus’, und prüfen Sie dann unser ausgewähltes Dokument vorher.

bow_corpus = [wörterbuch.doc2bow(doc) für doc in processed_docs]

bogen_korpus[4310]

[(76, 1), (112, 1), (483, 1), (3998, 1)]

Vorschau Bag Of Words für unser vorverarbeitetes Musterdokument.

bow_doc_4310 = bow_corpus[4310]

für i im Bereich(len(bow_doc_4310)):

    drucken (“Wort {} (\”{}\\”) erscheint {}Zeit.”.format(bow_doc_4310[i][0],

                                               wörterbuch[bow_doc_4310[i][0]],

bow_doc_4310[i][1]))

Wort 76 (“Buschfeuer”) erscheint 1 Mal.

Wort 112 (“Hilfe”) erscheint 1 Mal.

Wort 483 (“Regen”) erscheint 1 Mal.

Wort 3998 (“dämpfen”) erscheint 1 Mal.

TF-IDF

Erstellen Sie den Artikel tf-idf model unter Verwendung von models.TfidfModel auf ‘bow_corpus’ und ersparen Sie es sich für ‘tfidf’, wenden Sie an diesem Punkt Änderungen am gesamten Korpus an und nennen Sie ihn ‘corpus_tfidf’. Endlich sehen wir die TF-IDF-Bewertungen für unseren ersten Bericht.

Erstellen Sie ein tf-idf-Modellobjekt unter Verwendung von models.TfidfModel auf ‘bow_corpus’ und speichern Sie es in ‘tfidf’, wenden Sie dann die Transformation auf das gesamte Korpus an und nennen Sie es ‘corpus_tfidf’. Schließlich sehen wir eine Vorschau der TF-IDF-Ergebnisse für unser erstes Dokument.

aus gensim-Importkorpora, Modelle

tfidf = Modelle.tfidfModell(bow_corpus)

corpus_tfidf = tfidf[bug_corpus]

aus pprint importieren pprint

für doc in corpus_tfidf:

    pprint(doc)

    Pause

[(0, 0.5907943557842693),

(1, 0.3900924708457926),

(2, 0.49514546614015836),

(3, 0.5036078441840635)]

LDA unter Verwendung von Pack of Words

Trainieren Sie unser lda-Modell unter Verwendung von gensim.models.LdaMulticore und ersparen Sie es sich für ‘lda_model’.

lda_model_tfidf = gensim.models.LdaMulticore(corpus_tfidf, num_topics=10, id2word=Wörterbuch, passes=2, workers=4)

für idx, Thema in lda_model_tfidf.print_topics(-1):

    print(‘Thema: {} Wort: {}’.format(idx, Thema))

Leistungsbewertung durch Klassifizierung von Beispieldokumenten mit dem LDA Bag of Words-Modell

Wir werden prüfen, wo unser Testdokument klassifiziert werden würde.

processed_docs[4310]

[‘Regen’, ‘Hilfe’, ‘Dämpfen’, ‘Buschfeuer’]

für Index, Partitur in sortiert(lda_model[bow_corpus[4310]], Schlüssel=lambda tup: -1*tup[1]):

    drucken (“\nPunktzahl: {}t \nThema: {}”.format(Partitur, lda_modell.druck_thema(index, 10)))

Leistungsbewertung durch Klassifizierung von Beispieldokumenten mit dem LDA TF-IDF-Modell.

für Index, Partitur in sortiert(lda_model_tfidf[bow_corpus[4310]], Schlüssel=lambda tup: -1*tup[1]):

    drucken (“\nPunktzahl: {}t \nThema: {}”.format(Partitur, lda_model_tfidf.print_topic(index, 10)))

Testmodell auf ungesehenem Dokument

unseen_document = ‘Wie ein Pentagon-Deal zu einer Identitätskrise für Google wurde’.

bow_vector = wörterbuch.doc2bow(vorprozess(ungesehenes_dokument))

für Index, Punktzahl in sorted(lda_model[bow_vector], Schlüssel=lambda tup: -1*tup[1]):

    drucken (“Partitur: {}\t Thema: {}”.format(Partitur, lda_modell.print_thema(index, 5)))