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

Clasificación de texto con embeddings

Lección 17 de 22 Actualizado el 29 de julio de 2026 Desarrollador
En esta página
  1. Objetivos
  2. Clasificación zero-shot
  3. Clasificación few-shot
  4. Clasificador supervisado ligero
  5. Comparación de enfoques
  6. Resumen

Objetivos

  • Clasificar texto sin entrenar un modelo
  • Implementar clasificación zero-shot y few-shot utilizando embeddings
  • Comparar el rendimiento con un clasificador supervisado ligero

Clasificación zero-shot

La búsqueda semántica encuentra documentos similares a una consulta entre miles de candidatos. La clasificación invierte este planteamiento sin alterar la mecánica subyacente: tus «documentos» son ahora tus categorías (cinco o diez), y la «consulta» es el texto que deseas clasificar. La etiqueta cuyo embedding esté más cercano se convierte en la predicción. Sin entrenamiento, sin datos anotados, solo una llamada a la API.

Dos detalles de implementación en el código de abajo merecen atención. Primero, el texto y los nombres de las categorías se incluyen en una única llamada a embeddings.create, lo que reduce la latencia en función del número de etiquetas. Segundo, aplicar softmax a las puntuaciones de similitud convierte los valores brutos (típicamente entre 0,3 y 0,5) en probabilidades que suman 1. Puedes mostrar estas probabilidades a un usuario o compararlas con un umbral de confianza.

from openai import OpenAI
import numpy as np

client = OpenAI()

def classifier_zero_shot(
    texte: str,
    categories: list[str],
    model: str = "text-embedding-3-large"
) -> dict:
    """Clasifica texto en categorías sin entrenamiento."""
    # Embeddings para las categorías
    all_inputs = [texte] + categories
    response = client.embeddings.create(
        input=all_inputs,
        model=model
    )
    embs = [d.embedding for d in sorted(response.data, key=lambda x: x.index)]
    texte_emb = np.array(embs[0])
    cat_embs = np.array(embs[1:])

    # Similitud con cada categoría
    scores = cat_embs @ texte_emb

    # Softmax para obtener probabilidades
    exp_scores = np.exp(scores - np.max(scores))
    probas = exp_scores / exp_scores.sum()

    resultats = sorted(
        zip(categories, probas),
        key=lambda x: x[1], reverse=True
    )

    return {
        "prediction": resultats[0][0],
        "confiance": float(resultats[0][1]),
        "scores": {cat: float(p) for cat, p in resultats}
    }

# Uso
texte = "Le cours de l'action a chuté de 15% après l'annonce"
categories = ["Finance", "Sport", "Technologie", "Politique", "Santé"]

resultat = classifier_zero_shot(texte, categories)
print(f"Prédiction : {resultat['prediction']} "
      f"({resultat['confiance']:.1%})")
print("Scores :", resultat["scores"])

En este ejemplo, «el precio de la acción cayó un 15 % tras el anuncio» acaba, como era de esperar, en Finanzas. Este enfoque encuentra un límite cuando las categorías son etiquetas internas cuyos nombres no revelan nada sobre su contenido. Una etiqueta como «P1» o «escalado de nivel 2» carece de significado semántico explotable, lo que hace que la clasificación sea esencialmente aleatoria.

Clasificación few-shot

Esto es exactamente lo que soluciona la clasificación few-shot. En lugar de representar una categoría por su nombre, la representas mediante el centroide de unos pocos ejemplos reales. La categoría «bug» ya no es la palabra «bug», sino la media de los embeddings de «la aplicación se cierra al iniciar», «error 500 en la página de inicio de sesión» y «el botón no funciona en móvil». Suelen bastar de tres a cinco ejemplos por clase, y el coste sigue siendo el de una única llamada a la API, ya que todos los textos se envían juntos.

def classifier_few_shot(
    texte: str,
    exemples: dict[str, list[str]],
    model: str = "text-embedding-3-large"
) -> dict:
    """Clasifica por similitud con ejemplos etiquetados.

    Args:
        exemples: {"categoría": ["ejemplo1", "ejemplo2", ...]}
    """
    # Preparar todos los textos
    tous_textes = [texte]
    mapping = []
    for cat, txts in exemples.items():
        for t in txts:
            tous_textes.append(t)
            mapping.append(cat)

    # Embeddings en una única llamada
    response = client.embeddings.create(
        input=tous_textes, model=model
    )
    embs = [d.embedding for d in sorted(response.data, key=lambda x: x.index)]
    texte_emb = np.array(embs[0])

    # Media de embeddings por categoría
    cat_embeddings = {}
    for i, cat in enumerate(mapping):
        emb = np.array(embs[i + 1])
        if cat not in cat_embeddings:
            cat_embeddings[cat] = []
        cat_embeddings[cat].append(emb)

    cat_moyennes = {
        cat: np.mean(embs_list, axis=0)
        for cat, embs_list in cat_embeddings.items()
    }

    # Similitud
    scores = {
        cat: float(np.dot(texte_emb, emb_moy) /
                    (np.linalg.norm(texte_emb) * np.linalg.norm(emb_moy)))
        for cat, emb_moy in cat_moyennes.items()
    }

    prediction = max(scores, key=scores.get)
    return {"prediction": prediction, "scores": scores}

# Uso
exemples = {
    "bug": [
        "L'application crash au démarrage",
        "Erreur 500 sur la page de connexion",
        "Le bouton ne fonctionne pas sur mobile",
    ],
    "feature": [
        "Pourriez-vous ajouter un mode sombre ?",
        "Il serait utile d'exporter en PDF",
        "Suggestion : intégrer un calendrier",
    ],
    "question": [
        "Comment changer mon mot de passe ?",
        "Où trouver les paramètres de notification ?",
        "Quelle est la limite de stockage ?",
    ],
}

texte = "L'export CSV ne contient pas toutes les colonnes"
resultat = classifier_few_shot(texte, exemples)
print(f"Catégorie : {resultat['prediction']}")

El ticket de prueba —«la exportación CSV no incluye todas las columnas»— no contiene ni la palabra «bug» ni «error», pero se parece a los tres ejemplos de mal funcionamiento proporcionados, así que ahí es donde acaba. Ten en cuenta que hacer la media de los embeddings asume una categoría homogénea. Si tus ejemplos de «pregunta» mezclan consultas de facturación con preguntas sobre la API, su centroide caerá en una tierra de nadie semántica. En ese caso, es mejor dividir la categoría.

Clasificador supervisado ligero

Cuando tienes varias decenas de ejemplos por clase, hacer la media supone un desperdicio de información: aplana la forma de la nube de puntos. Un clasificador lineal entrenado con los mismos embeddings aprende en su lugar un límite de decisión. El embedding se encarga de la comprensión del lenguaje, mientras que LogisticRegression simplemente traza una línea geométrica en ese espacio. Esto da como resultado tiempos de entrenamiento de unos pocos segundos en una CPU estándar, whereas fine-tuning a language model would require a GPU (mientras que el ajuste fino de un modelo de lenguaje requeriría una GPU).

La validación cruzada de cinco pliegues no es solo un adorno. Te proporciona la desviación estándar de la precisión, ofreciendo una idea de la fiabilidad de tu estimación. Una puntuación de 0,91 ± 0,02 es utilizable; 0,91 ± 0,15 indica un conjunto de datos demasiado pequeño o desequilibrado.

from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score
import numpy as np

def entrainer_classifieur(
    textes: list[str],
    labels: list[str],
    model: str = "text-embedding-3-large"
) -> LogisticRegression:
    """Entrena un clasificador sobre embeddings."""
    # Generar embeddings
    response = client.embeddings.create(
        input=textes, model=model
    )
    X = np.array([d.embedding for d in sorted(response.data, key=lambda x: x.index)])

    # Entrenar un clasificador
    clf = LogisticRegression(max_iter=1000)
    
    # Validación cruzada
    scores = cross_val_score(clf, X, labels, cv=5)
    print(f"Accuracy (5-fold CV) : {scores.mean():.3f} ± {scores.std():.3f}")

    # Entrenar con el conjunto de datos completo
    clf.fit(X, labels)
    return clf

def predire(clf, texte: str, model: str = "text-embedding-3-large") -> str:
    """Predice la categoría de un texto."""
    emb = client.embeddings.create(
        input=texte, model=model
    ).data[0].embedding
    return clf.predict([emb])[0]

Comparación de enfoques

EnfoqueEjemplos necesariosPrecisiónLatencia
Zero-shot0~70-80 %1 llamada a la API
Few-shot (3-5/clase)15-25~80-90 %1 llamada a la API
Supervisado (50+/clase)250+~90-95 %1 llamada a la API + inferencia

Leídas en orden, estas tres líneas describen una progresión que puedes seguir a lo largo del ciclo de vida del producto. Comienza con zero-shot el primer día, sin ningún dato. Una vez hayas corregido manualmente una veintena de predicciones, recíclalas como ejemplos few-shot. Cuando el volumen de anotaciones supere los cincuenta por clase, entrena el clasificador supervisado. Ten en cuenta que la fila de «latencia» te recuerda que incluso el modelo supervisado sigue siendo rápido; la inferencia local añade una sobrecarga insignificante en comparación con la llamada a la API de embeddings.

Resumen

  • La clasificación zero-shot compara el texto con las etiquetas mediante embeddings
  • Few-shot utiliza ejemplos para definir cada categoría
  • Un clasificador supervisado (LogisticRegression) logra el mejor rendimiento
  • Comienza con zero-shot y añade ejemplos si la precisión es insuficiente