Rappresentazioni vettoriali

• Creare un cartella “vettori” all’interno della propria directory di lavoro;
• Copiare nella cartella “vettori” il file https://unior.glottoteca.it/computazionale/vettori/model10000.txt che contiene i primi 10000 vettori compresi in un “vocabolario” di vettori italiani creato nell’ambito del progetto CoNLL 2017 Shared Task (cf. https://aclanthology.org/K17-3001/). Pubblicato a cura di Andrey Kutuzov, questo vocabolario è scaricabile nella versione integrale da 2469122 vettori alla pagina http://vectors.nlpl.eu/repository (vocabolario n. 52). I vettori sono stati generati applicando l’algoritmo word2vec (nella versione “Continuous Skipgram”) a un corpus non lemmatizzato di 5364254134 parole unità (Italian CoNLL17 corpus).

• Nel nostro file i vettori sono registrati come righe di testo che comprendono la parola rappresentata seguita da uno spazio seguito a sua volta dai valori numerici delle componenti dei vettori intervallati da spazi.
• Ogni parola è associata a un vettore di 100 componenti, p. es:

...
ragazzo 0.274816 0.150672 0.256981 -0.061423 0.206469 0.025959 0.067223 -0.140390 -0.641028 0.745807 0.161690 0.488756 -0.216711 -0.353573 -0.040053 -0.148652 0.411991 -0.565740 0.233396 -0.302497 -0.234906 0.204365 0.382733 -0.461834 -0.172323 -0.041091 -0.326205 0.102736 0.379406 -0.367012 0.203576 -0.165576 -0.289311 0.137351 -0.264437 -0.182976 0.669364 -0.482138 0.084991 0.033591 -0.128019 0.494122 -0.545612 0.162401 -0.008899 0.091664 0.466830 -0.239388 0.161264 -0.664787 -0.122336 -0.409639 -0.028745 -0.116255 -0.015530 -0.038676 0.439448 -0.047542 0.346746 -0.002370 -0.165127 0.316057 0.087932 -0.144120 -0.298510 0.098640 0.163334 0.290075 0.364643 -0.346341 0.210945 0.181210 -0.137086 -0.088916 -0.033362 0.127205 -0.279166 0.415014 -0.755850 -0.058353 -0.055651 0.056765 0.038869 0.104142 -0.357542 0.034761 -0.141745 -0.065668 -0.040616 -0.231013 0.053406 -0.429221 -0.170160 0.145266 0.413834 -0.135055 0.148167 -0.029092 -0.157737 0.629005 
...

Ciascuna componente è un numero reale compreso tra 1 e -1. Ogni vettore può essere visto come una freccia che parte dall’origine e punta verso un punto le cui coordinate coincidono con le componenti del vettore in uno spazio cartesiano di 100 dimensioni (per cui ogni punto ha 100 coordinate anziché averne 2 - come accade quando si lavora con un piano - o 3 - come accade quando si lavora con il consueto spazio tridimensionale).

• Occorre tenere presenti le tre formule seguenti: 1) formula analitica del prodotto scalare tra vettori, secondo la quale il prodotto scalare tra due vettori si può calcolare come somma dei prodotti tra le componenti omonime dei vettori:

$$ \vec{a}\cdot\vec{b}=\sum_{i=1}^{n} a_{i}b_{i} $$

• 2) formula della norma di un vettore, secondo la quale la norma di un vettore è pari alla radice quadrata della somma dei quadrati delle componenti del vettore:

$$ \lVert \vec{a} \rVert =\sqrt{\sum_{i=1}^{n} a_{i}^{2}} $$

• 3) formula del coseno:

$$ cos(\theta) = \frac{\vec{a}\cdot\vec{b}}{\lVert \vec{a} \rVert \lVert \vec{b} \rVert} $$

• quest’ultima discende direttamente dalla definizione di prodotto scalare tra vettori, secondo la quale il prodotto scalare tra due vettori equivale al prodotto delle loro norme moltiplicato per il coseno dell’angolo convesso compreso tra essi: $$ \vec{a}\cdot\vec{b}=\lVert \vec{a} \rVert \lVert \vec{b} \rVert \hspace{2pt} cos(\theta)$$
• Lo script seguente:
  • definisce le funzioni per calcolare il prodotto scalare di due vettori (dot) (sulla base della formula analitica), la norma di un vettore (norm) e il coseno tra due vettori (cosine) – le definizioni delle tre funzioni sono l’espressione in python delle tre formule riportate qui sopra –;
  • legge il file module10000.txt rigo per rigo e per ogni rigo crea una entrata di un “dizionario” python in cui ogni termine è associato a un vettore (in formato “numpy.array”);
  • calcola, a titolo esemplificativo, il coseno di alcune coppie di elementi (vettori parola o vettori ottenuti da somme e sottrazioni di vettori parola).

w2vita.py

import numpy as np
dot=lambda a,b: sum(a[i]*b[i] for i in range(len(a)))
norm=lambda a: sum(n**2 for n in a)**(1/2)
cosine=lambda a,b: dot(a,b)/(norm(a)*norm(b))
 
with open('vettori/model10000.txt', errors="ignore") as file:
    lines=file.readlines()
vectors={}
for line in lines:
    line=line.split()
    term=line.pop(0) # term=v[0]; v=v[1:]
    vector=[]
    for number in line:
        vector.append(float(number))
    vectors.update({term:np.array(vector)})
 
print("COSENO TRA 'ragazza' E 'donna':")
print(cosine(vectors['ragazza'],vectors['donna']))
print("COSENO TRA 'ragazza' E 'ragazzo'")
print(cosine(vectors['ragazza'],vectors['ragazzo']))
print("COSENO TRA 'ragazza' E 'ragazzo'+'donna':")
print(cosine(vectors['ragazza'],vectors['ragazzo']+vectors['donna']))
print("COSENO TRA 'ragazza' E 'ragazzo'−'uomo'+'donna':")
print(cosine(vectors['ragazza'],vectors['ragazzo']-vectors['uomo']+vectors['donna']))
print()
print("COSENO TRA 'regina' E 'donna':")
print(cosine(vectors['regina'],vectors['donna']))
print("COSENO TRA 'regina' E 're'")
print(cosine(vectors['regina'],vectors['re']))
print("COSENO TRA 'regina' E 're'+'donna':")
print(cosine(vectors['regina'],vectors['re']+vectors['donna']))
print("COSENO TRA 'regina' E 're'−'uomo'+'donna':")
print(cosine(vectors['regina'],vectors['re']-vectors['uomo']+vectors['donna']))

Alternativa senza l’impiego della libreria numpy:

w2vita_bis.py

def dot(a,b):
    return sum(a[i]*b[i] for i in range(len(a)))
 
def norm(a):
    return sum(n**2 for n in a)**(1/2)
 
def cosine(a,b):
    return dot(a,b)/(norm(a)*norm(b))
 
def v_sum(a,b):
    return tuple(a[i]+b[i] for i in range(len(a)))
 
def v_subtr(a,b):
    return tuple(a[i]-b[i] for i in range(len(a)))
 
 
with open('model10000.txt', errors="ignore") as file:
    lines=file.readlines()
vectors={}
for line in lines:
    line=line.split()
    term=line.pop(0) # term=v[0]; v=v[1:]
    vector=[]
    for number in line:
        vector.append(float(number))
    vectors.update({term:tuple(vector)})
 
print("COSENO TRA 'ragazza' E 'donna':")
print(cosine(vectors['ragazza'],vectors['donna']))
print("COSENO TRA 'ragazza' E 'ragazzo'")
print(cosine(vectors['ragazza'],vectors['ragazzo']))
print("COSENO TRA 'ragazza' E 'ragazzo'+'donna':")
print(cosine(vectors['ragazza'],v_sum(vectors['ragazzo'],vectors['donna'])))
print("COSENO TRA 'ragazza' E 'ragazzo'−'uomo'+'donna':")
print(cosine(vectors['ragazza'],v_sum(v_subtr(vectors['ragazzo'],vectors['uomo']),vectors['donna'])))
print()
print("COSENO TRA 'regina' E 'donna':")
print(cosine(vectors['regina'],vectors['donna']))
print("COSENO TRA 'regina' E 're'")
print(cosine(vectors['regina'],vectors['re']))
print("COSENO TRA 'regina' E 're'+'donna':")
print(cosine(vectors['regina'],v_sum(vectors['re'],vectors['donna'])))
print("COSENO TRA 'regina' E 're'−'uomo'+'donna':")
print(cosine(vectors['regina'],v_sum(v_subtr(vectors['re'],vectors['uomo']),vectors['donna'])))

Dovrebbero apparire i seguenti risultati:

COSENO TRA 'ragazza' E 'donna':
0.7884854538928904
COSENO TRA 'ragazza' E 'ragazzo'
0.8232466445406994
COSENO TRA 'ragazza' E 'ragazzo'+'donna':
0.8851789074969085
COSENO TRA 'ragazza' E 'ragazzo'−'uomo'+'donna':
0.9186331189320743
 
COSENO TRA 'regina' E 'donna':
0.4508957461643857
COSENO TRA 'regina' E 're'
0.6537117135508874
COSENO TRA 'regina' E 're'+'donna':
0.6945732506357085
COSENO TRA 'regina' E 're'−'uomo'+'donna':
0.7164049341283609

Come si vede, gli elementi confrontati sono via via più simili. In particolare la somiglianza tra 'regina' e 're' o tra 'ragazza' e 'ragazzo' (espressa attraverso il coseno) aumenta se a 're' o a 'ragazzo' si aggiungono le componenti di 'donna' e si sottraggono quelle di 'uomo'. Ciò significa che le relazioni tra i vettori riflettono in certa misura quelle tra i significati che tali vettori rappresentano.

• Dichiarativo (comprehension syntax) con schema di definizione delle funzioni “lambda”:

dot=lambda a,b: sum(a[i]*b[i] for i in range(len(a)))

• Dichiarativo (comprehension syntax) con schema di base di definizione delle funzioni:

def dot(a,b):
    return sum(a[i]*b[i] for i in range(len(a)))

• Procedurale con sintassi di base:

def dot(a,b):
    output=0
    for i in range(len(a)):
        output+=a[i]*b[i]
    return output

• Importazione di una funzione precostituita del modulo numpy:

from numpy import dot