Come addestrare il modello word2vec usando la libreria gensim

Che cos’è il word embedding?

Word embedding è un processo di comprensione del testo tramite algoritmi di apprendimento automatico, inoltre diciamo che word embedding è una rappresentazione appresa per il testo dove cattura il contesto della parola in un documento, la similarità semantica e sintattica e la relazione tra altre parole nel corpus.

Questo approccio detiene la chiave per risolvere i problemi di elaborazione del linguaggio naturale utilizzando l’apprendimento automatico e l’algoritmo di apprendimento profondo. Fondamentalmente, il word embedding è una rappresentazione vettoriale delle parole. Calcolando la distanza o la posizione delle parole, rappresenta parole, frasi, paragrafi o documenti di significato.

Ci sono diverse tecniche di word embedding che sono state introdotte fino ad ora. In generale, diciamo che ci sono due tipi di incorporamento di parole –

• Static Word Embedding
• Contextual Word Embedding

1. Incorporazione statica di parole: I metodi tradizionali come Skip-Gram e Continuous Bag-of-Words imparano l’incorporazione statica addestrando tabelle di ricerca che traducono le parole in un vettore denso. Le incorporazioni statiche sono direttamente utili per risolvere i compiti di semantica lessicale.

Problema: Non può risolvere le ambiguità per le parole polisemiche. Come quando una parola rappresenta più significati in due frasi diverse, allora i metodi Skip-Gram o BOW falliscono.

2. Contextual Word Embedding: L’incorporazione contestuale delle parole mira a catturare la semantica delle parole in diversi contesti per affrontare il problema della polisemia e la natura dipendente dal contesto delle parole. Il modello LSTM, LSTM bidirezionale ecc. aiuta a ottenere la forma vettoriale delle parole.

Modello Word2Vec: Word2Vec è un metodo per costruire una tale incorporazione statica di parole. Questo è stato ottenuto usando due metodi Skip Gram e Common Bag of Words (CBOW) con l’aiuto di reti neurali. È stato sviluppato da Tomas Mikolov nel 2013 a Google.

Perché ne abbiamo bisogno?

Diciamo che abbiamo le seguenti frasi.

“Amo codificare in Jupyter.” e “Mi piace codificare in Pycharm”.

Entrambe le frasi sono molto vicine tra loro. Se costruiamo un vocabolario esaustivo (chiamiamolo V), avrà V = {I, love, enjoy, coding, in, Jupyter, Pycharm}. Se andiamo con una sola codifica calda. Non saremo in grado di ottenere il significato esatto come amore, godere, codifica ogni parola sono trattati come lo stesso, mentre amore e godere e molto vicino a vicenda.

Il nostro motivo è quello di avere parole con contesto simile sarà molto vicino posizione spaziale. Matematicamente, la distanza coseno identificherà quanto sono vicine due parole. La distanza coseno della parola più vicina o il coseno dell’angelo sarà vicino a 0 e per la più lontana sarà vicino a 1.

Come funziona Word2Vec?

Il modello Word2Vec può funzionare con due algoritmi –

• Skip-gram
• CBOW (Continuous Bag of Words)

ModelloCBOW: Questo metodo prende il contesto di ogni parola come input e cerca di predire la parola corrispondente al contesto. Nel processo di predizione della parola target, impariamo la rappresentazione vettoriale della parola target. Come input ci sarà una parola multipla secondo la dimensione della finestra (5 parole) ma restituirà una parola come output.

Guardiamo l’architettura più profonda:

Modello Skip-Gram: Questo è un altro algoritmo per Word2Vec. È l’opposto del modello CBOW. Il modello prenderà una parola come input, ma restituirà più parole secondo la dimensione della finestra.

Implementazione di word Embedding con Gensim Word2Vec Model:

Qui, spiegherò passo dopo passo come allenare il modello word2vec usando Gensim. Dataset, ho raccolto dalla piattaforma Kaggle. Questo dataset proviene dai dati pubblici del Myers-Briggs Type Indicator. Contiene due colonne type e post. “type” definisce 16 tipi di personalità e “post” definisce il commento da quei 16 tipi di individuo personalizzato.

1. Caricamento e descrizione dei dati

# Caricamento del dataset
data_df = pd.read_csv(“data/mbti_1.csv”)
data_df.head()

2. Pulizia e pre-elaborazione dei dati

Dopo aver caricato i dati, bisogna trovare se i dati contengono valori NA, se i valori NA sono presenti nel set di dati, li elimineremo.

# Rimuovere i valori na dal dataframe
def data_na_value_cleaning(data):
print(“\nPrima della pulizia, Forma dei dati : “, data.shape)
print(“\nPrima di rimuovere i valori nulli: – – – – – – -“)
print(data.isna().sum())
data.dropna(inplace=True)
data.reset_index(inplace=True,drop=True)
print(“Dopo la rimozione dei valori nulli: – – – – – – -“)
print(data.isna().sum())
print(“\nDopo la pulizia, Data Shape : “, data.shape)
return data

In quanto i nostri dati non hanno valori NA. Quindi, nessuna riga è stata rimossa. Ora, controlliamo se ci sono valori duplicati nel Dataset.

# Rimozione dei valori duplicati
def duplicate_content_removal(data, col, ini_row):
print(“\nPrima di rimuovere i duplicati, il numero di dati era : “, ini_row)
duplicate_count = data.duplicate().sum()
print(“\nNumero di duplicati: “, duplicate_count)

descrizione_dati = data.drop_duplicates()
cleaned_row = len(description_data)
if (ini_row – cleaned_row) > 0:
print(“\nTotale riduzione dati : “, (ini_row – cleaned_row))
print(“\nDopo la rimozione dei duplicati, il numero di dati è :”, cleaned_row)
else:
print(“\nIl dataset non contiene dati duplicati.”)
return list(description_data)

posts = duplicate_content_removal(data_df, ‘posts’, data_df.shape)

Ora, come parte del processo di pulizia, rimuoveremo link e punteggiatura. Inoltre, per una migliore formazione considereremo solo le parole e non il numero e le parole alfanumeriche. Rimuoveremo le stopwords per una migliore comprensione e accuratezza del modello.

def remove_link_punc(string):
# rimozione dei link
temp_string = re.sub(‘http?://(?:|||(?:%))+’, ‘ ‘, string)

# rimuovendo tutto tranne le lettere inglesi a-z
regex = re.compile(”)
temp_string = regex.sub(‘ ‘, temp_string)

# rimuovendo spazi extra
clean_string = re.sub(‘ +’, ‘ ‘, temp_stringa).lower()

return clean_string

Next method data_cleaning

def data_cleaning(content):
sentences =
for idx in tqdm(range(len(content)):
if content !=””:
# tokenizzazione delle frasi usando la libreria NLTK
for each_sent in sent_tokenize(str(content)):
if each_sent != “”:
temp_sent =
# Rimozione di link e punteggiatura
each_sent = remove_link_punc(each_sent.lower())

# Rimozione di stopwords e applicazione della lemmatizzazione
for each_word in each_sent.split():
if each_word not in stop_words and len(each_word)>= 3:
temp_sent.append(lemmatizer.lemmatize(each_word))

# Solo prendendo la lunghezza dell’elenco di parole è maggiore di uguale a 5
if len(temp_sent) >= 5:
sentences.append(temp_sent)
return sentences

sent_corpus = data_cleaning(posts)

# Stats delle parole della frase
len_count =
for l in sent_corpus:
len_count.append(len(l))

print(“Numero totale di frasi : “, len(len_count))
word_sent_df = pd.DataFrame(sorted(Counter(len_count).items()), columns=)
word_sent_df.head(10)

Dopo la pulizia e la pre-elaborazione dei dati, i dati hanno l’aspetto di ogni parola in una lista. Ogni lista è la rappresentazione di una frase. Genism word2vec richiede che un formato di ‘lista di liste’ per l’addestramento dove ogni documento è contenuto in una lista e ogni lista contiene liste di token di quel documento.

3. Addestramento del modello

Ora alleneremo il modello word2vec usando la libreria Gensim con il nostro dataset.

modello = Word2Vec(sentences=sent_corpus, size=200, window=4, min_count=1, workers=4)

sentences : dove possiamo passare il nostro dataset preparato che è sent_corpus

size : dimensione del vettore generato per ogni parola, per default la dimensione è 100.

window : Distanza massima tra la parola corrente e quella predetta all’interno di una frase, il valore predefinito è 5

min_count : Ignora tutte le parole dove la frequenza di ogni parola è inferiore a min_count, il valore predefinito è 5. Dato che volevamo aggiungere tutte le parole nel corpus, il valore che abbiamo fornito è 1.

workers : Utilizza così tanti threads per allenare il modello. Il valore predefinito è 3

sg : Utilizzato per scegliere l’algoritmo di allenamento: 1 per skip-gram; 0 per CBOW. Per default CBOW è usato per l’addestramento.

4. Vettore forma parola

Dopo l’addestramento del modello è completato. Possiamo andare ad ottenere la forma vettoriale di ogni parola. Ci sono due metodi per ottenere la forma vettoriale. La forma del vettore sarà 200 secondo la dimensione data.

# Ottenere la forma vettoriale della parola re
modello.wv.get_vector(‘king’)

Or

# Un altro modo per ottenere la forma vettoriale della parola2vec
model.wv.word_vec(‘king’)

5. Similarità e distanza tra due parole

Forniamo due liste di parole ‘re’,’maschio’ in una lista e ‘regina’,’femmina’ in un’altra lista. Cercheremo di scoprire quanto sono simili queste due parole della lista.

# Elenco di parole simili
modello.wv.n_similarity(,)

Qui cercheremo, qual è la distanza tra due parole.Le parole simili avranno meno distanza.

# Distanza tra due parole
modello.wv.distance(‘king’,’queen’)

Se vogliamo ottenere simile allora possiamo usare il seguente codice.

# Parola simile per re
modello.wv.similar_by_word(‘king’)

6. Altre tecniche usando word2Vec

# Dispari una dalla lista di parole
model.wv.doesnt_match()

Questo ci aiuterà a trovare le parole dispari presenti in una lista.

# valutazione delle coppie di parole
model.wv.evaluate_word_pairs(‘data/SimLex-999/SimLex-999_2.txt’,)

Questo ci aiuterà a valutare la coppia di parole

# analogia di parole dalla lista di parole
model.wv.evaluate_word_analogies(‘data/questions-words.txt’)

Questo sarà utile per l’analogia delle parole

7. Caricamento del modello allenato

Se abbiamo bisogno di usare il modello allenato, che può essere ottenuto usando il codice seguente.

# Caricamento modello pre-addestrato da google
da gensim import models

models.KeyedVectors.load_word2vec_format(‘data/GoogleNews-vectors-negative300.bin’, binary=True)

Ho provato a caricare il modello pre-addestrato da google. Possiamo scaricare dal link. Questo modello è anche molto potente e addestrato su enormi set di dati.

Per maggiori dettagli sull’implementazione, puoi dare un’occhiata al mio codice su github.

Grazie per aver letto, fammi sapere se c’è una domanda o un dubbio. Sarò felice di rispondere alle vostre domande.