Visualizza wikitesto di Word2vec

{{S|programmazione}}
'''Word2vec''' è un insieme di modelli che sono utilizzati per produrre [[word embedding]], il cui pacchetto fu originariamente creato in [[C (linguaggio)|C]] da [[Tomas Mikolov]]<ref>https://code.google.com/archive/p/word2vec/</ref>, poi implementato anche in [[Python]]<ref name=":0">http://radimrehurek.com/gensim/models/word2vec.html</ref> e [[Java (linguaggio di programmazione)|Java]]<ref name=":1">{{Cita web |url=https://deeplearning4j.org/word2vec.html#intro |titolo=Copia archiviata |accesso=7 marzo 2017 |urlarchivio=https://web.archive.org/web/20170308043751/https://deeplearning4j.org/word2vec.html#intro |dataarchivio=8 marzo 2017 |urlmorto=sì }}</ref>. Word2vec è una semplice [[rete neurale artificiale]] a due strati progettata per [[Elaborazione del linguaggio naturale|elaborare il linguaggio naturale]], l'algoritmo richiede in ingresso un [[corpus]] e restituisce un insieme di vettori che rappresentano la distribuzione [[semantica]] delle parole nel testo. Per ogni parola contenuta nel corpus, in modo univoco, viene costruito un vettore in modo da rappresentarla come un punto nello spazio multidimensionale creato. In questo spazio le parole saranno più vicine se riconosciute come [[Semantica distribuzionale|semanticamente più simili]]. Per capire come Word2vec possa produrre [[word embedding]] è necessario comprendere le architetture CBOW e Skip-Gram.

== CBOW e Skip-Gram ==
Word2vec può produrre [[word embedding]] utilizzando uno tra i seguenti due modelli di architettura: continuous bag-of-words ('''CBOW''') e '''Skip-Gram'''<ref>{{Cita pubblicazione|autore=Tomas Mikolov|autore2=Quoc V. Le|autore3=Ilya Sutskever|titolo=Exploiting Similarities among Languages for Machine Translation|rivista=arXiv:1309.4168|numero=}}</ref>.

Per addestrare i modelli è necessario disporre di un corpus di documenti testuali quanto più ampio possibile. Da questo corpus sarà possibile estrarre un vocabolario di parole distinte ([[Token (testo)|token]]). <syntaxhighlight lang="text" line="1" start="1">
Nel mezzo del cammin di nostra vita
mi ritrovai per una selva oscura
</syntaxhighlight>Ogni token distinto è quindi rappresentato con una codifica [[One-hot|One-hot encoding]].

Questo approccio presenta però alcuni limiti poiché la dimensione del vettore <math>V</math> dipende dalla dimensione del vocabolario che potrebbe essere anche molto ampia. Questo enorme utilizzo di dati potrebbe manifestarsi nella ''[[curse of dimensionality]].'' Inoltre, se venissero aggiunti/rimossi token dal [[word embedding]], il modello dovrebbe essere riaddestrato da zero. L'ultimo grosso limite di questo approccio è dovuto al fatto che non viene risolto il problema della [[polisemia]] dei termini (meaning conflation deficiency).

Nell'esempio di corpus sopra riportato sono presenti 13 token distinti, perciò  la lunghezza del vettore <math>V</math> è necessariamente 13.<syntaxhighlight lang="text" line="1">
nel     [1,0,0,0,0,0,0,0,0,0,0,0,0]
mezzo   [0,1,0,0,0,0,0,0,0,0,0,0,0]
del     [0,0,1,0,0,0,0,0,0,0,0,0,0]
cammin  [0,0,0,1,0,0,0,0,0,0,0,0,0]
di      [0,0,0,0,1,0,0,0,0,0,0,0,0]
nostra  [0,0,0,0,0,1,0,0,0,0,0,0,0]
vita    [0,0,0,0,0,0,1,0,0,0,0,0,0]
mi      [0,0,0,0,0,0,0,1,0,0,0,0,0]
ritrovai[0,0,0,0,0,0,0,0,1,0,0,0,0]
per     [0,0,0,0,0,0,0,0,0,1,0,0,0]
una     [0,0,0,0,0,0,0,0,0,0,1,0,0]
selva   [0,0,0,0,0,0,0,0,0,0,0,1,0]
oscura  [0,0,0,0,0,0,0,0,0,0,0,0,1]
</syntaxhighlight>I due modelli esplorano il '''contesto''' dei token investigando gli altri token che sono prossimi a quest'ultimo. Qui si evidenzia la principale differenza tra le architetture CBOW e Skip-Gram.

Se la prima architettura mira a predire il ''token corrente'' (output) a partire da una finestra di ''parole di contesto'' (input); la seconda ha lo scopo di predire le ''parole di contesto'' (output) a partire dal ''token corrente'' (input).

Il parametro <math>C</math> definisce la dimensione della finestra di contesto: sono incluse nel contesto i <math>C</math>  token immediatamente precedenti/successivi al token corrente. 
{| class="wikitable"
|+Finestra di contesto con C=2 per il testo "Nel mezzo del cammin di nostra vita"
!token corrente
!finestra di contesto
|-
|nel
|(nel,mezzo) (nel,del)
|-
|mezzo
|(nel, mezzo) (mezzo,del) (mezzo,cammin)
|-
|cammin
|(mezzo, cammin)(del,cammin)(cammin,di)(cammin,nostra)
|-
|di
|(del,di)(cammin,di)(di,nostra)(di,vita)
|-
|nostra
|(cammin,nostra)(di,nostra)(nostra,vita)
|-
|vita
|(di,vita)(nostra,vita)
|}
Entrambi i modelli sono implementati tramite una [[rete neurale artificiale]] costituita da tre strati: uno strato d'ingresso ('''input layer'''), uno strato nascosto ('''hidden layer''') e uno strato d'uscita ('''output layer''').

[[File:Rete neurale artificiale.png|miniatura|Architettura generica utilizzata da CBOW e Skip-gram]]

L'input varia a seconda del modello di architettura utilizzato così come varia il tipo di output predetto. Infatti, a seconda dell'architettura il token corrente e la finestra di contesto saranno l'input o l'output del modello.

A seguito del training del modello tramite '''''[[Retropropagazione dell'errore|backpropagation]]''''', la matrice dei pesi <math>W</math> conterrà le rappresentazioni delle [[word embedding]] dei <math>V</math> token del vocabolario dove N è la dimensione del word embedding. In altre parole, la riga <math>[w_{(i,1)},w_{(i,2)},...,w_{(i,N-1)},w_{(i,N)}]</math> della matrice <math>W</math> conterrà la rappresentazione [[word embedding]] del token <math>V_i</math>.

La [[funzione softmax]] viene applicata nell'ultimo layer della rete neurale.

=== CBOW ===
[[File:CBOW.png|miniatura|Architettura CBOW. Nella figura sono presenti più matrici <math>W</math>, ma ciò non deve indurre erroneamente a pensare che le matrici <math>W</math> siano molteplici.]]
L'architettura CBOW ha lo scopo di predire il token corrente (output, es. ''nel'') a partire da una finestra di parole di contesto (input, es. ''mezzo'' e ''del''). L'input consiste quindi nella rappresentazione [[One-hot|One-hot encoding]] di <math>C*2</math> token di contesto. La matrice <math>W</math> è la stessa descritta nell'architettura generale, ma, in questo caso, l'hidden layer è la ''media'' dei vettori <math>W_i</math> corrispondenti alle parole di contesto in ingresso.

Facendo ciò l'hidden layer perde l'informazione della posizione nel testo dei token che fanno parte della finestra di contesto così come avviene nella rappresentazione [[Modello della borsa di parole|bag of words]].

=== Skip-Gram ===
[[File:Skipgram.png|miniatura|Architettura Skip-gram. A differenza di CBOW, le matrici W' non rappresentano una copia della stessa matrice, ma sono diverse per ogni token in output.]]
L'architettura Skip-Gram ha lo scopo di predire le parole di contesto (output, es. ''nel'', ''del'' e ''cammin'') a partire dal token corrente (input, es. ''mezzo''). L'output è rappresentato da un vettore <math>Vx1</math> ottenuto dalla media della rappresentazione [[One-hot|One-hot encoding]] di ogni token di contesto. L'input consiste invece nella rappresentazione [[One-hot|One-hot encoding]] del token corrente. L'hidden layer corrisponde quindi alla rappresentazione [[word embedding]] del token corrente.

Il modello genererà un vettore di output per ogni token di contesto. Di conseguenza saranno presenti altrettanti vettori di errore di dimensione <math>Vx1</math>. Al fine di avviare la back propagation i <math>C*2</math> vettori di errore vengono sommati tra di loro per ottenere un solo vettore <math>Vx1</math>.  I pesi dell'hidden layer verranno quindi aggiornati in base a questo vettore di errore cumulativo.

Anche nell'architettura skip-gram non viene quindi tenuto conto della posizione nel testo dei token di contesto .

==Parametri word2vec==
=== Shell, C ===
Il pacchetto originale di Word2vec permette di lanciare da shell l'algoritmo scritto in C. Il file ''demo-word.sh'' infatti riporta questo comando:<syntaxhighlight lang="shell">
$BIN_DIR/word2vec -train $TEXT_DATA -output $VECTOR_DATA -cbow 0 -size 200 -window 5 -negative 0 -hs 1 -sample 1e-3 -threads 12 -binary 1
</syntaxhighlight>Dove ''$BIN_DIR/word2vec'' è il percorso delle [[Cartella (informatica)|cartelle]] per arrivare al file word2vec nella cartella ''bin''; ''$TEXT_DATA'' va sostituito invece con il corpus formato testo con cui si vuole fare l'addestramento e ''$VECTOR_DATA'' sarà il nome del file che l'algoritmo andrà a creare.
Successivamente possiamo vedere dei parametri modificabili:
*''size'' per definire la dimensione dei vettori da creare.
*''window'' per decidere la massima distanza tra la parola corrente e quella predetta all'interno di una frase.
*''threads'' per decidere quanti thread del processore usare per addestrare il modello.
*''binary'' determina in che codifica sarà salvato il file (se il parametro è inizializzato a 1 il file creato sarà binario, altrimenti sarà [[leggibile dall'uomo]], cioè in formato testo).

=== Gensim, Python ===
Vi sono vari parametri che si possono modificare per personalizzare il processamento dell'algoritmo, alcuni sono scritti di seguito:
*''sentence=var'', è il primo parametro da inserire per inizializzare il modello a partire da una variabile ''var'' iterabile e sotto forma di lista di parole (stringhe [[unicode]]) che verranno usate per l'addestramento.
*''size=n'', permette di decidere la dimensione dei vettori che l'algoritmo andrà a creare.
*''window=n'', permette di decidere la massima distanza tra la parola corrente e quella predetta all'interno di una frase.
*''min_count=n'', permette di ignorare le parole con una frequenza minima minori di n.
*''workers=n'', permette di decidere quanti thread del processore usare per addestrare il modello.
*''seed=n'', per il generatore di numeri casuali.

Il [[tutorial]] di gensim<ref name=":0" /> inizializza i parametri (''n'') in questo modo:
<syntaxhighlight lang="python3">
class gensim.models.word2vec.Word2Vec(sentences=None, size=100, alpha=0.025, window=5, min_count=5, max_vocab_size=None, sample=0.001, seed=1, workers=3, min_alpha=0.0001, sg=0, hs=0, negative=5, cbow_mean=1, hashfxn=<built-in function hash>, iter=5, null_word=0, trim_rule=None, sorted_vocab=1, batch_words=10000)
</syntaxhighlight>

=== DL4J, Java ===
I parametri spiegati sulla documentazione di DL4J<ref name=":1" /> sono:
*''batchSize'' è la quantità di parole da elaborare contemporaneamente.
*''minWordFrequency'' è la frequenza minima che devono avere le parole per essere prese in considerazione dall'algoritmo.
*''layerSize '' è il numero di dimensioni che vogliamo dare ai vettori che l'algoritmo andrà a creare.

La documentazione di DL4J<ref name=":1" /> inizializza i parametri in questo modo:<syntaxhighlight lang="java">
Word2Vec vec = new Word2Vec.Builder() 
    .minWordFrequency(5) 
    .iterations(1) 
    .layerSize(100) 
    .seed(42) 
    .windowSize(5) 
    .iterate(iter) 
    .tokenizerFactory(t) 
    .build();
</syntaxhighlight>

== Note ==
<references/>

==Bibliografia==
*[https://www.amazon.it/Deep-Learning-Language-Processing-Embeddings-ebook/dp/B01KQ0ZN0A Deep Learning: Natural Language Processing in Python with Word2Vec: Word2Vec and Word Embeddings in Python and Theano (Deep Learning and Natural Language Processing Book 1)]

{{portale|informatica}}

[[Categoria:Programmazione]]
[[Categoria:Elaborazione del linguaggio naturale]]
[[Categoria:Intelligenza artificiale]]
[[Categoria:Apprendimento automatico]]