Gensim - Guida rapida

Questo capitolo ti aiuterà a comprendere la storia e le caratteristiche di Gensim insieme ai suoi usi e vantaggi.

Cos'è Gensim?

Gensim = “Generate Similar”è una popolare libreria di elaborazione del linguaggio naturale (NLP) open source utilizzata per la modellazione di argomenti senza supervisione. Utilizza i migliori modelli accademici e l'apprendimento automatico statistico moderno per eseguire vari compiti complessi come:

• Creazione di documenti o vettori di parole
• Corpora
• Esecuzione dell'identificazione dell'argomento
• Esecuzione del confronto di documenti (recupero di documenti semanticamente simili)
• Analisi di documenti di testo semplice per la struttura semantica

Oltre a svolgere le attività complesse di cui sopra, Gensim, implementato in Python e Cython, è progettato per gestire raccolte di testo di grandi dimensioni utilizzando lo streaming di dati e algoritmi online incrementali. Questo lo rende diverso da quei pacchetti software di machine learning che prendono di mira solo l'elaborazione in memoria.

Storia

Nel 2008, Gensim iniziò come una raccolta di vari script Python per la matematica digitale ceca. Lì, è servito a generare un breve elenco degli articoli più simili a un determinato articolo. Ma nel 2009, RARE Technologies Ltd. ha rilasciato la sua versione iniziale. Quindi, più tardi, a luglio 2019, abbiamo ottenuto la sua versione stabile (3.8.0).

Varie caratteristiche

Di seguito sono riportate alcune delle caratteristiche e delle capacità offerte da Gensim:

Scalabilità

Gensim può elaborare facilmente corpora di grandi dimensioni e su scala web utilizzando i suoi algoritmi di formazione online incrementali. È di natura scalabile, poiché non è necessario che l'intero corpus di input risieda completamente nella memoria ad accesso casuale (RAM) in qualsiasi momento. In altre parole, tutti i suoi algoritmi sono indipendenti dalla memoria rispetto alla dimensione del corpus.

Robusto

Gensim è robusto in natura ed è stato utilizzato in vari sistemi da varie persone e organizzazioni per oltre 4 anni. Possiamo facilmente collegare il nostro corpus di input o flusso di dati. È anche molto facile da estendere con altri algoritmi Vector Space.

Platform Agnostic

Come sappiamo che Python è un linguaggio molto versatile in quanto essendo Python puro Gensim gira su tutte le piattaforme (come Windows, Mac OS, Linux) che supportano Python e Numpy.

Implementazioni multicore efficienti

Al fine di accelerare l'elaborazione e il recupero sui cluster di macchine, Gensim fornisce implementazioni multicore efficienti di vari algoritmi popolari come Latent Semantic Analysis (LSA), Latent Dirichlet Allocation (LDA), Random Projections (RP), Hierarchical Dirichlet Process (HDP).

Open Source e abbondanza di supporto comunitario

Gensim è concesso in licenza con la licenza GNU LGPL approvata dall'OSI che ne consente l'uso gratuito sia per uso personale che commerciale. Qualsiasi modifica apportata in Gensim è a sua volta open-source e ha anche abbondanza di supporto della comunità.

Usi di Gensim

Gensim è stato utilizzato e citato in oltre mille applicazioni commerciali e accademiche. È anche citato da vari articoli di ricerca e tesi degli studenti. Include implementazioni parallele in streaming di quanto segue:

fastText

fastText, utilizza una rete neurale per l'incorporamento di parole, è una libreria per l'apprendimento dell'incorporamento di parole e della classificazione del testo. È stato creato dal laboratorio AI Research (FAIR) di Facebook. Questo modello, fondamentalmente, ci permette di creare un algoritmo supervisionato o non supervisionato per ottenere rappresentazioni vettoriali per parole.

Word2vec

Word2vec, utilizzato per produrre word embedding, è un gruppo di modelli di reti neurali superficiali ea due strati. I modelli sono fondamentalmente addestrati per ricostruire i contesti linguistici delle parole.

LSA (analisi semantica latente)

È una tecnica in PNL (Natural Language Processing) che ci permette di analizzare le relazioni tra un insieme di documenti e i termini che li contengono. Viene fatto producendo una serie di concetti relativi ai documenti e ai termini.

LDA (Latent Dirichlet Allocation)

È una tecnica della PNL che consente di spiegare insiemi di osservazioni a gruppi non osservati. Questi gruppi inosservati spiegano perché alcune parti dei dati sono simili. Questo è il motivo, è un modello statistico generativo.

tf-idf (termine frequenza del documento inversa)

tf-idf, una statistica numerica nel recupero delle informazioni, riflette quanto sia importante una parola per un documento in un corpus. Viene spesso utilizzato dai motori di ricerca per valutare e classificare la pertinenza di un documento in base a una query dell'utente. Può essere utilizzato anche per il filtraggio di parole non significative nel riepilogo e nella classificazione del testo.

Tutti saranno spiegati in dettaglio nelle prossime sezioni.

Vantaggi

Gensim è un pacchetto NLP che fa la modellazione di argomenti. Gli importanti vantaggi di Gensim sono i seguenti:

• Potremmo ottenere le funzionalità di modellazione di argomenti e incorporamento di parole in altri pacchetti come ‘scikit-learn’ e ‘R’, ma le strutture fornite da Gensim per la creazione di modelli di argomenti e l'incorporamento di parole non hanno eguali. Fornisce inoltre servizi più convenienti per l'elaborazione del testo.

• Un altro vantaggio più significativo di Gensim è che ci consente di gestire file di testo di grandi dimensioni anche senza caricare l'intero file in memoria.

• Gensim non richiede annotazioni costose o etichettatura manuale dei documenti perché utilizza modelli non supervisionati.

Il capitolo illustra i prerequisiti per l'installazione di Gensim, le sue dipendenze principali e le informazioni sulla sua versione corrente.

Prerequisiti

Per installare Gensim, dobbiamo avere Python installato sui nostri computer. Puoi andare al collegamento www.python.org/downloads/ e selezionare l'ultima versione per il tuo sistema operativo, ad esempio Windows e Linux / Unix. Puoi fare riferimento al link www.tutorialspoint.com/python3/index.htm per il tutorial di base su Python. Gensim è supportato per Linux, Windows e Mac OS X.

Dipendenze del codice

Gensim dovrebbe funzionare su qualsiasi piattaforma che supporti Python 2.7 or 3.5+ e NumPy. In realtà dipende dal seguente software:

Pitone

Gensim è testato con le versioni Python 2.7, 3.5, 3.6 e 3.7.

Numpy

Come sappiamo, NumPy è un pacchetto per il calcolo scientifico con Python. Può anche essere utilizzato come un efficiente contenitore multidimensionale di dati generici. Gensim dipende dal pacchetto NumPy per lo scricchiolio dei numeri. Per il tutorial di base su Python, puoi fare riferimento al link www.tutorialspoint.com/numpy/index.htm .

smart_open

smart_open, una libreria Python 2 e Python 3, viene utilizzata per lo streaming efficiente di file molto grandi. Supporta lo streaming da / a archivi come S3, HDFS, WebHDFS, HTTP, HTTPS, SFTP o file system locali. Gensim dipende dasmart_open Libreria Python per aprire in modo trasparente file su archiviazione remota e file compressi.

Versione corrente

La versione attuale di Gensim è 3.8.0 rilasciato nel luglio 2019.

Installazione tramite terminale

Uno dei modi più semplici per installare Gensim, è eseguire il seguente comando nel tuo terminale:

pip install --upgrade gensim

Installazione utilizzando l' ambiente Conda

Un modo alternativo per scaricare Gensim è usare condaambiente. Esegui il seguente comando nel tuo fileconda terminale -

conda install –c conda-forge gensim

Installazione utilizzando il pacchetto sorgente

Supponiamo che, se hai scaricato e decompresso il pacchetto sorgente, devi eseguire i seguenti comandi:

python setup.py test
python setup.py install

Qui apprenderemo i concetti fondamentali di Gensim, con focus principale sui documenti e sul corpus.

Concetti fondamentali di Gensim

Di seguito sono riportati i concetti e i termini fondamentali necessari per comprendere e utilizzare Gensim:

• Document - ZSi riferisce a un testo.

• Corpus - Si riferisce a una raccolta di documenti.

• Vector - La rappresentazione matematica di un documento è chiamata vettore.

• Model - Si riferisce a un algoritmo utilizzato per trasformare i vettori da una rappresentazione all'altra.

Cos'è il documento?

Come discusso, si riferisce a un testo. Se andiamo in qualche dettaglio, è un oggetto del tipo di sequenza di testo noto come‘str’ in Python 3. Ad esempio, in Gensim, un documento può essere qualsiasi cosa come -

• Breve tweet di 140 caratteri
• Singolo paragrafo, ad es. Articolo o abstract di un documento di ricerca
• Articolo di notizie
• Book
• Novel
• Theses

Sequenza di testo

Un tipo di sequenza di testo è comunemente noto come ‘str’ in Python 3. Come sappiamo che in Python, i dati testuali vengono gestiti con stringhe o più specificamente ‘str’oggetti. Le stringhe sono fondamentalmente sequenze immutabili di punti di codice Unicode e possono essere scritte nei seguenti modi:

• Single quotes - Ad esempio, ‘Hi! How are you?’. Ci permette anche di incorporare virgolette doppie. Per esempio,‘Hi! “How” are you?’

• Double quotes - Ad esempio, "Hi! How are you?". Ci permette anche di incorporare virgolette singole. Per esempio,"Hi! 'How' are you?"

• Triple quotes - Può avere tre virgolette singole come, '''Hi! How are you?'''. o tre virgolette doppie come,"""Hi! 'How' are you?"""

Tutti gli spazi saranno inclusi nella stringa letterale.

Esempio

Di seguito è riportato un esempio di un documento in Gensim:

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

Cos'è Corpus?

Un corpus può essere definito come l'insieme ampio e strutturato di testi leggibili dalla macchina prodotti in un contesto comunicativo naturale. In Gensim, una raccolta di oggetti documento è chiamata corpus. Il plurale di corpus ècorpora.

Ruolo del corpo in Gensim

Un corpus in Gensim svolge i seguenti due ruoli:

Serve come input per l'addestramento di un modello

Il primo e importante ruolo che un corpus gioca in Gensim è come input per la formazione di un modello. Per inizializzare i parametri interni del modello, durante l'addestramento, il modello cerca alcuni temi e argomenti comuni dal corpus formativo. Come discusso in precedenza, Gensim si concentra su modelli non supervisionati, quindi non richiede alcun tipo di intervento umano.

Funge da Topic Extractor

Una volta che il modello è stato addestrato, può essere utilizzato per estrarre argomenti dai nuovi documenti. Qui, i nuovi documenti sono quelli che non vengono utilizzati nella fase di formazione.

Esempio

Il corpus può includere tutti i tweet di una determinata persona, l'elenco di tutti gli articoli di un giornale o tutti i documenti di ricerca su un determinato argomento, ecc.

Raccolta di Corpus

Di seguito è riportato un esempio di piccolo corpus che contiene 5 documenti. Qui ogni documento è una stringa composta da una singola frase.

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

Preprocessing Collecting Corpus

Una volta raccolto il corpus, è necessario eseguire alcuni passaggi di preelaborazione per mantenerlo semplice. Possiamo semplicemente rimuovere alcune parole inglesi di uso comune come "the". Possiamo anche rimuovere le parole che ricorrono solo una volta nel corpus.

Ad esempio, il seguente script Python viene utilizzato per minuscolo ogni documento, dividerlo per uno spazio bianco e filtrare le parole di arresto:

Esempio

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

Produzione

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

Pre-elaborazione efficace

Gensim fornisce anche funzioni per una preelaborazione più efficace del corpo. In questo tipo di pre-elaborazione, possiamo convertire un documento in un elenco di token minuscoli. Possiamo anche ignorare i gettoni troppo corti o troppo lunghi. Tale funzione ègensim.utils.simple_preprocess(doc, deacc=False, min_len=2, max_len=15).

gensim.utils.simple_preprocess() fucntion

Gensim fornisce questa funzione per convertire un documento in un elenco di token minuscoli e anche per ignorare i token troppo corti o troppo lunghi. Ha i seguenti parametri:

doc (str)

Si riferisce al documento di input su cui deve essere applicata la preelaborazione.

deacc (bool, opzionale)

Questo parametro viene utilizzato per rimuovere i segni di accento dai token. Utilizzadeaccent() per farlo.

min_len (int, opzionale)

Con l'aiuto di questo parametro, possiamo impostare la lunghezza minima di un token. I gettoni più corti della lunghezza definita verranno scartati.

max_len (int, opzionale)

Con l'aiuto di questo parametro possiamo impostare la lunghezza massima di un token. I gettoni più lunghi della lunghezza definita verranno scartati.

L'output di questa funzione sarebbero i token estratti dal documento di input.

Qui impareremo i concetti fondamentali di Gensim, con focus principale sul vettore e sul modello.

Cos'è Vector?

E se volessimo dedurre la struttura latente nel nostro corpus? Per questo, dobbiamo rappresentare i documenti in modo tale da poterli manipolare matematicamente. Un tipo popolare di rappresentazione consiste nel rappresentare ogni documento del corpus come un vettore di caratteristiche. Ecco perché possiamo dire che il vettore è una comoda rappresentazione matematica di un documento.

Per darti un esempio, rappresentiamo una singola caratteristica, del nostro corpus sopra utilizzato, come una coppia QA -

Q - Quante volte fa la parola Hello compaiono nel documento?

A - Zero (0).

Q - Quanti paragrafi ci sono nel documento?

A - Due (2)

La domanda è generalmente rappresentata dal suo ID intero, quindi la rappresentazione di questo documento è una serie di coppie come (1, 0.0), (2, 2.0). Tale rappresentazione vettoriale è nota come adensevettore. Perchédense, perché comprende una risposta esplicita a tutte le domande scritte sopra.

La rappresentazione può essere un semplice come (0, 2), se conosciamo tutte le domande in anticipo. Tale sequenza delle risposte (ovviamente se le domande sono note in anticipo) è lavector per il nostro documento.

Un altro tipo di rappresentazione popolare è il bag-of-word (BoW)modello. In questo approccio, ogni documento è fondamentalmente rappresentato da un vettore contenente il conteggio della frequenza di ogni parola nel dizionario.

Per darti un esempio, supponiamo di avere un dizionario che contenga le parole ["Hello", "How", "are", "you"]. Un documento costituito dalla stringa "Come stai come" sarebbe quindi rappresentato dal vettore [0, 2, 1, 1]. Qui, le voci del vettore sono in ordine delle occorrenze di "Hello", "How", "are" e "you".

Vector contro documento

Dalla precedente spiegazione del vettore, la distinzione tra un documento e un vettore è quasi compresa. Ma, per renderlo più chiaro,document è testo e vectorè una rappresentazione matematicamente conveniente di quel testo. Sfortunatamente, a volte molte persone usano questi termini in modo intercambiabile.

Ad esempio, supponiamo di avere un documento A arbitrario, invece di dire "il vettore che corrisponde al documento A", dicevano "il vettore A" o "il documento A". Questo porta a una grande ambiguità. Un'altra cosa importante da notare qui è che due documenti diversi possono avere la stessa rappresentazione vettoriale.

Conversione di un corpus in un elenco di vettori

Prima di prendere un esempio di implementazione della conversione di un corpus nell'elenco di vettori, dobbiamo associare ogni parola nel corpus con un ID intero univoco. Per questo, estenderemo l'esempio preso nel capitolo precedente.

Esempio

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

Produzione

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

Mostra che nel nostro corpus ci sono 25 diversi gettoni in questo gensim.corpora.Dictionary.

Esempio di implementazione

Possiamo usare il dizionario per trasformare i documenti tokenizzati in questi vettori a 5 diemsional come segue:

pprint.pprint(dictionary.token2id)

Produzione

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

Allo stesso modo, possiamo creare la rappresentazione del bag of word per un documento come segue:

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

Produzione

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

Cos'è il modello?

Una volta vettorializzato il corpus, cosa succederà? Ora possiamo trasformarlo usando i modelli. Il modello può essere riferito a un algoritmo utilizzato per trasformare una rappresentazione del documento in un'altra.

Come abbiamo discusso, i documenti, in Gensim, sono rappresentati come vettori quindi, possiamo, sebbene modellare come una trasformazione tra due spazi vettoriali. C'è sempre una fase di formazione in cui i modelli apprendono i dettagli di tali trasformazioni. Il modello legge il corpus formativo durante la fase di formazione.

Inizializzazione di un modello

Inizializziamo tf-idfmodello. Questo modello trasforma i vettori dalla rappresentazione BoW (Bag of Words) in un altro spazio vettoriale in cui i conteggi di frequenza sono pesati in base alla rarità relativa di ogni parola nel corpus.

Esempio di implementazione

Nell'esempio seguente, inizializzeremo il file tf-idfmodello. Lo addestreremo sul nostro corpus e poi trasformeremo la stringa “tree graph”.

Esempio

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

Produzione

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

Ora, una volta creato il modello, possiamo trasformare l'intero corpus tramite tfidf e indicizzarlo e interrogare la somiglianza del nostro documento di query (stiamo dando il documento di query 'sistema ad albero') contro ogni documento nel corpus -

Esempio

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

Produzione

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

Dall'output di cui sopra, il documento 4 e il documento 5 hanno un punteggio di somiglianza di circa il 49%.

Inoltre, possiamo anche ordinare questo output per una maggiore leggibilità come segue:

Esempio

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

Produzione

2 1.0
3 0.4869355
4 0.4869355
0 0.0
1 0.0

Nell'ultimo capitolo in cui abbiamo discusso di vettore e modello, hai avuto un'idea del dizionario. Qui discuteremoDictionary oggetto un po 'più in dettaglio.

Cos'è Dictionary?

Prima di approfondire il concetto di dizionario, comprendiamo alcuni semplici concetti di PNL:

• Token - Un token significa una "parola".

• Document - Un documento fa riferimento a una frase o un paragrafo.

• Corpus - Si riferisce a una raccolta di documenti come un sacco di parole (BoW).

Per tutti i documenti, un corpus contiene sempre l'id del token di ogni parola insieme al conteggio della frequenza nel documento.

Passiamo al concetto di dizionario in Gensim. Per lavorare su documenti di testo, Gensim richiede anche che le parole, cioè i token, siano convertite nei loro ID univoci. Per raggiungere questo obiettivo, ci dà la possibilità diDictionary object, che mappa ogni parola al loro ID intero univoco. Lo fa convertendo il testo di input nell'elenco di parole e quindi passandolo al filecorpora.Dictionary() oggetto.

Bisogno di dizionario

Ora sorge la domanda che qual è effettivamente la necessità di un oggetto dizionario e dove può essere utilizzato? In Gensim, l'oggetto dizionario viene utilizzato per creare un corpus bag of words (BoW) che viene ulteriormente utilizzato come input per la modellazione di argomenti e altri modelli.

Forme di input di testo

Esistono tre diverse forme di testo di input, che possiamo fornire a Gensim:

• Poiché le frasi memorizzate nell'oggetto elenco nativo di Python (noto come str in Python 3)

• Come un unico file di testo (può essere piccolo o grande)

• Più file di testo

Creazione di un dizionario utilizzando Gensim

Come discusso, in Gensim, il dizionario contiene la mappatura di tutte le parole, ovvero i token, al loro ID intero univoco. Possiamo creare un dizionario da un elenco di frasi, da uno o più file di testo (file di testo contenenti più righe di testo). Quindi, per prima cosa iniziamo creando un dizionario usando l'elenco di frasi.

Da un elenco di frasi

Nell'esempio seguente creeremo un dizionario da un elenco di frasi. Quando abbiamo un elenco di frasi o puoi pronunciare più frasi, dobbiamo convertire ogni frase in un elenco di parole e le comprensioni è uno dei modi molto comuni per farlo.

Esempio di implementazione

Innanzitutto, importa i pacchetti richiesti e necessari come segue:

import gensim
from gensim import corpora
from pprint import pprint

Quindi, crea l'elenco di comprensione dall'elenco di frasi / documento per usarlo creando il dizionario -

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

Successivamente, dobbiamo dividere le frasi in parole. Si chiama tokenizzazione.

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

Ora, con l'aiuto del seguente script, possiamo creare il dizionario -

dict_LoS = corpora.Dictionary(text_tokens)

Ora otteniamo qualche informazione in più come il numero di gettoni nel dizionario -

print(dict_LoS)

Produzione

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

Possiamo anche vedere la parola per la mappatura di interi univoci come segue:

print(dict_LoS.token2id)

Produzione

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

Esempio di implementazione completo

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)

Da un singolo file di testo

Nell'esempio seguente creeremo il dizionario da un singolo file di testo. In modo simile, possiamo anche creare un dizionario da più di un file di testo (cioè directory di file).

Per questo, abbiamo salvato il documento, utilizzato nell'esempio precedente, nel file di testo denominato doc.txt. Gensim leggerà il file riga per riga ed elaborerà una riga alla volta utilizzandosimple_preprocess. In questo modo, non è necessario caricare il file completo in memoria tutto in una volta.

Esempio di implementazione

Innanzitutto, importa i pacchetti richiesti e necessari come segue:

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 prossima riga di codici creerà il dizionario gensim utilizzando il singolo file di testo denominato doc.txt -

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

Ora otteniamo qualche informazione in più come il numero di gettoni nel dizionario -

print(dict_STF)

Produzione

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

Possiamo anche vedere la parola per la mappatura di interi univoci come segue:

print(dict_STF.token2id)

Produzione

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

Esempio di implementazione completo

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)

Da più file di testo

Ora creiamo un dizionario da più file, cioè più di un file di testo salvato nella stessa directory. Per questo esempio, abbiamo creato tre diversi file di testo, vale a direfirst.txt, second.txt e third.txtcontenente le tre righe dal file di testo (doc.txt), abbiamo usato per l'esempio precedente. Tutti questi tre file di testo vengono salvati in una directory denominataABC.

Esempio di implementazione

Per implementare ciò, dobbiamo definire una classe con un metodo che possa iterare attraverso tutti e tre i file di testo (Primo, Secondo e Terzo.txt) nella directory (ABC) e fornire l'elenco elaborato di token di parole.

Definiamo la classe denominata Read_files avere un metodo chiamato __iteration__ () come segue -

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)

Successivamente, dobbiamo fornire il percorso della directory come segue:

path = "ABC"

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

I passaggi successivi sono simili a quelli che abbiamo fatto negli esempi precedenti. La prossima riga di codici creerà la directory Gensim utilizzando la directory con tre file di testo:

dict_MUL = corpora.Dictionary(Read_files(path))

Produzione

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

Ora possiamo anche vedere la parola per la mappatura di interi univoci come segue:

print(dict_MUL.token2id)

Produzione

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

Salvataggio e caricamento di un dizionario Gensim

Gensim sostiene il proprio nativo save() metodo per salvare il dizionario sul disco e load() metodo per caricare nuovamente il dizionario dal disco.

Ad esempio, possiamo salvare il dizionario con l'aiuto del seguente script:

Gensim.corpora.dictionary.save(filename)

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

Allo stesso modo, possiamo caricare il dizionario salvato usando il metodo load (). Lo script seguente può farlo -

Gensim.corpora.dictionary.load(filename)

#provide the path where you have saved the dictionary.

Abbiamo capito come creare un dizionario da un elenco di documenti e da file di testo (da uno così come da più di uno). Ora, in questa sezione, creeremo un corpus di bag of words (BoW). Per poter lavorare con Gensim, è uno degli oggetti più importanti con cui dobbiamo familiarizzare. Fondamentalmente, è il corpus che contiene la parola id e la sua frequenza in ogni documento.

Creazione di un BoW Corpus

Come discusso, in Gensim, il corpus contiene la parola id e la sua frequenza in ogni documento. Possiamo creare un corpus BoW da un semplice elenco di documenti e da file di testo. Quello che dobbiamo fare è passare l'elenco di parole tokenizzato all'oggetto denominatoDictionary.doc2bow(). Quindi, per prima cosa, iniziamo creando un corpus BoW utilizzando un semplice elenco di documenti.

Da un semplice elenco di frasi

Nell'esempio seguente, creeremo un corpus BoW da un semplice elenco contenente tre frasi.

Innanzitutto, dobbiamo importare tutti i pacchetti necessari come segue:

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

Fornisci ora l'elenco contenente le frasi. Abbiamo tre frasi nella nostra lista:

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

Quindi, eseguire la tokenizzazione delle frasi come segue:

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

Crea un oggetto di corpora.Dictionary() come segue -

dictionary = corpora.Dictionary()

Ora passa queste frasi tokenizzate a dictionary.doc2bow() objectcome segue -

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

Finalmente possiamo stampare Bag of word corpus -

print(BoW_corpus)

Produzione

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

L'output sopra mostra che la parola con id = 0 appare una volta nel primo documento (perché abbiamo (0,1) nell'output) e così via.

L'output di cui sopra non è in qualche modo possibile per gli esseri umani leggere. Possiamo anche convertire questi ID in parole, ma per questo abbiamo bisogno del nostro dizionario per eseguire la conversione come segue:

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

Produzione

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

Ora l'output di cui sopra è in qualche modo leggibile dall'uomo.

Esempio di implementazione completo

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)

Da un file di testo

Nel seguente esempio, creeremo un corpus BoW da un file di testo. Per questo, abbiamo salvato il documento, utilizzato nell'esempio precedente, nel file di testo denominatodoc.txt..

Gensim leggerà il file riga per riga ed elaborerà una riga alla volta utilizzando simple_preprocess. In questo modo, non è necessario caricare il file completo in memoria tutto in una volta.

Esempio di implementazione

Innanzitutto, importa i pacchetti richiesti e necessari come segue:

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

Successivamente, la seguente riga di codici farà leggere i documenti da doc.txt e li tokenizzerà -

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

Ora dobbiamo passare queste parole simbolizzate in dictionary.doc2bow() oggetto (come nell'esempio precedente)

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

Produzione

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

Il doc.txt il file ha il seguente contenuto:

CNTK precedentemente noto come Computational Network Toolkit è un toolkit di livello commerciale open source gratuito e facile da usare che ci consente di addestrare algoritmi di deep learning per apprendere come il cervello umano.

Puoi trovare il suo tutorial gratuito su tutorialspoint.com che fornisce anche i migliori tutorial tecnici su tecnologie come l'apprendimento automatico del deep learning AI gratuitamente.

Esempio di implementazione completo

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)

Salvataggio e caricamento di un corpus Gensim

Possiamo salvare il corpus con l'aiuto del seguente script:

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.

Allo stesso modo, possiamo caricare il corpus salvato utilizzando il seguente script:

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

Questo capitolo ti aiuterà a conoscere le varie trasformazioni in Gensim. Cominciamo con la comprensione dei documenti trasformanti.

Trasformazione dei documenti

Trasformare documenti significa rappresentare il documento in modo tale che il documento possa essere manipolato matematicamente. Oltre a dedurre la struttura latente del corpus, la trasformazione dei documenti servirà anche ai seguenti obiettivi:

• Scopre la relazione tra le parole.

• Mette in risalto la struttura nascosta nel corpus.

• Descrive i documenti in un modo nuovo e più semantico.

• Rende più compatta la rappresentazione dei documenti.

• Migliora l'efficienza perché la nuova rappresentazione consuma meno risorse.

• Migliora l'efficacia perché nella nuova rappresentazione le tendenze dei dati marginali vengono ignorate.

• Il rumore viene ridotto anche nella nuova rappresentazione del documento.

Vediamo i passaggi di implementazione per trasformare i documenti da una rappresentazione dello spazio vettoriale a un'altra.

Fasi di implementazione

Per trasformare i documenti, dobbiamo seguire i seguenti passaggi:

Passaggio 1: creazione del corpus

Il primo e fondamentale passaggio è creare il corpus dai documenti. Abbiamo già creato il corpus negli esempi precedenti. Creiamone un altro con alcuni miglioramenti (rimuovendo le parole comuni e le parole che compaiono una sola volta) -

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

Ora fornisci i documenti per creare il corpus -

t_corpus = ["CNTK precedentemente noto come Computational Network Toolkit", "è un toolkit di livello commerciale open source gratuito e facile da usare", "che ci consente di addestrare algoritmi di deep learning per imparare come il cervello umano.", " Puoi trovare il suo tutorial gratuito su tutorialspoint.com "," Tutorialspoint.com fornisce anche i migliori tutorial tecnici su tecnologie come il deep learning machine learning gratuito "]

Successivamente, dobbiamo fare tokenise e insieme ad esso rimuoveremo anche le parole comuni:

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
]

Lo script seguente rimuoverà solo quelle parole che appaiono -

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)

Produzione

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

Ora passalo al file corpora.dictionary() oggetto per ottenere gli oggetti unici nel nostro corpus -

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

Produzione

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

Successivamente, la seguente riga di codici creerà il modello Bag of Word per il nostro corpus:

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

Produzione

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

Passaggio 2: creazione di una trasformazione

Le trasformazioni sono alcuni oggetti Python standard. Possiamo inizializzare queste trasformazioni, cioè oggetti Python, usando un corpus addestrato. Qui useremotf-idf modello per creare una trasformazione del nostro corpus addestrato, ad es BoW_corpus.

Per prima cosa, dobbiamo importare il pacchetto dei modelli da gensim.

from gensim import models

Ora, dobbiamo inizializzare il modello come segue:

tfidf = models.TfidfModel(BoW_corpus)

Passaggio 3: trasformazione dei vettori

Ora, in quest'ultimo passaggio, i vettori verranno convertiti dalla vecchia rappresentazione alla nuova rappresentazione. Poiché abbiamo inizializzato il modello tfidf nel passaggio precedente, il tfidf verrà ora trattato come un oggetto di sola lettura. Qui, utilizzando questo oggetto tfidf convertiremo il nostro vettore dalla rappresentazione della borsa della parola (vecchia rappresentazione) a pesi reali Tfidf (nuova rappresentazione).

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

Produzione

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

Abbiamo applicato la trasformazione su due valori di corpus, ma possiamo anche applicarla all'intero corpus come segue:

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

Produzione

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

Esempio di implementazione completo

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)

Varie trasformazioni in Gensim

Usando Gensim, possiamo implementare varie trasformazioni popolari, cioè algoritmi di Vector Space Model. Alcuni di loro sono i seguenti:

Tf-Idf (frequenza termine-frequenza documento inverso)

Durante l'inizializzazione, questo algoritmo del modello tf-idf si aspetta un corpus di addestramento con valori interi (come il modello Bag-of-Words). Successivamente, al momento della trasformazione, prende una rappresentazione vettoriale e restituisce un'altra rappresentazione vettoriale.

Il vettore di output avrà la stessa dimensionalità ma il valore delle caratteristiche rare (al momento dell'addestramento) sarà aumentato. Fondamentalmente converte i vettori a valori interi in vettori a valori reali. Di seguito è riportata la sintassi della trasformazione Tf-idf:

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

LSI (Latent Semantic Indexing)

L'algoritmo del modello LSI può trasformare il documento da un modello vettoriale a valori interi (come il modello Bag-of-Words) o uno spazio ponderato Tf-Idf in spazio latente. Il vettore di output sarà di dimensionalità inferiore. Di seguito è riportata la sintassi della trasformazione LSI:

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

LDA (Latent Dirichlet Allocation)

L'algoritmo del modello LDA è un altro algoritmo che trasforma il documento dallo spazio modello Bag-of-Words in uno spazio argomento. Il vettore di output sarà di dimensionalità inferiore. Di seguito è riportata la sintassi della trasformazione LSI:

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

Proiezioni casuali (RP)

RP, un approccio molto efficiente, mira a ridurre la dimensionalità dello spazio vettoriale. Questo approccio è fondamentalmente approssimativo delle distanze Tf-Idf tra i documenti. Lo fa inserendo un po 'di casualità.

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

Processo gerarchico di Dirichlet (HDP)

HDP è un metodo bayesiano non parametrico che è una nuova aggiunta a Gensim. Dobbiamo fare attenzione durante l'utilizzo.

Model=models.HdpModel(corpus, id2word=dictionary

Qui impareremo come creare la matrice TF-IDF (Term Frequency-Inverse Document Frequency) con l'aiuto di Gensim.

Cos'è TF-IDF?

È il modello Term Frequency-Inverse Document Frequency che è anche un modello di borsa di parole. È diverso dal corpus regolare perché appesantisce i token, ovvero le parole che compaiono frequentemente nei documenti. Durante l'inizializzazione, questo algoritmo del modello tf-idf si aspetta un corpus di addestramento con valori interi (come il modello Bag-of-Words).

Successivamente, al momento della trasformazione, prende una rappresentazione vettoriale e restituisce un'altra rappresentazione vettoriale. Il vettore di output avrà la stessa dimensionalità ma il valore delle caratteristiche rare (al momento dell'addestramento) sarà aumentato. Fondamentalmente converte i vettori a valori interi in vettori a valori reali.

Come viene calcolato?

Il modello TF-IDF calcola tfidf con l'aiuto di due semplici passaggi:

Passaggio 1: moltiplicazione della componente locale e globale

In questa prima fase, il modello moltiplicherà una componente locale come TF (Term Frequency) con una componente globale come IDF (Inverse Document Frequency).

Passaggio 2: normalizza il risultato

Una volta eseguita la moltiplicazione, nel passaggio successivo il modello TFIDF normalizzerà il risultato alla lunghezza dell'unità.

Come risultato di questi due passaggi precedenti, le parole che si verificano di frequente nei documenti verranno ridimensionate.

Come ottenere i pesi TF-IDF?

Qui, implementeremo un esempio per vedere come ottenere i pesi TF-IDF. Fondamentalmente, per ottenere i pesi TF-IDF, prima dobbiamo addestrare il corpus e poi applicare quel corpus all'interno del modello tfidf.

Addestra il corpo

Come detto sopra per ottenere la TF-IDF dobbiamo prima addestrare il nostro corpus. Innanzitutto, dobbiamo importare tutti i pacchetti necessari come segue:

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

Fornisci ora l'elenco contenente le frasi. Abbiamo tre frasi nella nostra lista:

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

Quindi, eseguire la tokenizzazione delle frasi come segue:

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

Crea un oggetto di corpora.Dictionary() come segue -

dictionary = corpora.Dictionary()

Ora passa queste frasi tokenizzate a dictionary.doc2bow() oggetto come segue -

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

Successivamente, otterremo la parola id e le loro frequenze nei nostri documenti.

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

Produzione

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

In questo modo abbiamo addestrato il nostro corpus (Bag-of-Word corpus).

Successivamente, dobbiamo applicare questo corpus addestrato all'interno del modello tfidf models.TfidfModel().

Per prima cosa importa il pacchetto numpay -

import numpy as np

Ora applichiamo il nostro corpus addestrato (BoW_corpus) all'interno delle parentesi quadre di models.TfidfModel()

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

Successivamente, otterremo la parola id e le loro frequenze nel nostro corpus modellato tfidf -

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

Produzione

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

Dalle uscite di cui sopra, vediamo la differenza nelle frequenze delle parole nei nostri documenti.

Esempio di implementazione completo

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

Differenza di peso delle parole

Come discusso in precedenza, le parole che ricorrono più frequentemente nel documento avranno i pesi minori. Comprendiamo la differenza di peso delle parole dai due output precedenti. La parola‘are’si verifica in due documenti e sono stati appesantiti. Allo stesso modo, la parola‘you’ che appaiono in tutti i documenti e rimossi del tutto.

Questo capitolo tratta la modellazione degli argomenti rispetto a Gensim.

Per annotare i nostri dati e comprendere la struttura della frase, uno dei metodi migliori è utilizzare algoritmi linguistici computazionali. Senza dubbio, con l'aiuto di questi algoritmi linguistici computazionali possiamo comprendere alcuni dettagli più fini sui nostri dati ma,

• Possiamo sapere che tipo di parole compaiono più spesso di altre nel nostro corpus?

• Possiamo raggruppare i nostri dati?

• Possiamo essere temi alla base dei nostri dati?

Saremmo in grado di ottenere tutto ciò con l'aiuto della modellazione degli argomenti. Quindi approfondiamo il concetto di modelli di argomento.

Cosa sono i modelli di argomento?

Un modello di argomento può essere definito come il modello probabilistico contenente informazioni sugli argomenti nel nostro testo. Ma qui sorgono due domande importanti che sono le seguenti:

Primo, what exactly a topic is?

L'argomento, come suggerisce il nome, sono le idee sottostanti oi temi rappresentati nel nostro testo. Per farti un esempio, il corpus contenentenewspaper articles avrebbe gli argomenti relativi a finance, weather, politics, sports, various states news e così via.

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

Come sappiamo, per identificare la somiglianza nel testo, possiamo fare il recupero delle informazioni e le tecniche di ricerca usando le parole. Ma, con l'aiuto dei modelli di argomento, ora possiamo cercare e organizzare i nostri file di testo utilizzando argomenti anziché parole.

In questo senso possiamo dire che gli argomenti sono la distribuzione probabilistica delle parole. Ecco perché, utilizzando modelli di argomenti, possiamo descrivere i nostri documenti come distribuzioni probabilistiche di argomenti.

Obiettivi dei modelli di argomento

Come discusso in precedenza, il focus della modellazione degli argomenti riguarda idee e temi sottostanti. I suoi obiettivi principali sono i seguenti:

• I modelli di argomento possono essere utilizzati per il riepilogo del testo.

• Possono essere utilizzati per organizzare i documenti. Ad esempio, possiamo utilizzare la modellazione degli argomenti per raggruppare gli articoli di notizie in una sezione organizzata / interconnessa come organizzare tutti gli articoli di notizie relativi acricket.

• Possono migliorare i risultati della ricerca. Come? Per una query di ricerca, possiamo utilizzare modelli di argomento per rivelare il documento che contiene una combinazione di parole chiave diverse, ma sono circa la stessa idea.

• Il concetto di raccomandazioni è molto utile per il marketing. Viene utilizzato da vari siti Web di shopping online, siti Web di notizie e molti altri. I modelli di argomento aiutano a dare consigli su cosa comprare, cosa leggere dopo, ecc. Lo fanno trovando materiali che hanno un argomento comune nell'elenco.

Topic Modeling Algoritmi in Gensim

Indubbiamente, Gensim è il toolkit di modellazione di argomenti più popolare. La sua disponibilità gratuita e l'essere in Python lo rendono più popolare. In questa sezione, discuteremo alcuni algoritmi di modellazione di argomenti più popolari. Qui, ci concentreremo sul "cosa" piuttosto che sul "come" perché Gensim li astrarre molto bene per noi.

Latent Dirichlet Allocation (LDA)

L'allocazione latente di Dirichlet (LDA) è la tecnica più comune e popolare attualmente in uso per la modellazione di argomenti. È quello che i ricercatori di Facebook hanno utilizzato nel loro documento di ricerca pubblicato nel 2013. È stato proposto per la prima volta da David Blei, Andrew Ng e Michael Jordan nel 2003. Hanno proposto LDA nel loro articolo intitolato semplicementeLatent Dirichlet allocation.

Caratteristiche dell'LDA

Conosciamo meglio questa meravigliosa tecnica attraverso le sue caratteristiche -

Probabilistic topic modeling technique

LDA è una tecnica di modellazione di argomenti probabilistici. Come abbiamo discusso in precedenza, nella modellazione degli argomenti assumiamo che in qualsiasi raccolta di documenti correlati (potrebbero essere documenti accademici, articoli di giornale, post di Facebook, Tweet, e-mail e così via), ci sono alcune combinazioni di argomenti inclusi in ogni documento .

L'obiettivo principale della modellazione di argomenti probabilistici è scoprire la struttura di argomenti nascosti per la raccolta di documenti correlati. Le seguenti tre cose sono generalmente incluse in una struttura di argomenti:

• Topics

• Distribuzione statistica degli argomenti tra i documenti

• Parole in un documento che comprende l'argomento

Work in an unsupervised way

LDA funziona in modo non supervisionato. È perché LDA utilizza le probabilità condizionali per scoprire la struttura dell'argomento nascosto. Si presume che gli argomenti siano distribuiti in modo non uniforme nella raccolta di documenti correlati.

Very easy to create it in Gensim

In Gensim, è molto facile creare il modello LDA. abbiamo solo bisogno di specificare il corpus, la mappatura del dizionario e il numero di argomenti che vorremmo utilizzare nel nostro modello.

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

May face computationally intractable problem

Calcolare la probabilità di ogni possibile struttura di argomenti è una sfida computazionale affrontata da LDA. È impegnativo perché deve calcolare la probabilità di ogni parola osservata in ogni possibile struttura di argomenti. Se abbiamo un gran numero di argomenti e parole, LDA potrebbe dover affrontare problemi computazionalmente intrattabili.

Indicizzazione semantica latente (LSI)

Gli algoritmi di modellazione degli argomenti implementati per la prima volta in Gensim con Latent Dirichlet Allocation (LDA) è Latent Semantic Indexing (LSI). È anche chiamatoLatent Semantic Analysis (LSA).

È stato brevettato nel 1988 da Scott Deerwester, Susan Dumais, George Furnas, Richard Harshman, Thomas Landaur, Karen Lochbaum e Lynn Streeter. In questa sezione configureremo il nostro modello LSI. Può essere fatto nello stesso modo di impostare il modello LDA. dobbiamo importare il modello LSI dagensim.models.

Ruolo di LSI

In realtà, LSI è una tecnica PNL, soprattutto nella semantica distribuzionale. Analizza la relazione tra un insieme di documenti e i termini che questi documenti contengono. Se parliamo del suo funzionamento, allora costruisce una matrice che contiene i conteggi delle parole per documento da una grande porzione di testo.

Una volta costruito, per ridurre il numero di righe, il modello LSI utilizza una tecnica matematica chiamata SVD (singular value decomposition). Oltre a ridurre il numero di righe, preserva anche la struttura di somiglianza tra le colonne. Nella matrice, le righe rappresentano parole uniche e le colonne rappresentano ogni documento. Funziona sulla base di ipotesi distributive, cioè presuppone che le parole che hanno un significato simile si trovino nello stesso tipo di testo.

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

Processo gerarchico di Dirichlet (HDP)

I modelli tematici come LDA e LSI aiutano a riassumere e organizzare grandi archivi di testi che non è possibile analizzare a mano. Oltre a LDA e LSI, un altro potente modello di argomento in Gensim è HDP (Hierarchical Dirichlet Process). È fondamentalmente un modello di appartenenza mista per l'analisi senza supervisione di dati raggruppati. A differenza di LDA (la sua controparte finita), HDP deduce il numero di argomenti dai dati.

Model=models.HdpModel(corpus, id2word=dictionary

Questo capitolo ti aiuterà a imparare come creare un modello di argomenti di allocazione latente di Dirichlet (LDA) in Gensim.

Estrazione automatica di informazioni su argomenti da grandi volumi di testi in una delle principali applicazioni della PNL (elaborazione del linguaggio naturale). Un grande volume di testi potrebbe essere feed di recensioni di hotel, tweet, post di Facebook, feed di qualsiasi altro canale di social media, recensioni di film, notizie, feedback degli utenti, e-mail ecc.

In questa era digitale, sapere di cosa parlano le persone / clienti, capire le loro opinioni e i loro problemi, può essere molto prezioso per le imprese, le campagne politiche e gli amministratori. Ma è possibile leggere manualmente volumi di testo così grandi e quindi estrarre le informazioni dagli argomenti?

No non lo è. Richiede un algoritmo automatico in grado di leggere questi grandi volumi di documenti di testo ed estrarre automaticamente le informazioni / gli argomenti discussi da esso richiesti.

Ruolo di LDA

L'approccio di LDA alla modellazione degli argomenti consiste nel classificare il testo in un documento in un particolare argomento. Modellato come distribuzioni di Dirichlet, LDA costruisce -

• Un argomento per modello di documento e
• Parole per modello di argomento

Dopo aver fornito l'algoritmo del modello di argomento LDA, al fine di ottenere una buona composizione della distribuzione argomento-parola chiave, riorganizza:

• Le distribuzioni degli argomenti all'interno del documento e
• Distribuzione delle parole chiave all'interno degli argomenti

Durante l'elaborazione, alcune delle ipotesi formulate da LDA sono:

• Ogni documento è modellato come distribuzioni multi-nominali di argomenti.
• Ogni argomento è modellato come distribuzioni multi-nominali di parole.
• Dovremmo scegliere il corpus di dati corretto perché LDA presume che ogni porzione di testo contenga le parole correlate.
• LDA presume inoltre che i documenti siano prodotti da una combinazione di argomenti.

Implementazione con Gensim

Qui, useremo LDA (Latent Dirichlet Allocation) per estrarre gli argomenti discussi naturalmente dal set di dati.

Caricamento del set di dati

Il set di dati che useremo è il set di dati di ’20 Newsgroups’avere migliaia di articoli di notizie da varie sezioni di una notizia. È disponibile sottoSklearnset di dati. Possiamo facilmente scaricare con l'aiuto del seguente script Python -

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

Diamo un'occhiata ad alcune delle notizie di esempio con l'aiuto del seguente script:

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

Prerequisito

Abbiamo bisogno di Stopwords da NLTK e modello inglese da Scapy. Entrambi possono essere scaricati come segue:

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

Importazione dei pacchetti necessari

Per costruire il modello LDA dobbiamo importare il seguente pacchetto necessario:

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

Preparazione di parole non significative

Ora, dobbiamo importare le Stopword e usarle -

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

Pulisci il testo

Ora, con l'aiuto di Gensim simple_preprocess()abbiamo bisogno di tokenizzare ogni frase in un elenco di parole. Dovremmo anche rimuovere i segni di punteggiatura e i caratteri non necessari. Per fare ciò, creeremo una funzione denominatasent_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))

Costruire modelli bigram e trigram

Come sappiamo, i bigram sono due parole che ricorrono frequentemente insieme nel documento e il trigramma sono tre parole che ricorrono frequentemente insieme nel documento. Con l'aiuto di Gensim'sPhrases modello, possiamo farlo -

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)

Filtra le parole non significative

Successivamente, dobbiamo filtrare le Stopwords. Insieme a ciò, creeremo anche funzioni per creare bigram, trigram e per lemmatizzazione -

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

Dizionario di costruzione e corpus per il modello di argomento

Ora dobbiamo costruire il dizionario e il corpus. Lo abbiamo fatto anche negli esempi precedenti -

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

Creazione di un modello di argomento LDA

Abbiamo già implementato tutto ciò che è necessario per addestrare il modello LDA. Ora è il momento di costruire il modello di argomento LDA. Per il nostro esempio di implementazione, può essere fatto con l'aiuto della seguente riga di codici:

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
)

Esempio di implementazione

Vediamo l'esempio di implementazione completo per costruire il modello di argomento 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
)

Possiamo ora utilizzare il modello LDA creato sopra per ottenere gli argomenti, per calcolare la perplessità del modello.

In questo capitolo, capiremo come utilizzare il modello di argomento LDA (Latent Dirichlet Allocation).

Visualizzazione degli argomenti nel modello LDA

Il modello LDA (lda_model) che abbiamo creato sopra può essere utilizzato per visualizzare gli argomenti dai documenti. Può essere fatto con l'aiuto del seguente script:

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

Produzione

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

Perplessità del modello di calcolo

Il modello LDA (lda_model) che abbiamo creato sopra può essere utilizzato per calcolare la perplessità del modello, ovvero quanto è buono il modello. Più basso è il punteggio migliore sarà il modello. Può essere fatto con l'aiuto del seguente script:

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

Produzione

Perplexity: -12.338664984332151

Computing Coherence Score

Il modello LDA (lda_model)che abbiamo creato sopra può essere utilizzato per calcolare il punteggio di coerenza del modello, ovvero la media / mediana dei punteggi di somiglianza di parole a coppie delle parole nell'argomento. Può essere fatto con l'aiuto del seguente script:

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)

Produzione

Coherence Score: 0.510264381411751

Visualizzazione degli argomenti-parole chiave

Il modello LDA (lda_model)che abbiamo creato sopra può essere utilizzato per esaminare gli argomenti prodotti e le parole chiave associate. Può essere visualizzato utilizzandopyLDAvispacchetto come segue -

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

Produzione

Dall'output di cui sopra, le bolle sul lato sinistro rappresentano un argomento e più grande è la bolla, più prevalente è l'argomento. Il modello dell'argomento sarà valido se il modello dell'argomento ha grandi bolle non sovrapposte sparse in tutto il grafico.

Questo capitolo spiegherà cos'è un modello di mallet di allocazione latente di dirichlet (LDA) e come crearlo in Gensim.

Nella sezione precedente abbiamo implementato il modello LDA e ottenuto gli argomenti dai documenti del dataset 20Newsgroup. Quella era la versione incorporata di Gensim dell'algoritmo LDA. Esiste anche una versione Mallet di Gensim, che fornisce una migliore qualità degli argomenti. Qui, applicheremo l'LDA di Mallet all'esempio precedente che abbiamo già implementato.

Cos'è il modello Mallet LDA?

Mallet, un toolkit open source, è stato scritto da Andrew McCullum. È fondamentalmente un pacchetto basato su Java che viene utilizzato per la PNL, la classificazione dei documenti, il clustering, la modellazione degli argomenti e molte altre applicazioni di apprendimento automatico in testo. Ci fornisce il toolkit Mallet Topic Modeling che contiene implementazioni efficienti e basate sul campionamento di LDA e Hierarchical LDA.

Mallet2.0 è la versione corrente di MALLET, il toolkit di modellazione di argomenti java. Prima di iniziare a usarlo con Gensim per LDA, dobbiamo scaricare il pacchetto mallet-2.0.8.zip sul nostro sistema e decomprimerlo. Una volta installato e decompresso, impostare la variabile d'ambiente% MALLET_HOME% sul punto della directory MALLET manualmente o tramite il codice che forniremo, mentre implementeremo l'LDA con Mallet in seguito.

Gensim Wrapper

Python fornisce il wrapper Gensim per Latent Dirichlet Allocation (LDA). La sintassi di quel wrapper ègensim.models.wrappers.LdaMallet. Questo modulo, il campionamento delle gibbs compresso da MALLET, consente la stima del modello LDA da un corpus di formazione e l'inferenza della distribuzione degli argomenti anche su documenti nuovi e invisibili.

Esempio di implementazione

Useremo LDA Mallet sul modello LDA precedentemente costruito e controlleremo la differenza di prestazioni calcolando il punteggio di Coherence.

Fornire il percorso al file del martello

Prima di applicare il modello Mallet LDA sul nostro corpus costruito nell'esempio precedente, dobbiamo aggiornare le variabili di ambiente e fornire anche il percorso del file Mallet. Può essere fatto con l'aiuto del seguente codice:

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.

Una volta fornito il percorso al file Mallet, ora possiamo usarlo nel corpus. Può essere fatto con l'aiuto dildamallet.show_topics() funzionare come segue -

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

Produzione

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

Valutazione delle prestazioni

Ora possiamo anche valutarne le prestazioni calcolando il punteggio di coerenza come segue:

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

Produzione

Coherence Score: 0.5842762900901401

Questo capitolo discute i documenti e il modello LDA in Gensim.

Trovare il numero ottimale di argomenti per LDA

Possiamo trovare il numero ottimale di argomenti per LDA creando molti modelli LDA con vari valori di argomenti. Tra queste ADL possiamo sceglierne una con il valore di coerenza più elevato.

Funzione seguente denominata coherence_values_computation()addestrerà più modelli LDA. Fornirà anche i modelli e il punteggio di coerenza corrispondente -

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

Ora con l'aiuto del seguente codice, possiamo ottenere il numero ottimale di argomenti che possiamo mostrare anche con l'aiuto di un grafico -

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

Produzione

Successivamente, possiamo anche stampare i valori di coerenza per vari argomenti come segue:

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

Produzione

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

Ora, sorge la domanda su quale modello dovremmo scegliere ora? Una delle buone pratiche è scegliere il modello, cioè dare il massimo valore di coerenza prima di adulare. Ecco perché sceglieremo il modello con 25 argomenti che si trova al numero 4 nell'elenco sopra.

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

Trovare argomenti dominanti nelle frasi

Trovare argomenti dominanti nelle frasi è una delle applicazioni pratiche più utili della modellazione di argomenti. Determina di che argomento tratta un dato documento. Qui, troveremo quel numero di argomento che ha il contributo percentuale più alto in quel particolare documento. Per aggregare le informazioni in una tabella, creeremo una funzione denominatadominant_topics() -

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

Successivamente, otterremo gli argomenti principali in ogni documento:

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

Successivamente, otterremo l'argomento dominante, il contributo percentuale e le parole chiave per ogni documento:

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

Con l'aiuto del seguente codice, aggiungeremo il testo originale alla fine dell'output -

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
)

Ora, esegui la formattazione degli argomenti nelle frasi come segue:

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

Infine, possiamo mostrare gli argomenti dominanti come segue:

df_dominant_topic.head(15)

Trovare il documento più rappresentativo

Per capire di più sull'argomento, possiamo anche trovare i documenti, un determinato argomento ha contribuito di più. Possiamo dedurre quell'argomento leggendo quel particolare documento (i).

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

Produzione

Volume e distribuzione degli argomenti

A volte vogliamo anche giudicare l'ampiezza dell'argomento trattato nei documenti. Per questo abbiamo bisogno di comprendere il volume e la distribuzione degli argomenti nei documenti.

Calcola prima il numero di documenti per ogni argomento come segue:

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

Quindi, calcola la percentuale di documenti per ogni argomento come segue -;

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

Ora trova l'argomento Numero e parole chiave come segue:

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

Ora, concatena quindi la colonna saggia come segue:

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

Successivamente, cambieremo i nomi delle colonne come segue:

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

Produzione

Questo capitolo si occupa della creazione di modelli di argomenti LSI (Latent Semantic Indexing) e Hierarchical Dirichlet Process (HDP) per quanto riguarda Gensim.

Gli algoritmi di modellazione degli argomenti implementati per la prima volta in Gensim con Latent Dirichlet Allocation (LDA) sono Latent Semantic Indexing (LSI). È anche chiamatoLatent Semantic Analysis (LSA). È stato brevettato nel 1988 da Scott Deerwester, Susan Dumais, George Furnas, Richard Harshman, Thomas Landaur, Karen Lochbaum e Lynn Streeter.

In questa sezione configureremo il nostro modello LSI. Può essere fatto nello stesso modo di impostare il modello LDA. Dobbiamo importare il modello LSI dagensim.models.

Ruolo di LSI

In realtà, LSI è una tecnica PNL, soprattutto nella semantica distribuzionale. Analizza la relazione tra un insieme di documenti e i termini che questi documenti contengono. Se parliamo del suo funzionamento, allora costruisce una matrice che contiene i conteggi delle parole per documento da una grande porzione di testo.

Una volta costruito, per ridurre il numero di righe, il modello LSI utilizza una tecnica matematica chiamata SVD (singular value decomposition). Oltre a ridurre il numero di righe, preserva anche la struttura di somiglianza tra le colonne.

Nella matrice, le righe rappresentano parole uniche e le colonne rappresentano ogni documento. Funziona sulla base di ipotesi distributive, cioè presuppone che le parole che hanno un significato simile si trovino nello stesso tipo di testo.

Implementazione con Gensim

Qui utilizzeremo LSI (Latent Semantic Indexing) per estrarre gli argomenti discussi naturalmente dal set di dati.

Caricamento del set di dati

Il set di dati che useremo è il set di dati di ’20 Newsgroups’avere migliaia di articoli di notizie da varie sezioni di una notizia. È disponibile sottoSklearnset di dati. Possiamo facilmente scaricare con l'aiuto del seguente script Python -

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

Diamo un'occhiata ad alcune delle notizie di esempio con l'aiuto del seguente script:

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

Prerequisito

Abbiamo bisogno di Stopwords da NLTK e modello inglese da Scapy. Entrambi possono essere scaricati come segue:

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

Importazione dei pacchetti necessari

Per costruire il modello LSI dobbiamo importare il seguente pacchetto necessario:

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

Preparazione di parole non significative

Ora dobbiamo importare le Stopword e usarle -

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

Pulisci il testo

Ora, con l'aiuto di Gensim simple_preprocess()abbiamo bisogno di tokenizzare ogni frase in un elenco di parole. Dovremmo anche rimuovere i segni di punteggiatura e i caratteri non necessari. Per fare ciò, creeremo una funzione denominatasent_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))

Costruire modelli bigram e trigram

Come sappiamo, i bigram sono due parole che ricorrono frequentemente insieme nel documento e il trigramma sono tre parole che ricorrono frequentemente insieme nel documento. Con l'aiuto del modello Phrases di Gensim, possiamo farlo -

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)

Filtra le parole non significative

Successivamente, dobbiamo filtrare le Stopwords. Insieme a ciò, creeremo anche funzioni per creare bigram, trigram e per lemmatizzazione -

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

Dizionario di costruzione e corpus per il modello di argomento

Ora dobbiamo costruire il dizionario e il corpus. Lo abbiamo fatto anche negli esempi precedenti -

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

Creazione di un modello di argomento LSI

Abbiamo già implementato tutto ciò che è necessario per addestrare il modello LSI. Ora è il momento di costruire il modello di argomento LSI. Per il nostro esempio di implementazione, può essere fatto con l'aiuto della seguente riga di codici:

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

Esempio di implementazione

Vediamo l'esempio di implementazione completo per costruire il modello di argomento 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
)

Ora possiamo utilizzare il modello LSI creato sopra per ottenere gli argomenti.

Visualizzazione degli argomenti nel modello LSI

Il modello LSI (lsi_model)che abbiamo creato sopra può essere utilizzato per visualizzare gli argomenti dai documenti. Può essere fatto con l'aiuto del seguente script:

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

Produzione

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

Gerarchical Dirichlet Process (HPD)

I modelli tematici come LDA e LSI aiutano a riassumere e organizzare grandi archivi di testi che non è possibile analizzare a mano. Oltre a LDA e LSI, un altro potente modello di argomento in Gensim è HDP (Hierarchical Dirichlet Process). È fondamentalmente un modello di appartenenza mista per l'analisi senza supervisione di dati raggruppati. A differenza di LDA (la sua controparte finita), HDP deduce il numero di argomenti dai dati.

Implementazione con Gensim

Per implementare HDP in Gensim, dobbiamo addestrare corpus e dizionario (come negli esempi precedenti durante l'implementazione di modelli di argomenti LDA e LSI) modello di argomenti HDP che possiamo importare da gensim.models.HdpModel. Anche qui implementeremo il modello di argomento HDP sui dati di 20Newsgroup e anche i passaggi sono gli stessi.

Per il nostro corpus e dizionario (creato negli esempi precedenti per il modello LSI e LDA), possiamo importare HdpModel come segue:

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

Visualizzazione degli argomenti nel modello LSI

Il modello HDP (Hdp_model)può essere utilizzato per visualizzare gli argomenti dai documenti. Può essere fatto con l'aiuto del seguente script:

pprint(Hdp_model.print_topics())

Produzione

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

Il capitolo ci aiuterà a capire lo sviluppo dell'incorporamento di parole in Gensim.

L'incorporamento di parole, approccio per rappresentare parole e documenti, è una rappresentazione vettoriale densa per il testo in cui le parole con lo stesso significato hanno una rappresentazione simile. Di seguito sono riportate alcune caratteristiche dell'incorporamento di parole:

• È una classe di tecnica che rappresenta le singole parole come vettori a valori reali in uno spazio vettoriale predefinito.

• Questa tecnica è spesso concentrata nel campo del DL (deep learning) perché ogni parola è mappata su un vettore ei valori del vettore vengono appresi allo stesso modo di un NN (Neural Networks).

• L'approccio chiave della tecnica di incorporamento delle parole è una rappresentazione distribuita densa per ogni parola.

Diversi metodi / algoritmi di incorporamento di parole

Come discusso in precedenza, i metodi / algoritmi di incorporamento di parole apprendono una rappresentazione vettoriale a valore reale da un corpus di testo. Questo processo di apprendimento può essere utilizzato con il modello NN su attività come la classificazione dei documenti o è un processo non supervisionato come le statistiche dei documenti. Qui discuteremo due metodi / algoritmi che possono essere utilizzati per apprendere una parola incorporata dal testo:

Word2Vec di Google

Word2Vec, sviluppato da Tomas Mikolov, et. al. in Google nel 2013, è un metodo statistico per apprendere in modo efficiente una parola incorporata dal corpus di testo. In realtà è stato sviluppato come risposta per rendere più efficiente l'addestramento basato su NN sull'incorporamento di parole. È diventato lo standard de facto per l'incorporamento di parole.

Il word embedding di Word2Vec implica l'analisi dei vettori appresi e l'esplorazione della matematica vettoriale sulla rappresentazione delle parole. Di seguito sono riportati i due diversi metodi di apprendimento che possono essere utilizzati come parte del metodo Word2Vec:

• Modello CBoW (Continuous Bag of Words)
• Modello a salto di grammo continuo

GloVe di Standford

GloVe (Global vectors for Word Representation), è un'estensione del metodo Word2Vec. È stato sviluppato da Pennington et al. a Stanford. L'algoritmo GloVe è un mix di entrambi:

• Statistiche globali di tecniche di fattorizzazione di matrici come LSA (Latent Semantic Analysis)
• Apprendimento basato sul contesto locale in Word2Vec.

Se parliamo del suo funzionamento, invece di utilizzare una finestra per definire il contesto locale, GloVe costruisce una matrice di co-occorrenza di parole esplicite utilizzando le statistiche sull'intero corpus di testo.

Sviluppo dell'incorporamento di Word2Vec

Qui svilupperemo l'incorporamento di Word2Vec utilizzando Gensim. Per poter lavorare con un modello Word2Vec, Gensim ci fornisceWord2Vec classe da cui è possibile importare models.word2vec. Per la sua implementazione, word2vec richiede molto testo, ad esempio l'intero corpus di recensioni di Amazon. Ma qui, applicheremo questo principio al testo con memoria di piccole dimensioni.

Esempio di implementazione

Per prima cosa dobbiamo importare la classe Word2Vec da gensim.models come segue:

from gensim.models import Word2Vec

Successivamente, dobbiamo definire i dati di addestramento. Piuttosto che prendere file di testo di grandi dimensioni, stiamo usando alcune frasi per implementare questo principio.

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

Una volta forniti i dati di addestramento, dobbiamo addestrare il modello. può essere fatto come segue:

model = Word2Vec(sentences, min_count=1)

Possiamo riassumere il modello come segue -;

print(model)

Possiamo riassumere il vocabolario come segue:

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

Successivamente, accediamo al vettore per una parola. Lo stiamo facendo per la parola "tutorial".

print(model['tutorial'])

Successivamente, dobbiamo salvare il modello -

model.save('model.bin')

Successivamente, dobbiamo caricare il modello -

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

Infine, stampa il modello salvato come segue:

print(new_model)

Esempio di implementazione completo

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)

Produzione

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)

Visualizzazione di Word Embedding

Possiamo anche esplorare la parola incorporamento con la visualizzazione. Può essere fatto utilizzando un metodo di proiezione classico (come PCA) per ridurre i vettori di parole ad alta dimensione a grafici 2-D. Una volta ridotti, possiamo quindi tracciarli sul grafico.

Tracciare vettori di parole usando PCA

Innanzitutto, dobbiamo recuperare tutti i vettori da un modello addestrato come segue:

Z = model[model.wv.vocab]

Successivamente, dobbiamo creare un modello PCA 2-D di vettori di parole utilizzando la classe PCA come segue:

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

Ora possiamo tracciare la proiezione risultante usando matplotlib come segue:

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

Possiamo anche annotare i punti sul grafico con le parole stesse. Traccia la proiezione risultante usando matplotlib come segue:

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

Esempio di implementazione completo

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

Produzione

Il modello Doc2Vec, al contrario del modello Word2Vec, viene utilizzato per creare una rappresentazione vettoriale di un gruppo di parole prese collettivamente come una singola unità. Non fornisce solo la semplice media delle parole nella frase.

Creazione di vettori di documenti utilizzando Doc2Vec

Qui per creare vettori di documenti usando Doc2Vec, useremo il dataset text8 che può essere scaricato da gensim.downloader.

Download del set di dati

Possiamo scaricare il dataset text8 utilizzando i seguenti comandi:

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

Ci vorrà del tempo per scaricare il set di dati text8.

Addestra il Doc2Vec

Per addestrare il modello, abbiamo bisogno del documento con tag che può essere creato utilizzando models.doc2vec.TaggedDcument() come segue -

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

Possiamo stampare il set di dati addestrato come segue:

print(data_for_training [:1])

Produzione

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

Inizializza il modello

Una volta addestrati, ora dobbiamo inizializzare il modello. può essere fatto come segue:

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

Ora, costruisci il vocabolario come segue:

model.build_vocab(data_for_training)

Ora, addestriamo il modello Doc2Vec come segue:

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

Analisi dell'output

Infine, possiamo analizzare l'output utilizzando model.infer_vector () come segue:

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

Esempio di implementazione completo

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

Produzione

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