AI Engineering Academy · Leçon

Regrouper et visualiser des embeddings

Appliquez un regroupement k-moyennes à un ensemble d’embeddings et visualisez-les en 2D avec UMAP afin de découvrir les regroupements thématiques naturels de vos données.

Regrouper et visualiser des embeddings est une leçon AI Engineering Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Engineering Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Engineering Academy comprend 4 leçons au total.

Pourquoi regrouper les représentations vectorielles ?

Lorsque vous disposez de centaines ou de milliers de documents, vous souhaitez souvent découvrir quels sujets sont présents sans tout lire manuellement. Le regroupement des représentations vectorielles rassemble automatiquement les documents sémantiquement similaires et révèle la structure naturelle de vos données.

Parmi les applications courantes figurent l’attribution automatique d’étiquettes aux tickets d’assistance, la découverte de catégories de contenu, la détection de documents redondants et l’analyse des sujets qui intéressent le plus les utilisateurs.

Présentation du regroupement K-means

K-means répartit n points de données en k groupes en attribuant itérativement chaque point au centroïde le plus proche, puis en recalculant les centroïdes comme moyenne des points attribués. Il converge lorsque les attributions ne changent plus.

Pour les représentations vectorielles, k-means trouve les documents proches dans l’espace de représentation de grande dimension et les regroupe efficacement selon leur similarité sémantique.

from sklearn.cluster import KMeans
import numpy as np

# corpus_embeddings: (n_docs, 1536) — pre-computed
corpus_embeddings = np.random.randn(200, 1536)  # placeholder

kmeans = KMeans(n_clusters=5, random_state=42, n_init='auto')
kmeans.fit(corpus_embeddings)

labels = kmeans.labels_
print(f'Cluster assignments: {labels[:10]}')
print(f'Unique clusters: {set(labels)}')

Choisir le nombre approprié de groupes

Choisir k (le nombre de groupes) est la partie la plus difficile. La méthode du coude représente l’inertie (la somme des distances au carré par rapport aux centroïdes) pour différentes valeurs de k et recherche le point à partir duquel l’ajout de groupes ne réduit plus significativement l’inertie.

Le score de silhouette mesure dans quelle mesure un point s’intègre mieux à son propre groupe qu’au groupe voisin le plus proche — les scores proches de 1 sont meilleurs. Essayez des valeurs de k comprises entre 3 et 20 et retenez le meilleur score.

from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score
import numpy as np

corpus_embeddings = np.random.randn(200, 50)  # placeholder (50D for speed)

best_k, best_score = 2, -1
for k in range(2, 11):
    km = KMeans(n_clusters=k, random_state=42, n_init='auto')
    labels = km.fit_predict(corpus_embeddings)
    score = silhouette_score(corpus_embeddings, labels, sample_size=100)
    print(f'k={k}: silhouette={score:.3f}')
    if score > best_score:
        best_score, best_k = score, k

print(f'Best k: {best_k}')

Étiqueter les groupes avec un LLM

Après le regroupement, vous pouvez demander à un LLM de générer une étiquette compréhensible par l’être humain pour chaque groupe en lui transmettant quelques documents représentatifs de ce groupe. Cela transforme automatiquement les numéros bruts des groupes en noms de catégories pertinents.

from openai import OpenAI

client = OpenAI()

def label_cluster(cluster_docs, n_examples=3):
    examples = '\n'.join(f'- {d}' for d in cluster_docs[:n_examples])
    prompt = f'Given these documents, provide a 3-word category label:\n{examples}\nLabel:'
    response = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[{'role': 'user', 'content': prompt}],
        max_tokens=20
    )
    return response.choices[0].message.content.strip()

# Example usage:
# cluster_0_docs = [documents[i] for i in range(len(documents)) if labels[i] == 0]
# print(label_cluster(cluster_0_docs))

Réduire la dimensionnalité avec UMAP

Les vecteurs de 1536 dimensions ne peuvent pas être représentés directement. UMAP (Uniform Manifold Approximation and Projection) réduit les données de grande dimension à 2D ou 3D tout en préservant la structure du voisinage local. Contrairement à PCA, UMAP est non linéaire et préserve beaucoup mieux les groupes.

UMAP est le choix standard pour visualiser les représentations vectorielles de textes, car les documents similaires restent proches les uns des autres dans le graphique 2D.

import umap
import numpy as np

corpus_embeddings = np.random.randn(200, 1536)  # placeholder

reducer = umap.UMAP(
    n_components=2,
    metric='cosine',   # important for text embeddings
    random_state=42
)

embeddings_2d = reducer.fit_transform(corpus_embeddings)
print(f'Reduced shape: {embeddings_2d.shape}')  # (200, 2)

Visualiser les groupes avec Matplotlib

Une fois les coordonnées 2D obtenues avec UMAP et les étiquettes de groupes produites par k-means, un simple nuage de points rend la structure des groupes visible. Colorez chaque point selon son étiquette de groupe et ajoutez les titres des documents représentatifs sous forme d’annotations textuelles pour rendre le graphique interprétable.

import matplotlib.pyplot as plt
import numpy as np

# Assume: embeddings_2d (n, 2), labels (n,), documents list
# Placeholder data:
np.random.seed(42)
embeddings_2d = np.random.randn(50, 2)
labels = np.random.randint(0, 5, 50)

fig, ax = plt.subplots(figsize=(10, 7))
scatter = ax.scatter(
    embeddings_2d[:, 0],
    embeddings_2d[:, 1],
    c=labels,
    cmap='tab10',
    s=60,
    alpha=0.8
)
plt.colorbar(scatter, label='Cluster')
ax.set_title('Document Embedding Clusters (UMAP)')
plt.tight_layout()
plt.savefig('/tmp/clusters.png', dpi=150)
print('Saved cluster plot')

Paramètres UMAP importants

Principaux hyperparamètres UMAP qui influencent la qualité de la visualisation :

n_neighbors (valeur par défaut : 15) : les valeurs élevées capturent davantage la structure globale, tandis que les valeurs faibles révèlent les groupes locaux
min_dist (valeur par défaut : 0,1) : degré de regroupement des points ; une valeur plus faible produit des groupes plus compacts, mais davantage de chevauchements entre eux
metric : utilisez toujours 'cosine' pour les représentations vectorielles de textes — la distance euclidienne ne convient pas

Expérimentez avec une valeur de n_neighbors comprise entre 5 et 50 afin de trouver la visualisation qui révèle le mieux la structure de vos données.

Alternative : le regroupement hiérarchique

Le regroupement hiérarchique agglomératif construit un arbre de groupes imbriqués sans vous obliger à définir k à l’avance. Vous coupez l’arbre à un seuil de distance choisi pour obtenir vos groupes finaux. Cette méthode est utile lorsque vous ignorez combien de sujets naturels sont présents dans vos données.

from sklearn.cluster import AgglomerativeClustering
import numpy as np

corpus_embeddings = np.random.randn(100, 50)  # placeholder

cluster = AgglomerativeClustering(
    n_clusters=None,
    distance_threshold=1.5,
    metric='cosine',
    linkage='average'
)
labels = cluster.fit_predict(corpus_embeddings)

n_clusters = len(set(labels))
print(f'Found {n_clusters} natural clusters')

Trouver les valeurs aberrantes et les quasi-doublons

Les représentations vectorielles sont également très efficaces pour trouver les documents quasi identiques. Calculez la similarité cosinus par paire entre tous les documents et signalez comme doublons potentiels les paires dont la similarité dépasse 0,95. Cette méthode est plus robuste que la comparaison directe des textes, car elle détecte aussi les doublons reformulés.

import numpy as np

def find_near_duplicates(corpus_vecs, threshold=0.95):
    # corpus_vecs assumed L2-normalized
    sim_matrix = corpus_vecs @ corpus_vecs.T  # (n, n)
    duplicates = []
    n = len(corpus_vecs)
    for i in range(n):
        for j in range(i + 1, n):
            if sim_matrix[i, j] >= threshold:
                duplicates.append((i, j, float(sim_matrix[i, j])))
    return duplicates

# pairs = find_near_duplicates(corpus_embeddings)
# print(f'Found {len(pairs)} near-duplicate pairs')

Flux de travail pratique pour le regroupement

Un flux de travail réel de regroupement suit ces étapes dans l’ordre :

Vectoriser tous les documents avec text-embedding-3-small
Réduire éventuellement les données à 50 dimensions avec UMAP avant le regroupement (pour accélérer k-means)
Effectuer le regroupement avec k-means et tester plusieurs valeurs de k pour trouver le meilleur score de silhouette
Étiqueter chaque groupe avec un LLM à l’aide de 5 documents représentatifs
Visualiser le nuage de points UMAP 2D, coloré selon les groupes
Examiner les valeurs aberrantes (les points éloignés de tout centroïde)

Limites du regroupement

Le regroupement des représentations vectorielles présente des limites importantes à garder à l’esprit :

K-means suppose des groupes sphériques — les groupes thématiques allongés ou de forme irrégulière peuvent être mal répartis
Les représentations vectorielles compressent le sens — deux documents peuvent être sémantiquement proches tout en appartenant à des catégories opérationnelles différentes
Les étiquettes des groupes doivent être vérifiées — prélevez toujours des documents dans chaque groupe afin de contrôler la pertinence de l’étiquette générée par le LLM

Utilisez le regroupement comme outil d’exploration, et non comme système de catégorisation faisant foi.

Vérification rapide

Vérifiez votre compréhension des concepts d’ingénierie de l’IA présentés dans cette leçon.

Récapitulatif de la leçon

Dans cette leçon, vous avez appris que k-means regroupe les documents selon leur proximité sémantique dans l’espace des plongements, que UMAP réduit les plongements de grande dimension à 2D pour la visualisation à l’aide de la distance cosinus et que le score de silhouette vous aide à choisir le bon nombre de clusters sans données étiquetées. Nous allons maintenant dépasser la recherche en mémoire et découvrir les bases de données vectorielles destinées à la production.

Questions Fréquemment Posées

La leçon « Regrouper et visualiser des embeddings » est-elle gratuite ?

Oui — le texte complet de « Regrouper et visualiser des embeddings » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Engineering Academy, passe à CoddyKit PRO. Le cours AI Engineering Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Regrouper et visualiser des embeddings » ?

Appliquez un regroupement k-moyennes à un ensemble d’embeddings et visualisez-les en 2D avec UMAP afin de découvrir les regroupements thématiques naturels de vos données. Tu pratiques AI Engineering Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Engineering Academy ?

Aucune expérience préalable n'est requise. AI Engineering Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Regrouper et visualiser des embeddings » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Engineering Academy ?

Oui. Chaque leçon AI Engineering Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à AI Engineering Academy