Ir al contenido principal
Español— Elegir un idioma
Menú

Clustering: Agrupación automática

Lección 18 de 22 Actualizado el 29 de julio de 2026 Desarrollador
En esta página
  1. Objetivos
  2. ¿Por qué hacer clustering?
  3. K-Means sobre embeddings
  4. Encontrar el número correcto de clústeres
  5. HDBSCAN: Clustering sin K
  6. Nombrar automáticamente los clústeres
  7. Canalización completa de clustering
  8. Resumen

Objetivos

  • Agrupar textos por temática sin etiquetas predefinidas
  • Utilizar K-Means y HDBSCAN sobre embeddings
  • Nombrar automáticamente los clústeres

¿Por qué hacer clustering?

La lección sobre clasificación partía de la base de que ya conocías las categorías existentes. El clustering aborda la situación opuesta, que es también la más habitual al explorar un corpus: nadie sabe qué contiene. Recuperas ocho mil verbatims de una encuesta de satisfacción o seis meses de tickets de soporte, y la primera pregunta no es «cuántos errores hay», sino «¿de qué está hablando la gente realmente?». El clustering descubre grupos temáticos sin que se le indique nada de antemano.

Tres casos de uso surgen constantemente: analizar miles de opiniones de clientes para extraer patrones dominantes, identificar temas recurrentes en tickets de soporte para alimentar una base de conocimientos y explorar un corpus de documentos desconocido antes de decidir cómo indexarlo.

K-Means sobre embeddings

K-Means es el algoritmo de referencia: le indicas un número de grupos, coloca esa cantidad de centros e itera desplazando cada centro hacia la media de los puntos que atrae. Al aplicarlo sobre embeddings en lugar de sobre una bolsa de palabras, agrupa por significado: «la aplicación se cierra al iniciar» y «no puedo iniciar sesión desde ayer» acaban juntos aunque no compartan ninguna palabra.

El corpus de ejemplo siguiente contiene intencionadamente cuatro familias —errores, solicitudes de funcionalidades, preguntas y elogios— para que puedas verificar visualmente la agrupación resultante. El parámetro random_state=42 garantiza que obtendrás los mismos clústeres en cada ejecución, algo esencial siempre que necesites comparar dos configuraciones.

from openai import OpenAI
from sklearn.cluster import KMeans
import numpy as np

client = OpenAI()

# Corpus de ejemplo
textes = [
    "L'application crash au démarrage sur Android",
    "Bug : impossible de se connecter depuis hier",
    "Le bouton de validation ne fonctionne pas",
    "Pourriez-vous ajouter un export Excel ?",
    "Suggestion : un mode hors-ligne serait utile",
    "Feature request : intégrer Slack",
    "Comment changer mon adresse email ?",
    "Où trouver ma facture de janvier ?",
    "Quel est le prix de l'abonnement annuel ?",
    "Votre produit est excellent, bravo !",
    "Merci pour le support réactif",
    "Je recommande vivement cette application",
]

# Generar embeddings
response = client.embeddings.create(
    input=textes,
    model="text-embedding-3-large"
)
embeddings = np.array(
    [d.embedding for d in sorted(response.data, key=lambda x: x.index)]
)

# Clustering con K-Means
n_clusters = 4
kmeans = KMeans(n_clusters=n_clusters, random_state=42, n_init=10)
labels = kmeans.fit_predict(embeddings)

# Mostrar clústeres
for cluster_id in range(n_clusters):
    print(f"\n--- Cluster {cluster_id} ---")
    indices = [i for i, l in enumerate(labels) if l == cluster_id]
    for idx in indices:
        print(f"  {textes[idx]}")

Encontrar el número correcto de clústeres

Con doce frases preparadas, elegir cuatro era obvio. Con ocho mil verbatims, nadie conoce el valor adecuado. Dos métricas te ayudan a estimarlo. La inercia, es decir, la dispersión residual dentro de los grupos, disminuye mecánicamente a medida que añades clústeres: buscas el «codo», el punto a partir del cual ya no desciende significativamente. La puntuación de silueta es más decisiva porque mide algo distinto: cuánto más cerca está cada punto de su propio grupo que del grupo vecino más próximo. A diferencia de la inercia, tiene un máximo, y ese máximo señala directamente un valor candidato.

from sklearn.metrics import silhouette_score
import matplotlib.pyplot as plt

inertias = []
silhouettes = []
K_range = range(2, 10)

for k in K_range:
    km = KMeans(n_clusters=k, random_state=42, n_init=10)
    km.fit(embeddings)
    inertias.append(km.inertia_)
    silhouettes.append(silhouette_score(embeddings, km.labels_))

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))

ax1.plot(K_range, inertias, "bo-")
ax1.set_xlabel("Number of clusters")
ax1.set_ylabel("Inertia")
ax1.set_title("Elbow method")

ax2.plot(K_range, silhouettes, "ro-")
ax2.set_xlabel("Number of clusters")
ax2.set_ylabel("Silhouette score")
ax2.set_title("Silhouette score")

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

meilleur_k = K_range[np.argmax(silhouettes)]
print(f"Best k according to silhouette: {meilleur_k}")

HDBSCAN: Clustering sin K

K-Means adolece de un defecto estructural con datos del mundo real: debe asignar cada punto a un clúster. Un verbatim aislado que no se parece a nada acaba forzosamente adherido al grupo menos distante, donde contamina la interpretación. HDBSCAN razona en términos de densidad y acepta decir «no»: determina él mismo el número de grupos y coloca los puntos aislados en una categoría separada etiquetada como -1.

Estos valores atípicos no son basura. En un corpus de tickets, suelen ser incidentes raros, solicitudes fuera de alcance o señales débiles; exactamente lo que merece una revisión humana. El código siguiente los muestra por separado en lugar de descartarlos.

import hdbscan

clusterer = hdbscan.HDBSCAN(
    min_cluster_size=3,
    min_samples=2,
    metric="euclidean"
)
labels_hdbscan = clusterer.fit_predict(embeddings)

n_clusters = len(set(labels_hdbscan)) - (1 if -1 in labels_hdbscan else 0)
n_outliers = list(labels_hdbscan).count(-1)

print(f"Clusters found: {n_clusters}")
print(f"Outliers: {n_outliers}")

for cluster_id in range(n_clusters):
    print(f"\n--- Cluster {cluster_id} ---")
    indices = [i for i, l in enumerate(labels_hdbscan) if l == cluster_id]
    for idx in indices:
        print(f"  {textes[idx]}")

if n_outliers > 0:
    print("\n--- Outliers ---")
    for i, l in enumerate(labels_hdbscan):
        if l == -1:
            print(f"  {textes[i]}")

Nombrar automáticamente los clústeres

Un algoritmo de clustering te devuelve números. «Clúster 2» no tiene cabida en un informe ni en un cuadro de mandos. El paso que hace usable el resultado consiste en enviar una docena de miembros representativos al LLM y pedirle un nombre corto: «Problemas de conexión», «Solicitudes de integración», «Preguntas sobre facturación». Limitarse a diez ejemplos controla el coste, fijar la temperatura en cero asegura que el mismo clúster reciba siempre el mismo nombre, y el bucle ignora la etiqueta -1 ya que los valores atípicos, por definición, no tienen tema común.

def nommer_clusters(
    textes: list[str],
    labels: list[int]
) -> dict[int, str]:
    """Nombra cada clúster utilizando un LLM."""
    noms = {}
    clusters = set(l for l in labels if l >= 0)

    for cluster_id in clusters:
        exemples = [
            textes[i] for i, l in enumerate(labels)
            if l == cluster_id
        ][:10]  # Máx. 10 ejemplos

        response = client.chat.completions.create(
            model="gpt-5.6-terra",
            messages=[{
                "role": "user",
                "content": (
                    f"Voici des textes regroupés dans un même cluster :\n\n"
                    + "\n".join(f"- {e}" for e in exemples) +
                    f"\n\nDonne un nom court (2-4 mots) qui décrit "
                    f"le thème commun de ce groupe. "
                    f"Retourne uniquement le nom."
                )
            }],
            temperature=0,
            max_tokens=20
        )
        noms[cluster_id] = response.choices[0].message.content.strip()

    return noms

# Uso
noms = nommer_clusters(textes, labels)
for cluster_id, nom in noms.items():
    print(f"Cluster {cluster_id}: {nom}")
    indices = [i for i, l in enumerate(labels) if l == cluster_id]
    for idx in indices:
        print(f"  - {textes[idx]}")

Canalización completa de clustering

Los tres pasos —embedding, clustering y nombrado— se ensamblan naturalmente en una única clase. El parámetro methode acepta "auto", que delega la elección del número de grupos en HDBSCAN, o un valor numérico pasado como cadena cuando quieres imponer una K a K-Means. El diccionario devuelto contiene las etiquetas, los nombres legibles y dos contadores que te indican de inmediato si el resultado merece la pena: un n_outliers cercano al total significa que tu corpus carece de estructura densa y deberías volver a K-Means.

class PipelineClustering:
    def __init__(self, model: str = "text-embedding-3-large"):
        self.client = OpenAI()
        self.model = model

    def analyser(self, textes: list[str], methode: str = "auto") -> dict:
        """Canalización completa: embedding → clustering → nombrado."""
        # 1. Embeddings
        response = self.client.embeddings.create(
            input=textes, model=self.model
        )
        embs = np.array([
            d.embedding for d in sorted(response.data, key=lambda x: x.index)
        ])

        # 2. Clustering
        if methode == "auto":
            clusterer = hdbscan.HDBSCAN(min_cluster_size=3)
            labels = clusterer.fit_predict(embs)
        else:
            km = KMeans(n_clusters=int(methode), random_state=42)
            labels = km.fit_predict(embs)

        # 3. Nombrar clústeres
        noms = nommer_clusters(textes, labels)

        return {
            "labels": labels.tolist(),
            "noms": noms,
            "n_clusters": len(set(l for l in labels if l >= 0)),
            "n_outliers": list(labels).count(-1)
        }

pipeline = PipelineClustering()
resultats = pipeline.analyser(textes)

Resumen

  • Usa K-Means cuando conozcas el número de clústeres
  • Usa HDBSCAN para detectar automáticamente grupos y valores atípicos
  • La puntuación de silueta ayuda a elegir la K adecuada
  • Un LLM nombra automáticamente los clústeres descubiertos
  • Los embeddings hacen que el clustering sea semántico, no solo léxico