Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Visualiser les embeddings

Les 5 van 22 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Objectifs
  2. Le défi : 3 072 dimensions
  3. Réduction de dimensionnalité avec t-SNE
  4. Réduction avec UMAP
  5. Visualisation interactive 3D
  6. Visualiser l’effet de la réduction de dimensionnalité
  7. Belangrijkste punten

Objectifs

  • Réduire des vecteurs de haute dimension pour une visualisation 2D/3D
  • Utiliser t-SNE et UMAP pour la visualisation
  • Interpréter les clusters visuels

Le défi : 3 072 dimensions

Les embeddings existent dans un espace à 3 072 dimensions qu’il est impossible de visualiser directement. Pour les inspecter, vous devez les projeter en deux ou trois dimensions. Cela implique une certaine perte d’information, mais préserve la structure essentielle : les points proches doivent rester proches. C’est un outil de diagnostic puissant. Un cluster scindé ou des thèmes qui se chevauchent sautent aux yeux, alors que des métriques agrégées pourraient totalement les manquer.

Réduction de dimensionnalité avec t-SNE

t-SNE (t-distributed Stochastic Neighbor Embedding) est la méthode classique. Elle trouve une disposition 2D où chaque point conserve son voisinage d’origine. L’exemple ci-dessous construit délibérément un corpus avec trois thèmes distincts — l’IA, la cuisine et le sport — afin que vous puissiez vérifier que la projection retrouve la structure attendue.

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()

Trois paramètres pilotent le résultat. perplexity équilibre la structure locale par rapport à la structure globale, avec des valeurs typiques entre 5 et 50 ; ici, elle est fixée à 4 car le corpus ne contient que douze points, et une perplexité supérieure au nombre de voisins disponibles produirait une projection incohérente. n_iter définit le nombre d’itérations d’optimisation, avec un minimum de 250 et idéalement plus de 1 000. random_state assure la reproductibilité : sans cela, deux exécutions successives produisent des figures différentes, rendant toute comparaison impossible.

Réduction avec UMAP

UMAP (Uniform Manifold Approximation and Projection) est souvent préféré à t-SNE car il est plus rapide et préserve mieux la structure globale. En d’autres termes, la distance entre deux clusters sur un graphique UMAP a un sens, alors qu’avec t-SNE, elle est arbitraire.

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()

Le tableau suivant résume les compromis entre les deux méthodes.

Critèret-SNEUMAP
VitesseLente (O(n²))Rapide
Structure globaleMal préservéeBien préservée
ReproductibilitéVariableStable
Paramètresperplexityn_neighbors, min_dist

Visualisation interactive 3D

Sur un corpus de quelques centaines de points, une figure statique devient illisible : les étiquettes se chevauchent et vous ne pouvez pas dire quel texte correspond à quel point. Plotly résout ce problème en déplaçant l’information dans des infobulles et en vous permettant de faire pivoter le nuage de points.

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()

Le fichier HTML résultant est prêt à être partagé. C’est un excellent moyen de montrer à une équipe métier comment leurs documents sont distribués sans écrire une seule ligne de code.

Visualiser l’effet de la réduction de dimensionnalité

La leçon 2 indiquait que la troncature d’un vecteur à 256 dimensions conserve environ 88 % de sa qualité. Ce chiffre reste abstrait tant que vous ne l’avez pas vu. En générant le même corpus avec quatre tailles différentes et en projetant chaque version, vous observez directement quand les clusters commencent à se toucher. Cela vous permet de décider sur la base de preuves plutôt que d’une règle générale.

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 avertissement avant d’interpréter ces figures : la projection déforme toujours. Un point isolé sur le graphique n’est pas nécessairement isolé dans l’espace d’origine, et deux clusters collés ensemble en 2D peuvent être parfaitement séparés en 3 072 dimensions. La visualisation vous aide à formuler une hypothèse, jamais à la valider. La validation repose sur les métriques que nous aborderons dans la leçon 10.

Belangrijkste punten

  • t-SNE et UMAP projettent les embeddings en 2D/3D pour la visualisation
  • UMAP est généralement préféré pour sa rapidité et sa fidélité
  • Plotly permet des visualisations 3D interactives
  • La visualisation aide à valider la qualité des embeddings et à détecter les anomalies