Gensim - Creazione della matrice TF-IDF

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.