Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Visualizzare gli embedding

Lezione 5 di 22 Aggiornata il 29 luglio 2026 Sviluppatore
In questa pagina
  1. Obiettivi
  2. La sfida: 3.072 dimensioni
  3. Riduzione della dimensionalità con t-SNE
  4. Riduzione con UMAP
  5. Visualizzazione interattiva 3D
  6. Visualizzare l’effetto della riduzione della dimensionalità
  7. Punti chiave

Obiettivi

  • Ridurre i vettori ad alta dimensionalità per la visualizzazione 2D/3D
  • Utilizzare t-SNE e UMAP per la visualizzazione
  • Interpretare i cluster visivi

La sfida: 3.072 dimensioni

Gli embedding vivono in uno spazio a 3.072 dimensioni che nessuno può visualizzare direttamente. Per ispezionarli, devi proiettarli in due o tre dimensioni. Questo comporta una certa perdita di informazioni, ma preserva la struttura essenziale: i punti che erano vicini devono rimanere vicini. Si tratta di un potente strumento diagnostico. Un cluster frammentato o temi sovrapposti saltano subito all’occhio, mentre le metriche aggregate potrebbero non rilevarli affatto.

Riduzione della dimensionalità con t-SNE

t-SNE (t-distributed Stochastic Neighbor Embedding) è il metodo classico. Trova un layout 2D in cui ogni punto mantiene il suo vicinato originale. L’esempio seguente costruisce deliberatamente un corpus con tre temi distinti (IA, cucina e sport) per verificare che la proiezione recuperi la struttura attesa.

from openai import OpenAI
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt
import numpy as np

client = OpenAI()

# Example corpus
textes = [
    # AI Cluster
    "Deep learning uses neural networks",
    "Machine learning transforms data science",
    "Transformers revolutionized NLP",
    "GPT-5 is a large language model",
    # Cooking Cluster
    "Chocolate cake recipe",
    "How to prepare ratatouille",
    "Basics of French pastry",
    "Oven baking techniques",
    # Sports Cluster
    "Paris Marathon attracts thousands of runners",
    "Interval training for running",
    "Soccer rules explained",
    "Sports nutrition and performance",
]

categories = (["AI"] * 4 + ["Cooking"] * 4 + ["Sports"] * 4)

# Generate embeddings
response = client.embeddings.create(
    input=textes,
    model="text-embedding-3-large"
)
embeddings = np.array([d.embedding for d in response.data])

# t-SNE reduction to 2D
tsne = TSNE(n_components=2, random_state=42, perplexity=4)
coords = tsne.fit_transform(embeddings)

# Visualization
couleurs = {"AI": "#2563eb", "Cooking": "#dc2626", "Sports": "#16a34a"}
fig, ax = plt.subplots(figsize=(10, 8))

for cat in couleurs:
    mask = [c == cat for c in categories]
    ax.scatter(
        coords[mask, 0], coords[mask, 1],
        c=couleurs[cat], label=cat, s=100, alpha=0.8
    )
    for i, (x, y) in enumerate(coords[mask]):
        idx = [j for j, m in enumerate(mask) if m][i]
        ax.annotate(
            textes[idx][:30] + "...",
            (x, y), fontsize=7, alpha=0.7
        )

ax.legend()
ax.set_title("t-SNE Visualization of Embeddings")
plt.tight_layout()
plt.savefig("tsne_embeddings.png", dpi=150)
plt.show()

Tre parametri guidano il risultato. perplexity bilancia la struttura locale rispetto a quella globale, con valori tipici tra 5 e 50; qui è impostato a 4 perché il corpus contiene solo dodici punti e una perplexity superiore al numero di vicini disponibili produrrebbe una proiezione incoerente. n_iter definisce il numero di iterazioni di ottimizzazione, con un minimo di 250 e idealmente più di 1.000. random_state garantisce la riproducibilità: senza di esso, due esecuzioni successive producono figure diverse, rendendo impossibile il confronto.

Riduzione con UMAP

UMAP (Uniform Manifold Approximation and Projection) è spesso preferito a t-SNE perché è più veloce e preserva meglio la struttura globale. In altre parole, la distanza tra due cluster in un grafico UMAP ha un significato, mentre con t-SNE è arbitraria.

import umap

# UMAP reduction to 2D
reducer = umap.UMAP(n_components=2, random_state=42, n_neighbors=5)
coords_umap = reducer.fit_transform(embeddings)

fig, ax = plt.subplots(figsize=(10, 8))

for cat in couleurs:
    mask = [c == cat for c in categories]
    ax.scatter(
        coords_umap[mask, 0], coords_umap[mask, 1],
        c=couleurs[cat], label=cat, s=100, alpha=0.8
    )

ax.legend()
ax.set_title("UMAP Visualization of Embeddings")
plt.tight_layout()
plt.savefig("umap_embeddings.png", dpi=150)
plt.show()

La tabella seguente riassume i compromessi tra i due metodi.

Criteriot-SNEUMAP
VelocitàLenta (O(n²))Veloce
Struttura globaleScarsamente preservataBen preservata
RiproducibilitàVariabileStabile
Parametriperplexityn_neighbors, min_dist

Visualizzazione interattiva 3D

Su un corpus di alcune centinaia di punti, una figura statica diventa illeggibile: le etichette si sovrappongono e non riesci a capire quale testo corrisponde a quale punto. Plotly risolve il problema spostando le informazioni nei tooltip e permettendoti di ruotare la nuvola di punti.

import plotly.express as px
import pandas as pd

# Reduction to 3D
reducer_3d = umap.UMAP(n_components=3, random_state=42, n_neighbors=5)
coords_3d = reducer_3d.fit_transform(embeddings)

df = pd.DataFrame({
    "x": coords_3d[:, 0],
    "y": coords_3d[:, 1],
    "z": coords_3d[:, 2],
    "category": categories,
    "text": [t[:50] for t in textes]
})

fig = px.scatter_3d(
    df, x="x", y="y", z="z",
    color="category",
    hover_data=["text"],
    title="3D Embeddings"
)
fig.write_html("embeddings_3d.html")
fig.show()

Il file HTML risultante è pronto per essere condiviso. È un modo eccellente per mostrare a un team aziendale come sono distribuiti i loro documenti senza scrivere una singola riga di codice.

Visualizzare l’effetto della riduzione della dimensionalità

La Lezione 2 affermava che troncare un vettore a 256 dimensioni mantiene circa l’88% della sua qualità. Questa cifra rimane astratta finché non la vedi. Generando lo stesso corpus con quattro dimensioni diverse e proiettando ciascuna versione, osservi direttamente quando i cluster iniziano a toccarsi. Questo ti permette di decidere basandoti su prove concrete piuttosto che su una regola generale.

dimensions_a_tester = [256, 512, 1536, 3072]

fig, axes = plt.subplots(1, 4, figsize=(24, 5))

for ax, dim in zip(axes, dimensions_a_tester):
    resp = client.embeddings.create(
        input=textes,
        model="text-embedding-3-large",
        dimensions=dim
    )
    embs = np.array([d.embedding for d in resp.data])
    tsne = TSNE(n_components=2, random_state=42, perplexity=4)
    coords = tsne.fit_transform(embs)

    for cat in couleurs:
        mask = [c == cat for c in categories]
        ax.scatter(coords[mask, 0], coords[mask, 1],
                   c=couleurs[cat], label=cat, s=60)
    ax.set_title(f"{dim} dimensions")
    ax.legend(fontsize=7)

plt.tight_layout()
plt.savefig("comparaison_dimensions.png", dpi=150)
plt.show()

Un avvertimento prima di interpretare queste figure: la proiezione distorce sempre. Un punto isolato sul grafico non è necessariamente isolato nello spazio originale e due cluster incollati insieme in 2D potrebbero essere perfettamente separati in 3.072 dimensioni. La visualizzazione ti aiuta a formulare un’ipotesi, mai a convalidarla. La convalida si basa sulle metriche che affronteremo nella Lezione 10.

Punti chiave

  • t-SNE e UMAP proiettano gli embedding in 2D/3D per la visualizzazione
  • UMAP è generalmente preferito per la sua velocità e fedeltà
  • Plotly abilita visualizzazioni 3D interattive
  • La visualizzazione aiuta a validare la qualità degli embedding e a rilevare anomalie