Gensim - Guide rapide

Ce chapitre vous aidera à comprendre l'histoire et les fonctionnalités de Gensim ainsi que ses utilisations et avantages.

Qu'est-ce que Gensim?

Gensim = “Generate Similar”est une bibliothèque de traitement du langage naturel (NLP) open source populaire utilisée pour la modélisation de sujets non supervisée. Il utilise les meilleurs modèles académiques et l'apprentissage automatique statistique moderne pour effectuer diverses tâches complexes telles que -

• Création de documents ou de vecteurs de mots
• Corpora
• Effectuer l'identification du sujet
• Exécution de la comparaison de documents (récupération de documents sémantiquement similaires)
• Analyse de documents en texte brut pour la structure sémantique

Outre l'exécution des tâches complexes ci-dessus, Gensim, implémenté en Python et Cython, est conçu pour gérer de grandes collections de texte en utilisant le streaming de données ainsi que des algorithmes en ligne incrémentiels. Cela le différencie des progiciels d'apprentissage automatique qui ciblent uniquement le traitement en mémoire.

L'histoire

En 2008, Gensim a commencé comme une collection de divers scripts Python pour les mathématiques numériques tchèques. Là, il a servi à générer une courte liste des articles les plus similaires à un article donné. Mais en 2009, RARE Technologies Ltd. a publié sa version initiale. Puis, plus tard en juillet 2019, nous avons obtenu sa version stable (3.8.0).

Diverses caractéristiques

Voici quelques-unes des fonctionnalités et capacités offertes par Gensim -

Évolutivité

Gensim peut facilement traiter des corpus à grande échelle et à l'échelle du Web en utilisant ses algorithmes d'apprentissage en ligne incrémentiels. Il est de nature évolutive, car il n'est pas nécessaire que tout le corpus d'entrée réside entièrement dans la mémoire vive (RAM) à tout moment. En d'autres termes, tous ses algorithmes sont indépendants de la mémoire par rapport à la taille du corpus.

Robuste

Gensim est de nature robuste et est utilisé dans divers systèmes par diverses personnes et organisations depuis plus de 4 ans. Nous pouvons facilement brancher notre propre corpus d'entrée ou flux de données. Il est également très facile de l'étendre avec d'autres algorithmes d'espace vectoriel.

Agnostique de la plateforme

Comme nous le savons, Python est un langage très polyvalent car étant du pur Python Gensim fonctionne sur toutes les plates-formes (comme Windows, Mac OS, Linux) qui prennent en charge Python et Numpy.

Implémentations multicœurs efficaces

Afin d'accélérer le traitement et la récupération sur les grappes de machines, Gensim fournit des implémentations multicœurs efficaces de divers algorithmes populaires tels que Latent Semantic Analysis (LSA), Latent Dirichlet Allocation (LDA), Random Projections (RP), Hierarchical Dirichlet Process (HDP).

Open Source et abondance de soutien communautaire

Gensim est licencié sous la licence GNU LGPL approuvée par OSI qui lui permet d'être utilisé gratuitement à la fois pour un usage personnel et commercial. Toutes les modifications apportées à Gensim sont à leur tour open-source et bénéficient également du soutien de la communauté.

Utilisations de Gensim

Gensim a été utilisé et cité dans plus de mille applications commerciales et académiques. Il est également cité par divers articles de recherche et thèses d'étudiants. Il comprend des implémentations parallélisées en continu des éléments suivants:

fastText

fastText, utilise un réseau de neurones pour l'incorporation de mots, est une bibliothèque d'apprentissage de l'incorporation de mots et de la classification de texte. Il est créé par le laboratoire AI Research (FAIR) de Facebook. Ce modèle, en gros, nous permet de créer un algorithme supervisé ou non pour obtenir des représentations vectorielles des mots.

Word2vec

Word2vec, utilisé pour produire l'incorporation de mots, est un groupe de modèles de réseaux neuronaux superficiels et à deux couches. Les modèles sont essentiellement formés pour reconstruire les contextes linguistiques des mots.

LSA (analyse sémantique latente)

C'est une technique en NLP (Natural Language Processing) qui nous permet d'analyser les relations entre un ensemble de documents et leurs termes contenant. Cela se fait en produisant un ensemble de concepts liés aux documents et aux termes.

LDA (allocation de dirichlet latent)

C'est une technique en PNL qui permet d'expliquer des ensembles d'observations par des groupes non observés. Ces groupes non observés expliquent pourquoi certaines parties des données sont similaires. C'est la raison, c'est un modèle statistique génératif.

tf-idf (terme fréquence-fréquence de document inverse)

tf-idf, une statistique numérique dans la recherche d'informations, reflète l'importance d'un mot pour un document dans un corpus. Il est souvent utilisé par les moteurs de recherche pour noter et classer la pertinence d'un document en fonction d'une requête utilisateur. Il peut également être utilisé pour le filtrage de mots vides dans la synthèse et la classification de texte.

Tous seront expliqués en détail dans les sections suivantes.

Avantages

Gensim est un package NLP qui fait de la modélisation de sujets. Les avantages importants de Gensim sont les suivants -

• Nous pouvons obtenir les fonctionnalités de modélisation de sujet et d'incorporation de mots dans d'autres packages tels que ‘scikit-learn’ et ‘R’, mais les installations fournies par Gensim pour la création de modèles de sujets et l'incorporation de mots sont sans précédent. Il fournit également des fonctionnalités plus pratiques pour le traitement de texte.

• Un autre avantage le plus important de Gensim est qu'il nous permet de gérer de gros fichiers texte même sans charger le fichier entier en mémoire.

• Gensim ne nécessite pas d'annotations coûteuses ni d'étiquetage manuel des documents car il utilise des modèles non supervisés.

Le chapitre éclaire les conditions préalables à l'installation de Gensim, ses dépendances principales et des informations sur sa version actuelle.

Conditions préalables

Pour installer Gensim, nous devons avoir Python installé sur nos ordinateurs. Vous pouvez aller sur le lien www.python.org/downloads/ et sélectionner la dernière version pour votre système d'exploitation, à savoir Windows et Linux / Unix. Vous pouvez vous référer au lien pour un tutoriel de base sur Python. Gensim est pris en charge pour Linux, Windows et Mac OS X.

Dépendances du code

Gensim doit fonctionner sur n'importe quelle plateforme prenant en charge Python 2.7 or 3.5+ et NumPy. Cela dépend en fait du logiciel suivant -

Python

Gensim est testé avec les versions 2.7, 3.5, 3.6 et 3.7 de Python.

Numpy

Comme nous le savons, NumPy est un package pour le calcul scientifique avec Python. Il peut également être utilisé comme un conteneur multidimensionnel efficace de données génériques. Gensim dépend du package NumPy pour le calcul des nombres. Pour un tutoriel de base sur Python, vous pouvez vous référer au lien .

smart_open

smart_open, une bibliothèque Python 2 et Python 3, est utilisée pour le streaming efficace de très gros fichiers. Il prend en charge le streaming depuis / vers des stockages tels que S3, HDFS, WebHDFS, HTTP, HTTPS, SFTP ou des systèmes de fichiers locaux. Gensim dépend desmart_open Bibliothèque Python pour ouvrir de manière transparente des fichiers sur un stockage distant ainsi que des fichiers compressés.

Version actuelle

La version actuelle de Gensim est 3.8.0 qui a été publié en juillet 2019.

Installation à l'aide du terminal

L'un des moyens les plus simples d'installer Gensim consiste à exécuter la commande suivante dans votre terminal -

pip install --upgrade gensim

Installation à l'aide de l' environnement Conda

Une autre façon de télécharger Gensim est d'utiliser condaenvironnement. Exécutez la commande suivante dans votreconda terminal -

conda install –c conda-forge gensim

Installation à l'aide du package source

Supposons que si vous avez téléchargé et décompressé le paquet source, vous devez exécuter les commandes suivantes -

python setup.py test
python setup.py install

Ici, nous allons découvrir les concepts de base de Gensim, avec un accent principal sur les documents et le corpus.

Concepts de base de Gensim

Voici les principaux concepts et termes nécessaires pour comprendre et utiliser Gensim -

• Document - ZIl fait référence à un texte.

• Corpus - Il fait référence à une collection de documents.

• Vector - La représentation mathématique d'un document est appelée vecteur.

• Model - Il fait référence à un algorithme utilisé pour transformer des vecteurs d'une représentation à une autre.

Qu'est-ce qu'un document?

Comme discuté, il fait référence à un texte. Si nous allons dans les détails, il s'agit d'un objet du type séquence de texte qui est connu sous le nom de‘str’ dans Python 3. Par exemple, dans Gensim, un document peut être n'importe quoi tel que -

• Tweet court de 140 caractères
• Paragraphe unique, c.-à-d. Résumé d'article ou de document de recherche
• Article de presse
• Book
• Novel
• Theses

Séquence de texte

Un type de séquence de texte est communément appelé ‘str’ en Python 3. Comme on sait qu'en Python, les données textuelles sont gérées avec des chaînes ou plus spécifiquement ‘str’objets. Les chaînes sont essentiellement des séquences immuables de points de code Unicode et peuvent être écrites de la manière suivante -

• Single quotes - Par exemple, ‘Hi! How are you?’. Cela nous permet également d'incorporer des guillemets doubles. Par exemple,‘Hi! “How” are you?’

• Double quotes - Par exemple, "Hi! How are you?". Cela nous permet également d'intégrer des guillemets simples. Par exemple,"Hi! 'How' are you?"

• Triple quotes - Il peut avoir trois guillemets simples comme, '''Hi! How are you?'''. ou trois guillemets comme,"""Hi! 'How' are you?"""

Tous les espaces seront inclus dans la chaîne littérale.

Exemple

Voici un exemple de document dans Gensim -

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

Qu'est-ce que Corpus?

Un corpus peut être défini comme l'ensemble vaste et structuré de textes lisibles par machine produits dans un cadre de communication naturel. Dans Gensim, une collection d'objets document est appelée corpus. Le pluriel de corpus estcorpora.

Rôle du Corpus dans Gensim

Un corpus dans Gensim remplit les deux rôles suivants -

Sert d'entrée pour la formation d'un modèle

Le tout premier et important rôle qu'un corpus joue dans Gensim est celui de la formation d'un modèle. Afin d'initialiser les paramètres internes du modèle, au cours de la formation, le modèle recherche des thèmes et sujets communs dans le corpus de formation. Comme discuté ci-dessus, Gensim se concentre sur les modèles non supervisés, par conséquent, il ne nécessite aucune intervention humaine.

Sert d'extraction de sujets

Une fois le modèle entraîné, il peut être utilisé pour extraire des sujets des nouveaux documents. Ici, les nouveaux documents sont ceux qui ne sont pas utilisés dans la phase de formation.

Exemple

Le corpus peut inclure tous les tweets d'une personne en particulier, la liste de tous les articles d'un journal ou tous les documents de recherche sur un sujet particulier, etc.

Collecte de Corpus

Voici un exemple de petit corpus qui contient 5 documents. Ici, chaque document est une chaîne composée d'une seule phrase.

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",
]

Prétraitement du corpus de collecte

Une fois que nous avons collecté le corpus, quelques étapes de prétraitement doivent être prises pour que le corpus reste simple. Nous pouvons simplement supprimer certains mots anglais couramment utilisés comme «the». Nous pouvons également supprimer des mots qui n'apparaissent qu'une seule fois dans le corpus.

Par exemple, le script Python suivant est utilisé pour mettre en minuscules chaque document, le diviser par un espace blanc et filtrer les mots vides -

Exemple

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

Production

[['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']]

Prétraitement efficace

Gensim fournit également une fonction pour un prétraitement plus efficace du corpus. Dans ce type de prétraitement, nous pouvons convertir un document en une liste de jetons minuscules. Nous pouvons également ignorer les jetons qui sont trop courts ou trop longs. Une telle fonction estgensim.utils.simple_preprocess(doc, deacc=False, min_len=2, max_len=15).

gensim.utils.simple_preprocess() fucntion

Gensim fournit cette fonction pour convertir un document en une liste de jetons minuscules et aussi pour ignorer les jetons trop courts ou trop longs. Il a les paramètres suivants -

doc (str)

Il fait référence au document d'entrée sur lequel le prétraitement doit être appliqué.

deacc (booléen, facultatif)

Ce paramètre est utilisé pour supprimer les marques d'accentuation des jetons. Il utilisedeaccent() pour faire ça.

min_len (int, facultatif)

À l'aide de ce paramètre, nous pouvons définir la longueur minimale d'un jeton. Les jetons plus courts que la longueur définie seront supprimés.

max_len (int, facultatif)

Avec l'aide de ce paramètre, nous pouvons définir la longueur maximale d'un jeton. Les jetons plus longs que la longueur définie seront supprimés.

La sortie de cette fonction serait les jetons extraits du document d'entrée.

Ici, nous allons découvrir les concepts de base de Gensim, avec un accent principal sur le vecteur et le modèle.

Qu'est-ce que le vecteur?

Et si nous voulons inférer la structure latente de notre corpus? Pour cela, nous devons représenter les documents de manière à pouvoir les manipuler mathématiquement. Un type de représentation populaire consiste à représenter chaque document de corpus comme un vecteur de caractéristiques. C'est pourquoi nous pouvons dire que le vecteur est une représentation mathématique pratique d'un document.

Pour vous donner un exemple, représentons une seule fonctionnalité, de notre corpus utilisé ci-dessus, comme une paire QA -

Q - Combien de fois le mot Hello apparaissent dans le document?

A - Zéro (0).

Q - Combien de paragraphes y a-t-il dans le document?

A - Deux (2)

La question est généralement représentée par son identifiant entier, donc la représentation de ce document est une série de paires comme (1, 0.0), (2, 2.0). Une telle représentation vectorielle est connue sous le nom dedensevecteur. Pourquoidense, car il comprend une réponse explicite à toutes les questions écrites ci-dessus.

La représentation peut être un simple comme (0, 2), si nous connaissons toutes les questions à l'avance. Une telle séquence de réponses (bien sûr si les questions sont connues à l'avance) est lavector pour notre document.

Un autre type de représentation populaire est le bag-of-word (BoW)modèle. Dans cette approche, chaque document est essentiellement représenté par un vecteur contenant le décompte de fréquence de chaque mot du dictionnaire.

Pour vous donner un exemple, supposons que nous ayons un dictionnaire contenant les mots ['Hello', 'How', 'are', 'you']. Un document composé de la chaîne «Comment allez-vous comment» serait alors représenté par le vecteur [0, 2, 1, 1]. Ici, les entrées du vecteur sont dans l'ordre des occurrences de «Hello», «How», «are» et «you».

Vecteur contre document

D'après l'explication ci-dessus du vecteur, la distinction entre un document et un vecteur est presque comprise. Mais, pour être plus clair,document est du texte et vectorest une représentation mathématiquement pratique de ce texte. Malheureusement, il arrive que de nombreuses personnes utilisent ces termes de manière interchangeable.

Par exemple, supposons que nous ayons un document arbitraire A alors au lieu de dire «le vecteur qui correspond au document A», ils disaient «le vecteur A» ou «le document A». Cela conduit à une grande ambiguïté. Une autre chose importante à noter ici est que deux documents différents peuvent avoir la même représentation vectorielle.

Conversion de corpus en liste de vecteurs

Avant de prendre un exemple d'implémentation de la conversion du corpus en liste de vecteurs, nous devons associer chaque mot du corpus à un identifiant entier unique. Pour cela, nous allons étendre l'exemple pris dans le chapitre ci-dessus.

Exemple

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

Production

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

Cela montre que dans notre corpus il y a 25 jetons différents dans ce gensim.corpora.Dictionary.

Exemple d'implémentation

Nous pouvons utiliser le dictionnaire pour transformer des documents tokenisés en ces vecteurs à 5 diems comme suit -

pprint.pprint(dictionary.token2id)

Production

{
   '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
}

Et de même, nous pouvons créer la représentation sac de mots pour un document comme suit -

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

Production

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

Qu'est-ce que le modèle?

Une fois que nous avons vectorisé le corpus, que faire ensuite? Maintenant, nous pouvons le transformer à l'aide de modèles. Le modèle peut faire référence à un algorithme utilisé pour transformer une représentation de document en une autre.

Comme nous l'avons vu, les documents, dans Gensim, sont représentés comme des vecteurs, par conséquent, nous pouvons, bien que modéliser comme une transformation entre deux espaces vectoriels. Il y a toujours une phase de formation où les modèles apprennent les détails de ces transformations. Le modèle lit le corpus de formation pendant la phase de formation.

Initialiser un modèle

Initialisons tf-idfmodèle. Ce modèle transforme les vecteurs de la représentation BoW (Bag of Words) en un autre espace vectoriel où les comptages de fréquence sont pondérés en fonction de la rareté relative de chaque mot du corpus.

Exemple d'implémentation

Dans l'exemple suivant, nous allons initialiser le tf-idfmodèle. Nous allons l'entraîner sur notre corpus puis transformer la chaîne «arbre graph».

Exemple

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

Production

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

Maintenant, une fois que nous avons créé le modèle, nous pouvons transformer l'ensemble du corpus via tfidf et l'indexer, et interroger la similitude de notre document de requête (nous donnons le document de requête `` système d'arbres '') avec chaque document du corpus -

Exemple

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

Production

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

D'après les résultats ci-dessus, le document 4 et le document 5 ont un score de similitude d'environ 49%.

De plus, nous pouvons également trier cette sortie pour plus de lisibilité comme suit -

Exemple

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

Production

2 1.0
3 0.4869355
4 0.4869355
0 0.0
1 0.0

Dans le dernier chapitre où nous avons discuté du vecteur et du modèle, vous avez eu une idée du dictionnaire. Ici, nous allons discuterDictionary objet un peu plus en détail.

Qu'est-ce que le dictionnaire?

Avant de plonger dans le concept de dictionnaire, comprenons quelques concepts simples de PNL -

• Token - Un jeton signifie un «mot».

• Document - Un document fait référence à une phrase ou un paragraphe.

• Corpus - Il se réfère à une collection de documents comme un sac de mots (BoW).

Pour tous les documents, un corpus contient toujours l'identifiant du jeton de chaque mot ainsi que son décompte de fréquence dans le document.

Passons au concept de dictionnaire dans Gensim. Pour travailler sur des documents texte, Gensim demande également que les mots, c'est-à-dire les jetons, soient convertis en leurs identifiants uniques. Pour y parvenir, il nous donne la possibilité deDictionary object, qui mappe chaque mot à son identifiant entier unique. Pour ce faire, il convertit le texte d'entrée en liste de mots, puis le transmet aucorpora.Dictionary() objet.

Besoin d'un dictionnaire

Maintenant, la question se pose de savoir quel est réellement le besoin d'un objet dictionnaire et où peut-il être utilisé? Dans Gensim, l'objet dictionnaire est utilisé pour créer un corpus de sac de mots (BoW) qui est également utilisé comme entrée pour la modélisation de sujets et d'autres modèles.

Formes d'entrées de texte

Il existe trois formes différentes de texte d'entrée, que nous pouvons fournir à Gensim -

• Comme les phrases stockées dans l'objet de liste natif de Python (connu sous le nom de str en Python 3)

• En un seul fichier texte (peut être petit ou grand)

• Plusieurs fichiers texte

Créer un dictionnaire à l'aide de Gensim

Comme indiqué, dans Gensim, le dictionnaire contient le mappage de tous les mots, également appelés jetons, avec leur identifiant entier unique. Nous pouvons créer un dictionnaire à partir d'une liste de phrases, d'un ou plusieurs fichiers texte (fichier texte contenant plusieurs lignes de texte). Alors, commençons par créer un dictionnaire en utilisant une liste de phrases.

À partir d'une liste de phrases

Dans l'exemple suivant, nous allons créer un dictionnaire à partir d'une liste de phrases. Lorsque nous avons une liste de phrases ou que vous pouvez dire plusieurs phrases, nous devons convertir chaque phrase en une liste de mots et la compréhension est l'un des moyens les plus courants de le faire.

Exemple d'implémentation

Tout d'abord, importez les packages requis et nécessaires comme suit -

import gensim
from gensim import corpora
from pprint import pprint

Ensuite, créez la liste de compréhension à partir de la liste de phrases / document pour l'utiliser en créant le dictionnaire -

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."
]

Ensuite, nous devons diviser les phrases en mots. Cela s'appelle la tokenisation.

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

Maintenant, avec l'aide du script suivant, nous pouvons créer le dictionnaire -

dict_LoS = corpora.Dictionary(text_tokens)

Maintenant, obtenons plus d'informations comme le nombre de jetons dans le dictionnaire -

print(dict_LoS)

Production

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

Nous pouvons également voir le mappage mot à entier unique comme suit -

print(dict_LoS.token2id)

Production

{
   '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
}

Exemple d'implémentation complet

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)

À partir d'un seul fichier texte

Dans l'exemple suivant, nous allons créer un dictionnaire à partir d'un seul fichier texte. De la même manière, nous pouvons également créer un dictionnaire à partir de plus d'un fichier texte (c'est-à-dire répertoire de fichiers).

Pour cela, nous avons enregistré le document, utilisé dans l'exemple précédent, dans le fichier texte nommé doc.txt. Gensim lira le fichier ligne par ligne et traitera une ligne à la fois en utilisantsimple_preprocess. De cette façon, il n'a pas besoin de charger le fichier complet en mémoire en une seule fois.

Exemple d'implémentation

Tout d'abord, importez les packages requis et nécessaires comme suit -

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

La prochaine ligne de codes créera un dictionnaire gensim en utilisant le fichier texte unique nommé doc.txt -

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

Maintenant, obtenons plus d'informations comme le nombre de jetons dans le dictionnaire -

print(dict_STF)

Production

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

Nous pouvons également voir le mappage mot à entier unique comme suit -

print(dict_STF.token2id)

Production

{
   '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
}

Exemple d'implémentation complet

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)

À partir de plusieurs fichiers texte

Créons maintenant un dictionnaire à partir de plusieurs fichiers, c'est-à-dire plus d'un fichier texte enregistré dans le même répertoire. Pour cet exemple, nous avons créé trois fichiers texte différents, à savoirfirst.txt, second.txt et third.txtcontenant les trois lignes du fichier texte (doc.txt), nous avons utilisé pour l'exemple précédent. Tous ces trois fichiers texte sont enregistrés dans un répertoire nomméABC.

Exemple d'implémentation

Pour implémenter cela, nous devons définir une classe avec une méthode qui peut parcourir les trois fichiers texte (First, Second et Third.txt) dans le répertoire (ABC) et générer la liste traitée des jetons de mots.

Définissons la classe nommée Read_files avoir une méthode nommée __iteration__ () comme suit -

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)

Ensuite, nous devons fournir le chemin du répertoire comme suit -

path = "ABC"

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

Les étapes suivantes sont similaires à celles des exemples précédents. La prochaine ligne de codes créera le répertoire Gensim en utilisant le répertoire contenant trois fichiers texte -

dict_MUL = corpora.Dictionary(Read_files(path))

Production

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

Maintenant, nous pouvons également voir le mappage mot en entier unique comme suit -

print(dict_MUL.token2id)

Production

{
   '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
}

Enregistrer et charger un dictionnaire Gensim

Gensim soutient leur propre natif save() méthode pour enregistrer le dictionnaire sur le disque et load() méthode pour charger le dictionnaire à partir du disque.

Par exemple, nous pouvons enregistrer le dictionnaire à l'aide du script suivant -

Gensim.corpora.dictionary.save(filename)

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

De même, nous pouvons charger le dictionnaire enregistré en utilisant la méthode load (). Le script suivant peut le faire -

Gensim.corpora.dictionary.load(filename)

#provide the path where you have saved the dictionary.

Nous avons compris comment créer un dictionnaire à partir d'une liste de documents et de fichiers texte (à partir d'un comme de plusieurs). Maintenant, dans cette section, nous allons créer un corpus de sac de mots (BoW). Pour travailler avec Gensim, c'est l'un des objets les plus importants avec lesquels nous devons nous familiariser. En gros, c'est le corpus qui contient le mot id et sa fréquence dans chaque document.

Création d'un corpus BoW

Comme discuté, dans Gensim, le corpus contient le mot id et sa fréquence dans chaque document. Nous pouvons créer un corpus BoW à partir d'une simple liste de documents et de fichiers texte. Ce que nous devons faire est de transmettre la liste de mots tokenisés à l'objet nomméDictionary.doc2bow(). Commençons donc par créer un corpus BoW en utilisant une simple liste de documents.

À partir d'une simple liste de phrases

Dans l'exemple suivant, nous allons créer un corpus BoW à partir d'une simple liste contenant trois phrases.

Tout d'abord, nous devons importer tous les packages nécessaires comme suit -

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

Maintenant, fournissez la liste contenant les phrases. Nous avons trois phrases dans notre liste -

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

Ensuite, faites la tokenisation des phrases comme suit -

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

Créer un objet de corpora.Dictionary() comme suit -

dictionary = corpora.Dictionary()

Passez maintenant ces phrases symboliques à dictionary.doc2bow() objectcomme suit -

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

Enfin, nous pouvons imprimer Sac de corpus de mots -

print(BoW_corpus)

Production

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

La sortie ci-dessus montre que le mot avec id = 0 apparaît une fois dans le premier document (car nous avons (0,1) dans la sortie) et ainsi de suite.

La sortie ci-dessus est en quelque sorte impossible à lire pour les humains. Nous pouvons également convertir ces identifiants en mots, mais pour cela, nous avons besoin de notre dictionnaire pour effectuer la conversion comme suit -

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

Production

[
   [('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)]
]

Maintenant, la sortie ci-dessus est en quelque sorte lisible par l'homme.

Exemple d'implémentation complet

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)

À partir d'un fichier texte

Dans l'exemple suivant, nous allons créer un corpus BoW à partir d'un fichier texte. Pour cela, nous avons enregistré le document, utilisé dans l'exemple précédent, dans le fichier texte nommédoc.txt..

Gensim lira le fichier ligne par ligne et traitera une ligne à la fois en utilisant simple_preprocess. De cette façon, il n'a pas besoin de charger le fichier complet en mémoire en une seule fois.

Exemple d'implémentation

Tout d'abord, importez les packages requis et nécessaires comme suit -

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

Ensuite, la ligne de codes suivante fera lire les documents de doc.txt et les tokeniseront -

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

Maintenant, nous devons passer ces mots symboliques dans dictionary.doc2bow() objet (comme dans l'exemple précédent)

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

Production

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

le doc.txt le fichier a le contenu suivant -

CNTK, anciennement connue sous le nom de Computational Network Toolkit, est une boîte à outils gratuite et open-source de qualité commerciale qui nous permet de former des algorithmes d'apprentissage en profondeur pour apprendre comme le cerveau humain.

Vous pouvez trouver son tutoriel gratuit sur tutorialspoint.com qui fournit également les meilleurs tutoriels techniques sur des technologies telles que l'apprentissage automatique en profondeur par IA.

Exemple d'implémentation complet

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)

Enregistrer et charger un Corpus Gensim

Nous pouvons sauvegarder le corpus à l'aide du script suivant -

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.

De même, nous pouvons charger le corpus enregistré en utilisant le script suivant -

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

Ce chapitre vous aidera à découvrir les différentes transformations de Gensim. Commençons par comprendre les documents transformateurs.

Transformer des documents

Transformer des documents signifie représenter le document de manière à ce que le document puisse être manipulé mathématiquement. En plus de déduire la structure latente du corpus, la transformation des documents servira également les objectifs suivants -

• Il découvre la relation entre les mots.

• Il fait ressortir la structure cachée du corpus.

• Il décrit les documents d'une manière nouvelle et plus sémantique.

• Cela rend la représentation des documents plus compacte.

• Cela améliore l'efficacité car une nouvelle représentation consomme moins de ressources.

• Cela améliore l'efficacité car dans la nouvelle représentation, les tendances des données marginales sont ignorées.

• Le bruit est également réduit dans la nouvelle représentation de document.

Voyons les étapes de mise en œuvre pour transformer les documents d'une représentation d'espace vectoriel à une autre.

Étapes de mise en œuvre

Afin de transformer des documents, nous devons suivre les étapes suivantes -

Étape 1: Création du corpus

La toute première étape de base consiste à créer le corpus à partir des documents. Nous avons déjà créé le corpus dans les exemples précédents. Créons-en un autre avec quelques améliorations (en supprimant les mots courants et les mots qui n'apparaissent qu'une seule fois) -

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

Maintenant, fournissez les documents pour créer le corpus -

t_corpus = ["CNTK anciennement connu sous le nom de Computational Network Toolkit", "est une boîte à outils open-source gratuite et de qualité commerciale", "qui nous permet de former des algorithmes d'apprentissage en profondeur pour apprendre comme le cerveau humain.", " Vous pouvez trouver son tutoriel gratuit sur tutorialspoint.com "," Tutorialspoint.com propose également les meilleurs tutoriels techniques sur des technologies telles que l'apprentissage automatique en profondeur par IA "]

Ensuite, nous devons faire des jetons et avec cela, nous supprimerons également les mots communs -

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
]

Le script suivant supprimera les mots qui apparaissent uniquement -

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)

Production

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

Passez-le maintenant au corpora.dictionary() objet pour obtenir les objets uniques de notre corpus -

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

Production

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

Ensuite, la ligne de codes suivante créera le modèle Bag of Word pour notre corpus -

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

Production

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

Étape 2: création d'une transformation

Les transformations sont des objets Python standard. Nous pouvons initialiser ces transformations ie les objets Python en utilisant un corpus entraîné. Ici, nous allons utilisertf-idf modèle pour créer une transformation de notre corpus formé ie BoW_corpus.

Tout d'abord, nous devons importer le package de modèles depuis gensim.

from gensim import models

Maintenant, nous devons initialiser le modèle comme suit -

tfidf = models.TfidfModel(BoW_corpus)

Étape 3: Transformer les vecteurs

Maintenant, dans cette dernière étape, les vecteurs seront convertis de l'ancienne représentation en nouvelle représentation. Comme nous avons initialisé le modèle tfidf à l'étape ci-dessus, le tfidf sera désormais traité comme un objet en lecture seule. Ici, en utilisant cet objet tfidf, nous convertirons notre vecteur de la représentation du sac de mots (ancienne représentation) en poids réels Tfidf (nouvelle représentation).

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

Production

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

Nous avons appliqué la transformation sur deux valeurs de corpus, mais nous pouvons également l'appliquer à l'ensemble du corpus comme suit -

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

Production

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

Exemple d'implémentation complet

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)

Diverses transformations dans Gensim

En utilisant Gensim, nous pouvons implémenter diverses transformations populaires, à savoir des algorithmes de modèle d'espace vectoriel. Certains d'entre eux sont les suivants -

Tf-Idf (fréquence du terme-fréquence de document inverse)

Lors de l'initialisation, cet algorithme de modèle tf-idf attend un corpus d'apprentissage ayant des valeurs entières (comme le modèle Bag-of-Words). Ensuite, au moment de la transformation, il prend une représentation vectorielle et renvoie une autre représentation vectorielle.

Le vecteur de sortie aura la même dimensionnalité mais la valeur des caractéristiques rares (au moment de l'apprentissage) sera augmentée. Il convertit essentiellement les vecteurs à valeurs entières en vecteurs à valeurs réelles. Voici la syntaxe de la transformation Tf-idf -

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

LSI (indexation sémantique latente)

L'algorithme de modèle LSI peut transformer un document d'un modèle vectoriel à valeur entière (tel que le modèle Bag-of-Words) ou d'un espace pondéré Tf-Idf en espace latent. Le vecteur de sortie sera de dimensionnalité inférieure. Voici la syntaxe de la transformation LSI -

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

LDA (allocation de dirichlet latent)

L'algorithme de modèle LDA est un autre algorithme qui transforme le document de l'espace modèle Bag-of-Words en un espace thématique. Le vecteur de sortie sera de dimensionnalité inférieure. Voici la syntaxe de la transformation LSI -

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

Projections aléatoires (RP)

RP, une approche très efficace, vise à réduire la dimensionnalité de l'espace vectoriel. Cette approche est essentiellement une approximation des distances Tf-Idf entre les documents. Il le fait en ajoutant un peu de hasard.

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

Processus de Dirichlet hiérarchique (HDP)

HDP est une méthode bayésienne non paramétrique qui est un nouvel ajout à Gensim. Nous devrions avoir à faire attention lors de son utilisation.

Model=models.HdpModel(corpus, id2word=dictionary

Ici, nous allons apprendre à créer une matrice de fréquence de document à fréquence inversée (TF-IDF) avec l'aide de Gensim.

Qu'est-ce que TF-IDF?

Il s'agit du modèle de fréquence du terme-fréquence de document inversée qui est également un modèle de sac de mots. Il est différent du corpus normal car il réduit le poids des jetons, c'est-à-dire des mots apparaissant fréquemment dans les documents. Lors de l'initialisation, cet algorithme de modèle tf-idf attend un corpus d'apprentissage ayant des valeurs entières (comme le modèle Bag-of-Words).

Ensuite, au moment de la transformation, il prend une représentation vectorielle et renvoie une autre représentation vectorielle. Le vecteur de sortie aura la même dimensionnalité mais la valeur des caractéristiques rares (au moment de l'apprentissage) sera augmentée. Il convertit essentiellement les vecteurs à valeurs entières en vecteurs à valeurs réelles.

Comment est-il calculé?

Le modèle TF-IDF calcule tfidf en suivant deux étapes simples -

Étape 1: multiplier les composants locaux et mondiaux

Dans cette première étape, le modèle multipliera une composante locale telle que TF (Term Frequency) par une composante globale telle que IDF (Inverse Document Frequency).

Étape 2: normaliser le résultat

Une fois terminé avec la multiplication, à l'étape suivante, le modèle TFIDF normalisera le résultat à la longueur unitaire.

À la suite de ces deux étapes ci-dessus, les mots fréquemment utilisés dans les documents seront pondérés.

Comment obtenir des poids TF-IDF?

Ici, nous allons implémenter un exemple pour voir comment nous pouvons obtenir des poids TF-IDF. Fondamentalement, pour obtenir les pondérations TF-IDF, nous devons d'abord former le corpus, puis appliquer ce corpus dans le modèle tfidf.

Former le corpus

Comme indiqué ci-dessus, pour obtenir le TF-IDF, nous devons d'abord former notre corpus. Tout d'abord, nous devons importer tous les packages nécessaires comme suit -

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

Maintenant, fournissez la liste contenant les phrases. Nous avons trois phrases dans notre liste -

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

Ensuite, faites la tokenisation des phrases comme suit -

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

Créer un objet de corpora.Dictionary() comme suit -

dictionary = corpora.Dictionary()

Passez maintenant ces phrases symboliques à dictionary.doc2bow() objet comme suit -

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

Ensuite, nous obtiendrons les identifiants de mot et leurs fréquences dans nos documents.

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

Production

[['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]]

De cette manière, nous avons formé notre corpus (corpus Bag-of-Word).

Ensuite, nous devons appliquer ce corpus entraîné dans le modèle tfidf models.TfidfModel().

Importez d'abord le package numpay -

import numpy as np

Appliquant maintenant notre corpus entraîné (BoW_corpus) entre crochets models.TfidfModel()

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

Ensuite, nous obtiendrons les identifiants de mot et leurs fréquences dans notre corpus modélisé tfidf -

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

Production

[['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]]

À partir des sorties ci-dessus, nous voyons la différence dans les fréquences des mots dans nos documents.

Exemple d'implémentation complet

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

Différence de poids des mots

Comme indiqué ci-dessus, les mots qui apparaîtront plus fréquemment dans le document auront les poids les plus petits. Comprenons la différence de poids des mots entre les deux sorties ci-dessus. Le mot‘are’se produit dans deux documents et ont été lestés. De même, le mot‘you’ apparaissant dans tous les documents et supprimés complètement.

Ce chapitre traite de la modélisation des sujets concernant Gensim.

Pour annoter nos données et comprendre la structure des phrases, l'une des meilleures méthodes consiste à utiliser des algorithmes linguistiques informatiques. Sans aucun doute, avec l'aide de ces algorithmes linguistiques informatiques, nous pouvons comprendre quelques détails plus fins sur nos données, mais,

• Pouvons-nous savoir quels types de mots apparaissent plus souvent que d'autres dans notre corpus?

• Pouvons-nous regrouper nos données?

• Pouvons-nous être des thèmes sous-jacents dans nos données?

Nous pourrions réaliser tout cela avec l'aide de la modélisation de sujets. Examinons donc en profondeur le concept de modèles thématiques.

Que sont les modèles thématiques?

Un modèle de sujet peut être défini comme le modèle probabiliste contenant des informations sur les sujets de notre texte. Mais ici, deux questions importantes se posent qui sont les suivantes -

Première, what exactly a topic is?

Le sujet, comme son nom l'indique, concerne les idées sous-jacentes ou les thèmes représentés dans notre texte. Pour vous donner un exemple, le corpus contenantnewspaper articles aurait les sujets liés à finance, weather, politics, sports, various states news etc.

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

Comme nous savons que, afin d'identifier la similitude dans le texte, nous pouvons faire des techniques de recherche d'informations et de recherche en utilisant des mots. Mais, avec l'aide de modèles de sujets, nous pouvons maintenant rechercher et organiser nos fichiers texte en utilisant des sujets plutôt que des mots.

En ce sens, nous pouvons dire que les sujets sont la distribution probabiliste des mots. C'est pourquoi, en utilisant des modèles de sujets, nous pouvons décrire nos documents comme des distributions probabilistes de sujets.

Objectifs des modèles thématiques

Comme indiqué ci-dessus, la modélisation des sujets se concentre sur les idées et les thèmes sous-jacents. Ses principaux objectifs sont les suivants -

• Les modèles de sujets peuvent être utilisés pour la synthèse de texte.

• Ils peuvent être utilisés pour organiser les documents. Par exemple, nous pouvons utiliser la modélisation de sujets pour regrouper des articles de presse dans une section organisée / interconnectée, comme organiser tous les articles de presse liés àcricket.

• Ils peuvent améliorer les résultats de la recherche. Comment? Pour une requête de recherche, nous pouvons utiliser des modèles de sujets pour révéler le document contenant un mélange de mots-clés différents, mais qui ont la même idée.

• Le concept de recommandations est très utile pour le marketing. Il est utilisé par divers sites Web d'achats en ligne, sites Web d'actualités et bien d'autres. Les modèles de sujets aident à faire des recommandations sur ce qu'il faut acheter, ce qu'il faut lire ensuite, etc. Ils le font en trouvant des matériaux ayant un sujet commun dans la liste.

Algorithmes de modélisation de sujet dans Gensim

Sans aucun doute, Gensim est la boîte à outils de modélisation de sujet la plus populaire. Sa disponibilité gratuite et être en Python le rendent plus populaire. Dans cette section, nous discuterons de certains algorithmes de modélisation de sujets les plus populaires. Ici, nous nous concentrerons sur «quoi» plutôt que «comment» car Gensim les résume très bien pour nous.

Allocation de Dirichlet Latent (LDA)

L'allocation de Dirichlet latente (LDA) est la technique la plus courante et la plus populaire actuellement utilisée pour la modélisation de sujets. C'est celui que les chercheurs de Facebook ont ​​utilisé dans leur article de recherche publié en 2013. Il a été proposé pour la première fois par David Blei, Andrew Ng et Michael Jordan en 2003. Ils ont proposé LDA dans leur article intitulé simplementLatent Dirichlet allocation.

Caractéristiques de LDA

En savoir plus sur cette merveilleuse technique à travers ses caractéristiques -

Probabilistic topic modeling technique

LDA est une technique de modélisation probabiliste de sujets. Comme nous l'avons discuté ci-dessus, dans la modélisation de sujets, nous supposons que dans toute collection de documents interdépendants (il peut s'agir d'articles universitaires, d'articles de journaux, de publications Facebook, de Tweets, de courriers électroniques, etc.), il existe des combinaisons de sujets inclus dans chaque document. .

Le principal objectif de la modélisation probabiliste de sujets est de découvrir la structure de sujets cachés pour la collection de documents interdépendants. Les trois éléments suivants sont généralement inclus dans une structure thématique -

• Topics

• Répartition statistique des thèmes parmi les documents

• Mots dans un document comprenant le sujet

Work in an unsupervised way

LDA fonctionne de manière non supervisée. C'est parce que LDA utilise des probabilités conditionnelles pour découvrir la structure de rubrique cachée. Cela suppose que les sujets sont inégalement répartis dans la collection de documents interdépendants.

Very easy to create it in Gensim

Dans Gensim, il est très facile de créer un modèle LDA. nous devons juste spécifier le corpus, le mappage du dictionnaire et le nombre de sujets que nous aimerions utiliser dans notre modèle.

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

May face computationally intractable problem

Le calcul de la probabilité de chaque structure de sujet possible est un défi de calcul auquel LDA est confronté. C'est difficile car il doit calculer la probabilité de chaque mot observé sous chaque structure de sujet possible. Si nous avons un grand nombre de sujets et de mots, LDA peut faire face à un problème insoluble sur le plan informatique.

Indexation sémantique latente (LSI)

Les algorithmes de modélisation de sujets qui ont été implémentés pour la première fois dans Gensim avec Latent Dirichlet Allocation (LDA) est Latent Semantic Indexing (LSI). Il est également appeléLatent Semantic Analysis (LSA).

Il a été breveté en 1988 par Scott Deerwester, Susan Dumais, George Furnas, Richard Harshman, Thomas Landaur, Karen Lochbaum et Lynn Streeter. Dans cette section, nous allons configurer notre modèle LSI. Cela peut être fait de la même manière que pour la configuration du modèle LDA. nous devons importer le modèle LSI degensim.models.

Rôle de LSI

En fait, LSI est une technique NLP, en particulier dans la sémantique distributionnelle. Il analyse la relation entre un ensemble de documents et les termes que ces documents contiennent. Si nous parlons de son fonctionnement, alors il construit une matrice qui contient le nombre de mots par document à partir d'un grand morceau de texte.

Une fois construit, pour réduire le nombre de lignes, le modèle LSI utilise une technique mathématique appelée décomposition en valeurs singulières (SVD). En plus de réduire le nombre de lignes, il préserve également la structure de similitude entre les colonnes. Dans la matrice, les lignes représentent des mots uniques et les colonnes représentent chaque document. Il fonctionne sur la base d'une hypothèse distributionnelle, c'est-à-dire qu'il suppose que les mots dont le sens est proche apparaîtront dans le même type de texte.

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

Processus de Dirichlet hiérarchique (HDP)

Les modèles de sujets tels que LDA et LSI aident à résumer et à organiser de grandes archives de textes qu'il n'est pas possible d'analyser à la main. Outre LDA et LSI, un autre modèle de sujet puissant dans Gensim est HDP (Hierarchical Dirichlet Process). Il s'agit essentiellement d'un modèle à composition mixte pour une analyse non supervisée de données groupées. Contrairement à LDA (son homologue fini), HDP déduit le nombre de sujets à partir des données.

Model=models.HdpModel(corpus, id2word=dictionary

Ce chapitre vous aidera à apprendre à créer un modèle de rubrique d'allocation de Dirichlet latent (LDA) dans Gensim.

Extraction automatique d'informations sur des sujets à partir d'un grand volume de textes dans l'une des principales applications de la PNL (traitement du langage naturel). Un grand volume de textes peut être des flux de critiques d'hôtels, de tweets, de publications Facebook, de flux de tout autre canal de médias sociaux, des critiques de films, des actualités, des commentaires d'utilisateurs, des e-mails, etc.

Dans cette ère numérique, savoir de quoi parlent les gens / clients, comprendre leurs opinions et leurs problèmes peut être très précieux pour les entreprises, les campagnes politiques et les administrateurs. Mais, est-il possible de lire manuellement des volumes de texte aussi importants, puis d'extraire les informations des sujets?

Non ce n'est pas. Il nécessite un algorithme automatique capable de lire ces gros volumes de documents texte et d'en extraire automatiquement les informations / sujets dont il a été question.

Rôle de LDA

L'approche de LDA en matière de modélisation de sujet consiste à classer le texte d'un document dans un sujet particulier. Modélisés comme des distributions Dirichlet, LDA construit -

• Un sujet par modèle de document et
• Mots par modèle de sujet

Après avoir fourni l'algorithme de modèle de sujet LDA, afin d'obtenir une bonne composition de la distribution sujet-mot-clé, il réorganise -

• Les distributions des sujets dans le document et
• Répartition des mots-clés dans les rubriques

Lors du traitement, certaines des hypothèses formulées par LDA sont:

• Chaque document est modélisé sous forme de distributions multi-nominales de sujets.
• Chaque sujet est modélisé comme des distributions multi-nominales de mots.
• Nous devrions avoir à choisir le bon corpus de données car LDA suppose que chaque morceau de texte contient les mots associés.
• LDA suppose également que les documents sont produits à partir d'un mélange de sujets.

Implémentation avec Gensim

Ici, nous allons utiliser LDA (Latent Dirichlet Allocation) pour extraire les sujets naturellement discutés de l'ensemble de données.

Chargement de l'ensemble de données

L'ensemble de données que nous allons utiliser est l'ensemble de données de ’20 Newsgroups’avoir des milliers d'articles de presse provenant de différentes sections d'un reportage. Il est disponible sousSklearnensembles de données. Nous pouvons facilement télécharger à l'aide du script Python suivant -

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

Examinons quelques-unes des nouvelles exemples à l'aide du script suivant -

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: [email protected] (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']

Prérequis

Nous avons besoin de Stopwords de NLTK et d'un modèle anglais de Scapy. Les deux peuvent être téléchargés comme suit -

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

Importation des packages nécessaires

Afin de construire le modèle LDA, nous devons importer le package nécessaire suivant -

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

Préparation des mots vides

Maintenant, nous devons importer les mots vides et les utiliser -

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

Nettoyez le texte

Maintenant, avec l'aide de Gensim simple_preprocess()nous devons tokeniser chaque phrase en une liste de mots. Nous devons également supprimer les ponctuations et les caractères inutiles. Pour ce faire, nous allons créer une fonction nomméesent_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))

Création de modèles Bigram & Trigram

Comme nous le savons, les bigrammes sont deux mots qui apparaissent fréquemment ensemble dans le document et les trigrammes sont trois mots qui apparaissent fréquemment ensemble dans le document. Avec l'aide de Gensim'sPhrases modèle, nous pouvons le faire -

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)

Filtrer les mots vides

Ensuite, nous devons filtrer les mots vides. Parallèlement à cela, nous créerons également des fonctions pour créer des bigrammes, des trigrammes et pour la lemmatisation -

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

Construire un dictionnaire et un corpus pour un modèle de sujet

Nous devons maintenant construire le dictionnaire et le corpus. Nous l'avons également fait dans les exemples précédents -

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

Création d'un modèle de sujet LDA

Nous avons déjà mis en œuvre tout ce qui est nécessaire pour former le modèle LDA. Il est maintenant temps de créer le modèle de sujet LDA. Pour notre exemple de mise en œuvre, cela peut être fait à l'aide de la ligne de codes suivante -

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
)

Exemple d'implémentation

Voyons l'exemple complet d'implémentation pour créer un modèle de rubrique LDA -

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
)

Nous pouvons maintenant utiliser le modèle LDA créé ci-dessus pour obtenir les sujets, pour calculer la Perplexité du modèle.

Dans ce chapitre, nous allons comprendre comment utiliser le modèle de rubrique LDA (Latent Dirichlet Allocation).

Affichage des rubriques dans le modèle LDA

Le modèle LDA (lda_model) que nous avons créé ci-dessus peut être utilisé pour afficher les rubriques des documents. Cela peut être fait à l'aide du script suivant -

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

Production

[
   (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"')
]

Perplexité du modèle de calcul

Le modèle LDA (lda_model) que nous avons créé ci-dessus peut être utilisé pour calculer la perplexité du modèle, c'est-à-dire la qualité du modèle. Plus le score est bas, meilleur sera le modèle. Cela peut être fait à l'aide du script suivant -

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

Production

Perplexity: -12.338664984332151

Calcul du score de cohérence

Le modèle LDA (lda_model)nous avons créé ci-dessus peut être utilisé pour calculer le score de cohérence du modèle, c'est-à-dire la moyenne / médiane des scores de similitude de mots par paires des mots du sujet. Cela peut être fait à l'aide du script suivant -

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)

Production

Coherence Score: 0.510264381411751

Visualiser les thèmes-mots-clés

Le modèle LDA (lda_model)nous avons créé ci-dessus peut être utilisé pour examiner les sujets produits et les mots-clés associés. Il peut être visualisé en utilisantpyLDAvispaquet comme suit -

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

Production

À partir de la sortie ci-dessus, les bulles sur le côté gauche représentent un sujet et plus la bulle est grande, plus ce sujet est répandu. Le modèle de sujet sera bon si le modèle de sujet comporte de grandes bulles non superposées dispersées dans le graphique.

Ce chapitre explique ce qu'est un modèle de maillet d'allocation de dirichlet latent (LDA) et comment le créer dans Gensim.

Dans la section précédente, nous avons implémenté le modèle LDA et récupérons les sujets à partir de documents de l'ensemble de données 20Newsgroup. C'était la version intégrée de Gensim de l'algorithme LDA. Il existe également une version Mallet de Gensim, qui offre une meilleure qualité des sujets. Ici, nous allons appliquer le LDA de Mallet sur l'exemple précédent que nous avons déjà implémenté.

Qu'est-ce que le modèle LDA Mallet?

Mallet, une boîte à outils open source, a été écrite par Andrew McCullum. Il s'agit essentiellement d'un package basé sur Java qui est utilisé pour la PNL, la classification de documents, la mise en cluster, la modélisation de sujets et de nombreuses autres applications d'apprentissage automatique en texte. Il nous fournit la boîte à outils Mallet Topic Modeling qui contient des implémentations efficaces et basées sur l'échantillonnage de LDA ainsi que de LDA hiérarchique.

Mallet2.0 est la version actuelle de MALLET, la boîte à outils de modélisation de sujets Java. Avant de commencer à l'utiliser avec Gensim pour LDA, nous devons télécharger le paquet mallet-2.0.8.zip sur notre système et le décompresser. Une fois installé et décompressé, définissez la variable d'environnement% MALLET_HOME% sur le point vers le répertoire MALLET soit manuellement, soit par le code que nous fournirons, lors de l'implémentation du LDA avec Mallet ensuite.

Emballeuse Gensim

Python fournit un wrapper Gensim pour l'allocation de dirichlets latents (LDA). La syntaxe de ce wrapper estgensim.models.wrappers.LdaMallet. Ce module, un échantillonnage de gibbs réduit de MALLET, permet l'estimation du modèle LDA à partir d'un corpus d'apprentissage et l'inférence de la distribution des sujets sur de nouveaux documents invisibles.

Exemple d'implémentation

Nous utiliserons LDA Mallet sur un modèle LDA précédemment construit et vérifierons la différence de performance en calculant le score de Coherence.

Fournir le chemin vers le fichier Mallet

Avant d'appliquer le modèle Mallet LDA sur notre corpus construit dans l'exemple précédent, nous devons mettre à jour les variables d'environnement et fournir également le chemin du fichier Mallet. Cela peut être fait à l'aide du code suivant -

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.

Une fois que nous avons fourni le chemin d'accès au fichier Mallet, nous pouvons maintenant l'utiliser sur le corpus. Cela peut être fait avec l'aide deldamallet.show_topics() fonction comme suit -

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

Production

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

Évaluation des performances

Maintenant, nous pouvons également évaluer ses performances en calculant le score de cohérence comme suit -

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

Production

Coherence Score: 0.5842762900901401

Ce chapitre traite des documents et du modèle LDA dans Gensim.

Recherche du nombre optimal de sujets pour LDA

Nous pouvons trouver le nombre optimal de sujets pour LDA en créant de nombreux modèles LDA avec différentes valeurs de sujets. Parmi ces LDA, nous pouvons en choisir un qui a la valeur de cohérence la plus élevée.

Fonction suivante nommée coherence_values_computation()entraînera plusieurs modèles LDA. Il fournira également les modèles ainsi que leur score de cohérence correspondant -

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

Maintenant, à l'aide du code suivant, nous pouvons obtenir le nombre optimal de sujets que nous pouvons également afficher à l'aide d'un graphique -

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

Production

Ensuite, nous pouvons également imprimer les valeurs de cohérence pour divers sujets comme suit -

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

Production

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

Maintenant, la question se pose quel modèle devrions-nous choisir maintenant? L'une des bonnes pratiques consiste à choisir le modèle, qui donne la plus grande valeur de cohérence avant de flatter. C'est pourquoi, nous choisirons le modèle avec 25 sujets qui est au numéro 4 dans la liste ci-dessus.

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

Trouver des sujets dominants dans les phrases

Trouver des sujets dominants dans des phrases est l'une des applications pratiques les plus utiles de la modélisation de sujets. Il détermine le sujet sur lequel porte un document donné. Ici, nous trouverons le numéro de sujet qui a le pourcentage de contribution le plus élevé dans ce document particulier. Afin d'agréger les informations dans une table, nous allons créer une fonction nomméedominant_topics() -

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

Ensuite, nous obtiendrons les principaux sujets de chaque document -

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

Ensuite, nous obtiendrons le sujet dominant, la contribution en pourcentage et les mots clés pour chaque document -

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

À l'aide du code suivant, nous ajouterons le texte d'origine à la fin de la sortie -

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
)

Maintenant, faites le formatage des sujets dans les phrases comme suit -

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

Enfin, nous pouvons montrer les sujets dominants comme suit -

df_dominant_topic.head(15)

Recherche du document le plus représentatif

Afin de mieux comprendre le sujet, nous pouvons également trouver les documents, un sujet donné a le plus contribué. Nous pouvons déduire ce sujet en lisant ce (s) document (s) particulier (s).

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

Production

Volume et distribution des sujets

Parfois, nous voulons également juger de l'ampleur de la discussion du sujet dans les documents. Pour cela, nous devons comprendre le volume et la répartition des sujets dans les documents.

Calculez d'abord le nombre de documents pour chaque sujet comme suit -

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

Ensuite, calculez le pourcentage de documents pour chaque sujet comme suit -;

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

Recherchez maintenant le sujet Numéro et mots-clés comme suit -

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

Maintenant, concaténez puis Colonne comme suit -

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

Ensuite, nous allons changer les noms de colonnes comme suit -

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

Production

Ce chapitre traite de la création d'un modèle thématique d'indexation sémantique latente (LSI) et de processus de Dirichlet hiérarchique (HDP) en ce qui concerne Gensim.

Les algorithmes de modélisation de sujet qui ont été mis en œuvre pour la première fois dans Gensim avec l'allocation de dirichlet latente (LDA) est Latent Semantic Indexing (LSI). Il est également appeléLatent Semantic Analysis (LSA). Il a été breveté en 1988 par Scott Deerwester, Susan Dumais, George Furnas, Richard Harshman, Thomas Landaur, Karen Lochbaum et Lynn Streeter.

Dans cette section, nous allons configurer notre modèle LSI. Cela peut être fait de la même manière que pour la configuration du modèle LDA. Nous devons importer le modèle LSI degensim.models.

Rôle de LSI

En fait, LSI est une technique NLP, en particulier dans la sémantique distributionnelle. Il analyse la relation entre un ensemble de documents et les termes que ces documents contiennent. Si nous parlons de son fonctionnement, alors il construit une matrice qui contient le nombre de mots par document à partir d'un grand morceau de texte.

Une fois construit, pour réduire le nombre de lignes, le modèle LSI utilise une technique mathématique appelée décomposition en valeurs singulières (SVD). En plus de réduire le nombre de lignes, il préserve également la structure de similitude entre les colonnes.

Dans la matrice, les lignes représentent des mots uniques et les colonnes représentent chaque document. Il fonctionne sur la base d'une hypothèse distributionnelle, c'est-à-dire qu'il suppose que les mots dont le sens est proche apparaîtront dans le même type de texte.

Implémentation avec Gensim

Ici, nous allons utiliser LSI (Latent Semantic Indexing) pour extraire les sujets naturellement discutés de l'ensemble de données.

Chargement de l'ensemble de données

L'ensemble de données que nous allons utiliser est l'ensemble de données de ’20 Newsgroups’avoir des milliers d'articles de presse provenant de différentes sections d'un reportage. Il est disponible sousSklearnensembles de données. Nous pouvons facilement télécharger à l'aide du script Python suivant -

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

Examinons quelques-unes des nouvelles exemples à l'aide du script suivant -

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: [email protected] (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']

Prérequis

Nous avons besoin de Stopwords de NLTK et d'un modèle anglais de Scapy. Les deux peuvent être téléchargés comme suit -

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

Importation des packages nécessaires

Afin de construire le modèle LSI, nous devons importer le package nécessaire suivant -

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

Préparation des mots vides

Nous devons maintenant importer les mots vides et les utiliser -

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

Nettoyer le texte

Maintenant, avec l'aide de Gensim simple_preprocess()nous devons tokeniser chaque phrase en une liste de mots. Nous devons également supprimer les ponctuations et les caractères inutiles. Pour ce faire, nous allons créer une fonction nomméesent_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))

Création de modèles Bigram & Trigram

Comme nous le savons, les bigrammes sont deux mots qui se produisent fréquemment ensemble dans le document et les trigrammes sont trois mots qui apparaissent fréquemment ensemble dans le document. Avec l'aide du modèle Phrases de Gensim, nous pouvons le faire -

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)

Filtrer les mots vides

Ensuite, nous devons filtrer les mots vides. Parallèlement à cela, nous créerons également des fonctions pour créer des bigrammes, des trigrammes et pour la lemmatisation -

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

Construire un dictionnaire et un corpus pour un modèle de sujet

Nous devons maintenant construire le dictionnaire et le corpus. Nous l'avons également fait dans les exemples précédents -

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

Création d'un modèle de thème LSI

Nous avons déjà mis en œuvre tout ce qui est nécessaire pour former le modèle LSI. Il est maintenant temps de créer le modèle de sujet LSI. Pour notre exemple de mise en œuvre, cela peut être fait à l'aide de la ligne de codes suivante -

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

Exemple d'implémentation

Voyons l'exemple complet d'implémentation pour créer un modèle de rubrique LDA -

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
)

Nous pouvons maintenant utiliser le modèle LSI créé ci-dessus pour obtenir les rubriques.

Affichage des rubriques dans le modèle LSI

Le modèle LSI (lsi_model)nous avons créé ci-dessus peut être utilisé pour afficher les sujets à partir des documents. Cela peut être fait à l'aide du script suivant -

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

Production

[
   (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"')
]

Processus de Dirichlet hiérarchique (HPD)

Les modèles thématiques tels que LDA et LSI aident à résumer et à organiser de grandes archives de textes qu'il n'est pas possible d'analyser à la main. Outre LDA et LSI, un autre modèle de sujet puissant dans Gensim est HDP (Hierarchical Dirichlet Process). Il s'agit essentiellement d'un modèle à composition mixte pour une analyse non supervisée de données groupées. Contrairement à LDA (son homologue fini), HDP déduit le nombre de sujets à partir des données.

Implémentation avec Gensim

Pour implémenter HDP dans Gensim, nous devons former le corpus et le dictionnaire (comme l'ont fait les exemples ci-dessus lors de l'implémentation des modèles de sujets LDA et LSI) du modèle de sujet HDP que nous pouvons importer à partir de gensim.models.HdpModel. Ici aussi, nous allons implémenter le modèle de sujet HDP sur les données 20Newsgroup et les étapes sont également les mêmes.

Pour notre corpus et notre dictionnaire (créés dans les exemples ci-dessus pour les modèles LSI et LDA), nous pouvons importer HdpModel comme suit -

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

Affichage des rubriques dans le modèle LSI

Le modèle HDP (Hdp_model)peut être utilisé pour afficher les rubriques des documents. Cela peut être fait à l'aide du script suivant -

pprint(Hdp_model.print_topics())

Production

[
   (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')
]

Le chapitre nous aidera à comprendre le développement de l'intégration de mots dans Gensim.

L'incorporation de mots, approche pour représenter des mots et un document, est une représentation vectorielle dense pour le texte où les mots ayant la même signification ont une représentation similaire. Voici quelques caractéristiques de l'incorporation de mots -

• C'est une classe de technique qui représente les mots individuels sous forme de vecteurs à valeur réelle dans un espace vectoriel prédéfini.

• Cette technique est souvent regroupée dans le domaine du DL (apprentissage en profondeur) car chaque mot est mappé sur un vecteur et les valeurs vectorielles sont apprises de la même manière qu'un NN (Neural Networks).

• L'approche clé de la technique d'incorporation de mots est une représentation distribuée dense pour chaque mot.

Différentes méthodes / algorithmes d'incorporation de mots

Comme discuté ci-dessus, les méthodes / algorithmes d'incorporation de mots apprennent une représentation vectorielle à valeur réelle à partir d'un corpus de texte. Ce processus d'apprentissage peut être utilisé avec le modèle NN sur des tâches telles que la classification de documents ou est un processus non supervisé tel que les statistiques de documents. Ici, nous allons discuter de deux méthodes / algorithmes qui peuvent être utilisés pour apprendre un mot incorporé à partir de texte -

Word2Vec par Google

Word2Vec, développé par Tomas Mikolov, et. Al. chez Google en 2013, est une méthode statistique pour apprendre efficacement un mot incorporé à partir d'un corpus de texte. Il est en fait développé pour rendre la formation basée sur NN sur l'intégration de mots plus efficace. C'est devenu la norme de facto pour l'intégration de mots.

L'incorporation de mots par Word2Vec implique l'analyse des vecteurs appris ainsi que l'exploration des mathématiques vectorielles sur la représentation des mots. Voici les deux méthodes d'apprentissage différentes qui peuvent être utilisées dans le cadre de la méthode Word2Vec -

• Modèle CBoW (Continuous Bag of Words)
• Modèle Skip-Gram continu

GloVe par Standford

GloVe (Global vectors for Word Representation), est une extension de la méthode Word2Vec. Il a été développé par Pennington et al. à Stanford. L'algorithme GloVe est un mélange des deux -

• Statistiques globales des techniques de factorisation matricielle comme LSA (Latent Semantic Analysis)
• Apprentissage local basé sur le contexte dans Word2Vec.

Si nous parlons de son fonctionnement, au lieu d'utiliser une fenêtre pour définir le contexte local, GloVe construit une matrice de cooccurrence de mot explicite en utilisant des statistiques sur l'ensemble du corpus de texte.

Développement de l'intégration de Word2Vec

Ici, nous développerons l'incorporation de Word2Vec en utilisant Gensim. Afin de travailler avec un modèle Word2Vec, Gensim nous fournitWord2Vec classe qui peut être importée depuis models.word2vec. Pour sa mise en œuvre, word2vec nécessite beaucoup de texte, par exemple l'ensemble du corpus de critiques Amazon. Mais ici, nous appliquerons ce principe au texte de petite mémoire.

Exemple d'implémentation

Nous devons d'abord importer la classe Word2Vec de gensim.models comme suit -

from gensim.models import Word2Vec

Ensuite, nous devons définir les données d'entraînement. Plutôt que de prendre un gros fichier texte, nous utilisons des phrases pour implémenter ce principe.

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

Une fois les données de formation fournies, nous devons former le modèle. cela peut être fait comme suit -

model = Word2Vec(sentences, min_count=1)

Nous pouvons résumer le modèle comme suit -;

print(model)

Nous pouvons résumer le vocabulaire comme suit -

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

Ensuite, accédons au vecteur pour un mot. Nous le faisons pour le mot «tutoriel».

print(model['tutorial'])

Ensuite, nous devons enregistrer le modèle -

model.save('model.bin')

Ensuite, nous devons charger le modèle -

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

Enfin, imprimez le modèle enregistré comme suit -

print(new_model)

Exemple d'implémentation complet

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)

Production

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)

Visualiser l'incorporation de mots

Nous pouvons également explorer le mot intégration avec la visualisation. Cela peut être fait en utilisant une méthode de projection classique (comme PCA) pour réduire les vecteurs de mots de haute dimension à des tracés 2D. Une fois réduits, nous pouvons ensuite les tracer sur un graphique.

Tracer des vecteurs de mots à l'aide de PCA

Tout d'abord, nous devons récupérer tous les vecteurs d'un modèle entraîné comme suit -

Z = model[model.wv.vocab]

Ensuite, nous devons créer un modèle PCA 2D de vecteurs de mots en utilisant la classe PCA comme suit -

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

Maintenant, nous pouvons tracer la projection résultante en utilisant le matplotlib comme suit -

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

Nous pouvons également annoter les points sur le graphique avec les mots lui-même. Tracez la projection résultante en utilisant le matplotlib comme suit -

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

Exemple d'implémentation complet

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

Production

Le modèle Doc2Vec, contrairement au modèle Word2Vec, est utilisé pour créer une représentation vectorisée d'un groupe de mots pris collectivement comme une seule unité. Cela ne donne pas seulement la moyenne simple des mots de la phrase.

Création de vecteurs de documents à l'aide de Doc2Vec

Ici, pour créer des vecteurs de document à l'aide de Doc2Vec, nous utiliserons un ensemble de données text8 qui peut être téléchargé à partir de gensim.downloader.

Téléchargement de l'ensemble de données

Nous pouvons télécharger le jeu de données text8 en utilisant les commandes suivantes -

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

Le téléchargement du jeu de données text8 prendra un certain temps.

Former le Doc2Vec

Afin de former le modèle, nous avons besoin du document étiqueté qui peut être créé en utilisant models.doc2vec.TaggedDcument() comme suit -

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

Nous pouvons imprimer le jeu de données formé comme suit -

print(data_for_training [:1])

Production

[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…)

Initialiser le modèle

Une fois formés, nous devons maintenant initialiser le modèle. cela peut être fait comme suit -

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

Maintenant, construisez le vocabulaire comme suit -

model.build_vocab(data_for_training)

Maintenant, entraînons le modèle Doc2Vec comme suit -

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

Analyse de la sortie

Enfin, nous pouvons analyser la sortie en utilisant model.infer_vector () comme suit -

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

Exemple d'implémentation complet

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

Production

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