Che cosa sono gli embeddings vettoriali?
Comprenderà come le reti neurali mappino il testo in vettori densi in uno spazio ad alta dimensionalità, perché testi semanticamente simili producano vettori vicini e che cosa misuri la similarità coseno.
Che cosa sono gli embeddings vettoriali? è una lezione AI Engineering Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento AI Engineering Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso AI Engineering Academy include 4 lezioni in totale.
Il significato dietro i numeri
Un vector embedding è un elenco di numeri (un vettore) che rappresenta il significato di una porzione di testo. Anziché memorizzare le parole come stringhe grezze, le reti neurali imparano a codificare il significato semantico in array numerici densi. Due testi dal significato simile produrranno vettori vicini tra loro in questo spazio ad alta dimensionalità.
Spazio vettoriale ad alta dimensionalità
Gli embedding moderni hanno in genere da 768 a 3072 dimensioni. Ogni dimensione cattura una caratteristica latente del significato — argomenti, sentiment, stile e relazioni — senza essere programmata esplicitamente. Il risultato è uno spazio geometrico ricco, in cui le relazioni semantiche diventano distanze misurabili.
Ad esempio, text-embedding-3-small produce vettori con 1536 dimensioni, mentre text-embedding-3-large produce vettori con 3072 dimensioni.
Come le reti neurali apprendono gli embedding
I modelli di embedding vengono addestrati su enormi corpora testuali per prevedere parole mancanti (masked language modeling) o distinguere coppie semanticamente simili da coppie dissimili. Durante l’addestramento, la rete modifica milioni di pesi finché i testi simili non si raggruppano naturalmente nello spazio vettoriale appreso.
Per questo gli embedding sono chiamati rappresentazioni dense: ogni dimensione contiene informazioni, a differenza delle codifiche one-hot sparse, in cui la maggior parte dei valori è pari a zero.
Similarità coseno: misurare la vicinanza
La similarità coseno misura l’angolo tra due vettori e restituisce un valore compreso tra -1 e 1. Un punteggio pari a 1 significa che i vettori puntano esattamente nella stessa direzione (significato identico), 0 significa che sono ortogonali (non correlati) e -1 significa che puntano in direzioni opposte.
Per il testo è preferibile alla distanza euclidea perché ignora la magnitudine dei vettori e si concentra esclusivamente sulla direzione, risultando così robusta rispetto alle differenze nella lunghezza del testo.
import numpy as np
def cosine_similarity(vec_a, vec_b):
dot_product = np.dot(vec_a, vec_b)
norm_a = np.linalg.norm(vec_a)
norm_b = np.linalg.norm(vec_b)
return dot_product / (norm_a * norm_b)
# Example with tiny 3D vectors
v1 = np.array([0.8, 0.2, 0.5])
v2 = np.array([0.9, 0.1, 0.4])
print(cosine_similarity(v1, v2)) # Close to 1.0Perché la similarità semantica è importante
La ricerca tradizionale per parole chiave non funziona quando gli utenti usano parafrasi: cercare automobile non restituisce i documenti che parlano di cars. I vector embedding risolvono questo problema perché testi semanticamente equivalenti vengono associati a vettori vicini, indipendentemente dalle parole esatte utilizzate.
Questo abilita la ricerca semantica, che consente di trovare il risultato più pertinente in base al significato anziché alla sovrapposizione delle parole: una capacità fondamentale per i sistemi RAG.
Visualizzare il vettore di embedding
Immaginate di rappresentare le frasi su una mappa 2D (un’analogia semplificata). Le frasi sul machine learning si raggruppano in una regione, quelle sulla cucina in un’altra e quelle sullo sport formano un terzo gruppo. I vector embedding creano questa mappa in migliaia di dimensioni.
Relazioni note come king - man + woman ≈ queen corrispondono a vere operazioni aritmetiche in questo spazio: le operazioni sui vettori codificano analogie semantiche.
Generare un embedding semplice
L’API degli embedding di OpenAI accetta del testo e restituisce un elenco di numeri floating-point. Una singola chiamata API può generare l’embedding di una frase o di un intero paragrafo. Il vettore restituito ha una dimensionalità fissa, indipendentemente dalla lunghezza dell’input.
Importante: gli input più lunghi non producono vettori più grandi: producono comunque un vettore della stessa dimensione fissa, ma i testi molto lunghi possono perdere dettagli specifici perché il modello comprime tutto in quello spazio fisso.
from openai import OpenAI
client = OpenAI() # uses OPENAI_API_KEY from environment
response = client.embeddings.create(
model='text-embedding-3-small',
input='Vector embeddings capture semantic meaning.'
)
embedding = response.data[0].embedding
print(f'Dimensions: {len(embedding)}') # 1536
print(f'First 5 values: {embedding[:5]}')Generare embedding per più testi contemporaneamente
Potete generare embedding per più stringhe in una singola chiamata API passando un elenco al parametro input. È molto più efficiente che effettuare una richiesta per ogni testo, perché riduce i round trip di rete e consente all’API di raggruppare i calcoli.
La risposta contiene un oggetto embedding per ogni input, nello stesso ordine, quindi potete associarli ai testi originali usando zip.
from openai import OpenAI
client = OpenAI()
texts = [
'Python is a programming language.',
'Snakes are reptiles.',
'Machine learning requires data.'
]
response = client.embeddings.create(
model='text-embedding-3-small',
input=texts
)
for text, result in zip(texts, response.data):
print(f'{text[:30]}... -> {len(result.embedding)}D vector')Prodotto scalare e similarità coseno a confronto
Se gli embedding sono normalizzati L2 (vettori unitari con magnitudine pari a 1), il prodotto scalare equivale alla similarità coseno. I modelli di embedding di OpenAI restituiscono vettori normalizzati, quindi potete usare entrambe le metriche; il prodotto scalare è leggermente più veloce da calcolare.
Tuttavia, quando combinate embedding provenienti da modelli o fonti diverse che potrebbero non essere normalizzati, calcolate sempre esplicitamente la similarità coseno per evitare risultati fuorvianti.
import numpy as np
def normalize(vec):
return vec / np.linalg.norm(vec)
v1 = normalize(np.array([3.0, 4.0, 0.0]))
v2 = normalize(np.array([4.0, 3.0, 0.0]))
# For unit vectors: dot product == cosine similarity
dot = np.dot(v1, v2)
print(f'Dot product: {dot:.4f}') # same as cosine simEmbedding e codifica one-hot a confronto
La codifica one-hot rappresenta ogni parola come un vettore contenente esattamente un 1 e tutti gli altri valori pari a 0. Un vocabolario di 50.000 parole produce vettori con 50.000 dimensioni quasi interamente composti da zeri: è molto inefficiente.
Gli embedding densi usano da 768 a 3072 dimensioni, ma ogni dimensione contiene informazioni reali. Lo spazio è da 10 a 20 volte più piccolo e al tempo stesso cattura molte più sfumature, tra cui sinonimi, analogie e significato composizionale, completamente ignorati dalla codifica one-hot.
Casi d’uso comuni degli embedding
Oltre alla ricerca semantica, gli embedding abilitano molte applicazioni pratiche:
- Ricerca semantica — trovare documenti in base al significato, non alle parole chiave
- Sistemi di raccomandazione — suggerire elementi simili a quelli apprezzati dall’utente
- Clustering — raggruppare automaticamente i documenti per argomento
- Classificazione — fornire gli embedding a un classificatore lineare
- Deduplicazione — rilevare contenuti quasi duplicati
Tutti i sistemi RAG dipendono dagli embedding per associare le query degli utenti ai segmenti di documento pertinenti.
Verifica rapida
Verificate la vostra comprensione dei concetti di AI Engineering trattati in questa lezione.
Riepilogo della lezione
In questa lezione avete appreso che i vector embedding codificano il significato semantico come array numerici densi, che la similarità coseno misura la vicinanza semantica confrontando le direzioni dei vettori e che l’API degli embedding di OpenAI converte il testo in vettori di dimensione fissa con una singola chiamata. Ora esploreremo come generare e confrontare gli embedding usando in pratica i modelli OpenAI.
Domande Frequenti
La lezione «Che cosa sono gli embeddings vettoriali?» è gratuita?
Sì — il testo completo di «Che cosa sono gli embeddings vettoriali?» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso AI Engineering Academy, passa a CoddyKit PRO. Il corso AI Engineering Academy include 4 lezioni in totale.
Cosa imparerò in «Che cosa sono gli embeddings vettoriali?»?
Comprenderà come le reti neurali mappino il testo in vettori densi in uno spazio ad alta dimensionalità, perché testi semanticamente simili producano vettori vicini e che cosa misuri la similarità co… Eserciti AI Engineering Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare AI Engineering Academy?
Non è richiesta alcuna esperienza precedente. AI Engineering Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.
Quanto tempo richiede la lezione «Che cosa sono gli embeddings vettoriali?»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione AI Engineering Academy?
Sì. Ogni lezione AI Engineering Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Che cosa sono gli embeddings vettoriali?
- Generare embeddings con OpenAI
- Ricerca semantica con NumPy
- Clustering e visualizzazione degli embeddings