Introduction

Dans le monde en constante évolution de l'intelligence artificielle générative, l'attention se porte souvent sur les interfaces de chat et les systèmes d'invitation. Cependant, les grands modèles de langage (LLM) possèdent des capacités bien plus vastes. L'une de leurs fonctionnalités les plus impressionnantes est la capacité à convertir des textes bruts, souvent désordonnés et non structurés, en représentations mathématiques sophistiquées appelées embeddings. Ces embeddings servent de base à de nombreux cas d'utilisation en apprentissage automatique, et le clustering est l'un des plus prometteurs.

Les embeddings, lorsqu'ils sont combinés avec des techniques de clustering avancées basées sur la densité, telles que HDBSCAN, permettent de découvrir des thèmes, des motifs ou des catégories cachés dans des collections de documents textuels. Ce processus ne nécessite pas d'étiquetage préalable, ce qui le rend particulièrement puissant pour analyser des données non structurées.

Cet article détaille la construction d'un pipeline de clustering textuel à partir de zéro. Nous utiliserons un ensemble de données accessible au public, contenant des exemples de texte, et un modèle d'embedding open-source pour générer ces représentations. En outre, nous tirerons parti de bibliothèques Python modernes, gratuites et pratiques, qui offrent des implémentations d'algorithmes de clustering comme HDBSCAN.

Étapes à suivre

Pour commencer, il est essentiel d'installer les bibliothèques Python nécessaires :

• Sentence transformers : Cette bibliothèque permet de charger un LLM pré-entraîné pour la génération d'embeddings depuis Hugging Face. Une clé API Hugging Face, ou jeton d'accès, est requise pour charger le modèle.
• Umap-learn : Utilisée pour appliquer un algorithme de réduction de la dimensionnalité aux embeddings.

Si vous travaillez sur un IDE local plutôt que sur un environnement de notebook cloud, vous devrez peut-être également installer scikit-learn et pandas si ce n'est pas déjà fait.

!pip install sentence-transformers umap-learn

Nous passons maintenant à la phase de codage en récupérant des données fraîches. La fonction fetch_20newsgroups est utilisée pour obtenir un ensemble de données contenant des textes d'articles de nouvelles catégorisés. Bien que cet ensemble contienne des étiquettes, nous les ignorerons pour simuler une situation où nous ne connaissons pas ces informations, dans le but de regrouper les données en fonction de leur similarité. Nous réduisons l'ensemble de données à 150 instances pour notre exemple.

import pandas as pd
from sklearn.datasets import fetch_20newsgroups

# Récupération d'un sous-ensemble de données très ciblé (~150-200 docs)
categories = ['sci.space', 'sci.med', 'rec.autos']
newsgroups = fetch_20newsgroups(subset='train', categories=categories, remove=('headers', 'footers', 'quotes'))

Échantillonnage d'un sous-ensemble représentatif et illustratif

df = pd.DataFrame({'text': newsgroups.data, 'true_label': newsgroups.target}) df = df[df['text'].str.strip().str.len() > 100].sample(150, random_state=42).reset_index(drop=True) print(f"Chargé {len(df)} documents textuels.") print("\nDocument d'exemple :") print(df['text'].iloc[0][:150] + "...")

## Génération des embeddings

La prochaine étape consiste à générer des embeddings à partir des textes bruts. Pour ce faire, nous utilisons le modèle **all-MiniLM-L6-v2** de la bibliothèque **sentence-transformers** de Hugging Face. Ce modèle est léger mais efficace pour obtenir rapidement des embeddings.

```python
from sentence_transformers import SentenceTransformer

# Chargement du modèle open-source gratuit
model = SentenceTransformer('all-MiniLM-L6-v2')

# Encodage des documents textuels en embeddings vectoriels denses
print("Génération des embeddings...")
embeddings = model.encode(df['text'].tolist(), show_progress_bar=True)
print(f"Forme de la matrice d'embedding : {embeddings.shape}")

Étant donné que la dimension des embeddings est initialement trop élevée pour le clustering, nous appliquons une technique de réduction de dimensionnalité en utilisant l'algorithme UMAP de la bibliothèque éponyme installée précédemment :

import umap

# Réduction des dimensions des embeddings à 5, pour conserver suffisamment d'informations de densité pour le clustering
reducer = umap.UMAP(n_neighbors=15, n_components=5, min_dist=0.0, random_state=42)
reduced_embeddings = reducer.fit_transform(embeddings)
print(f"Forme de la matrice réduite : {reduced_embeddings.shape}")

Application de HDBSCAN

Avec nos vecteurs d'embedding numériques réduits à cinq dimensions, nous pouvons maintenant appliquer l'algorithme HDBSCAN pour voir si cette représentation compacte permet un clustering significatif.

from sklearn.cluster import HDBSCAN

# Initialisation de HDBSCAN
# min_cluster_size=8 : nous avons spécifié que chaque cluster doit contenir au moins 8 documents
clusterer = HDBSCAN(min_cluster_size=8, min_samples=3, store_centers='centroid')
df['cluster'] = clusterer.fit_predict(reduced_embeddings)

# Comptage des instances par cluster
cluster_counts = df['cluster'].value_counts()
print("\nDistribution des clusters :")
print(cluster_counts)

Résultats

Il semble que HDBSCAN ait identifié deux clusters principaux associés à des zones de haute densité dans l'espace des données. Cependant, il est également possible que certains points soient considérés comme du bruit et ne soient pas attribués à ces clusters. Examinons cela de plus près :

for cluster_id in sorted(df['cluster'].unique()):
    if cluster_id == -1:
        print("\n=== CLUSTER : BRUIT / NON CLASSIFIÉ ===")
    else:
        print(f"\n=== CLUSTER : Sujet Découvert #{cluster_id} ===")
        # Obtention de jusqu'à 3 textes d'exemple de ce cluster
        samples = df[df['cluster'] == cluster_id]['text'].head(3).tolist()
        for i, sample in enumerate(samples, 1):
            clean_sample = " ".join(sample.split())[:120]
            print(f"  {i}. {clean_sample}...")

Conclusion

Les résultats du clustering sont partiellement influencés par les paramètres hyperparamétriques que nous avons définis pour HDBSCAN. Il est conseillé d'expérimenter avec différentes configurations pour la taille minimale des clusters et d'autres hyperparamètres afin d'explorer comment cela affecte les résultats.