L’affichage de points est une sorte de démonstration factuelle pour trouver les “sujets” uniques qui se produisent dans un assortiment de documents. La partie inactive de Dirichlet (LDA) est un cas de modèle à points et est utilisée pour ordonner les messages d’une archive à un sujet spécifique. Elle assemble un point pour chaque modèle d’archives et des mots par modèle de sujet, affichés sous forme de dispersions de Dirichlet.

L’information

La collection d’informations que nous utiliserons est un aperçu de plus d’un million de nouvelles réparties sur une période de 15 ans et peut être téléchargée sur Kaggle.

importer les pandas en tant que pd

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

data_text = données[[“headline_text”]]].

data_text[“index”] = data_text.index

documents = data_text

Jetez un coup d’œil aux données.

imprimer(len(documents))

imprimer(documents[:5])

Préparation de l’information

Nous allons jouer les avancées qui accompagnent ce projet :

La tokenisation : Diviser le contenu en phrases et les phrases en mots. Mettez les mots en minuscules et supprimez l’accentuation.

Les mots qui ont moins de 3 caractères sont évacués.

Tous les mots vides sont expulsés.

Les mots sont lemmatisés – les mots du troisième individu sont changés en premier individu et les mots d’action aux temps passé et futur sont changés en présent.

Les mots sont égrainés – les mots sont réduits à leur structure racinaire.

Chargement des bibliothèques gensim et nltk

import gensim

de gensim.utils import simple_preprocess

de gensim.parsing.preprocessing import STOPWORDS

de nltk.stem import WordNetLemmatizer, SnowballStemmer

de nltk.stem.porter import *

import numpy as np

np.random.seed(2018)

import nltk

nltk.download(‘wordnet’)

Télécharger le paquet wordnet sur

[nltk_data] C:\Users\SusanLi\AppData\Roaming\nltk_data…

[nltk_data] Le paquet wordnet est déjà à jour !

Vrai

Écrivez une fonction pour effectuer des étapes de lemmatisation et de prétraitement de l’ensemble des données.

def lemmatize_stemming(texte) :

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

def preprocess(texte) :

    résultat = []

    pour le jeton dans gensim.utils.simple_preprocess(text) :

        si le jeton n’est pas dans gensim.parsing.preprocessing.STOPWORDS et len(token) > 3 :

            result.append(lemmatize_stemming(token))

    résultat du retour

Sélectionnez un document à prévisualiser après le prétraitement.

doc_sample = documents [documents [index] == 4310].valeurs [0] [0]

imprimer(‘document original : ‘)

mots = []

pour le mot dans doc_sample.split(‘ ‘) :

    words.append(word)

print(words)

print(‘\n\n- document symbolisé et lemmatisé : ‘)

print(preprocess(doc_sample))

document original :

[pluie”, “aide”, “humidifier”, “feux de brousse”]

document symbolisé et lemmatisé :

[pluie”, “aide”, “humidité”, “brousse”]

Prétraiter le texte du titre, en enregistrant les résultats sous le nom de “processed_docs”.

processed_docs = documents[‘headline_text’].map(preprocess)

processed_docs[:10]

Pack de mots sur l’index informationnel

Créez un lexique à partir de “processed_docs” contenant les occasions où un mot apparaît dans le set de préparation.

dictionnaire = gensim.corpora.Dictionary(processed_docs)

compte = 0

pour k, v dans dictionary.iteritems() :

    print(k, v)

    compte += 1

    si le nombre est supérieur à 10 :

        pause

0 émission

1 communiti

2 décision

3 licence

4 prix

5 diffamation

6 esprit

7 appel

8 infrastructure

9 protéger

10 sommet

Filtre_extrêmes Gensim

Moins de 15 rapports (nombre suprême) ou

plus de 0,5 rapport (une partie de la taille du corpus complet, pas un nombre total).

après les deux étapes, ne conservez que les 100 000 premiers jetons les plus continus.

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

Gensim doc2bow

Pour chaque document, nous créons un dictionnaire indiquant combien

et combien de fois ces mots apparaissent. Sauvegardez ces informations dans le dossier “bow_corpus”, puis vérifiez le document sélectionné précédemment.

bow_corpus = [dictionary.doc2bow(doc) for doc in processed_docs]

bow_corpus [4310]

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

Prévisualisation du sac de mots pour notre échantillon de document prétraité.

bow_doc_4310 = bow_corpus [4310]

pour i dans la gamme(len(bow_doc_4310)) :

    print(“Word {} (\”{}\”) apparaît {} time.”.format(bow_doc_4310[i][0],

                                               dictionnaire [bow_doc_4310[i][0]],

bow_doc_4310[i][1]))

Le mot 76 (“bushfir”) apparaît 1 fois.

Le mot 112 (“aide”) apparaît 1 fois.

Le mot 483 (“pluie”) apparaît 1 fois.

Le mot 3998 (“dampen”) apparaît 1 fois.

TF-IDF

Faites un article de modèle tf-idf en utilisant models.TfidfModèle sur “bow_corpus” et mettez le en “tfidf”, à ce moment là, appliquez le changement à tout le corpus et appelez le “corpus_tfidf”. Nous voyons enfin les scores TF-IDF pour notre premier rapport.

Créer un objet modèle tf-idf à l’aide de models.TfidfModel sur “bow_corpus” et l’enregistrer dans “tfidf”, puis appliquer la transformation à l’ensemble du corpus et l’appeler “corpus_tfidf”. Enfin, nous prévisualisons les scores TF-IDF pour notre premier document.

de gensim import corpora, modèles

tfidf = modèles.TfidfModèle(bow_corpus)

corpus_tfidf = tfidf [bow_corpus]

de pprint import pprint

pour doc in corpus_tfidf :

    pprint(doc)

    pause

[(0, 0.5907943557842693),

(1, 0.3900924708457926),

(2, 0.49514546614015836),

(3, 0.5036078441840635)]

Exploitation de l’ADL à l’aide d’un ensemble de mots

Former notre modèle de lda en utilisant gensim.models.LdaMulticore et le mettre à la disposition de ‘lda_model’.

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

pour idx, sujet dans lda_model_tfidf.print_topics(-1) :

    print(‘Topic : {} Word : {}’.format(idx, topic))

Évaluation des performances par la classification d’un échantillon de document à l’aide du modèle de sac de mots de l’ADL

Nous allons vérifier où notre document de test serait classé.

processed_docs [4310]

[pluie”, “aide”, “humidité”, “brousse”]

pour l’indice, score dans sorted(lda_model[bow_corpus[4310]], key=lambda tup : -1*tup[1]) :

    print(“\nScore : {}\t \nTopic : {}”.format(score, lda_model.print_topic(index, 10))

Évaluation des performances par la classification d’un échantillon de document à l’aide du modèle TF-IDF de l’ADL.

pour l’indice, score dans sorted(lda_model_tfidf[bow_corpus[4310]], key=lambda tup : -1*tup[1]) :

    print(“\nScore : {}\t \nTopic : {}”.format(score, lda_model_tfidf.print_topic(index, 10))

Modèle d’essai sur un document non visible

unseen_document = “Comment un accord du Pentagone est devenu une crise d’identité pour Google

bow_vector = dictionnaire.doc2bow(preprocess(unseen_document))

pour l’indice, score dans sorted(lda_model[bow_vector], key=lambda tup : -1*tup[1]) :

    print(“Score : {}\t Topic : {}”.format(score, lda_model.print_topic(index, 5))