NLP, embeddings y Transformers

Un modelo no lee: recibe números de tamaño fijo, y el lenguaje no es ni numérico ni de tamaño fijo. Una frase tiene ocho palabras y otra cuarenta, y «banco» significa cosas distintas según la oración.

La solución actual se apoya en dos ideas: partir el texto en unidades con vectores densos (embeddings) y dejar que cada unidad mire a las demás para decidir qué significa en contexto (atención). Esa combinación es el Transformer.

¿Qué es el procesamiento de lenguaje natural?

El NLP (Natural Language Processing) es la rama que estudia cómo hacer tareas útiles con texto: clasificar, extraer, traducir, resumir, responder preguntas. La dificultad no es solo la ambigüedad; también lo es la variabilidad: dos frases con el mismo sentido pueden compartir muy pocas palabras, y una sola palabra puede invertir el significado.

¿Para qué sirve?

• Clasificación: detectar spam, medir el tono de un comentario o etiquetar tickets de soporte.
• Búsqueda semántica: encontrar documentos por significado y no por coincidencia exacta de palabras.
• Extracción: sacar nombres, fechas e importes de contratos y facturas.
• Generación: resumir, redactar y responder preguntas con modelos tipo GPT.
• Traducción y transcripción: convertir voz en texto y texto en otro idioma.
• Deduplicación y agrupamiento: detectar noticias repetidas o agrupar reseñas por tema.

¿Cómo funciona por dentro?

El recorrido tiene cuatro etapas. El tokenizador parte el texto en subpalabras y devuelve enteros de un vocabulario fijo. La capa de embeddings convierte cada entero en un vector de 768 dimensiones. Las capas del Transformer mezclan esos vectores con atención, y la cabeza final produce la salida de la tarea.

La tokenización no trabaja con palabras completas sino con subpalabras (WordPiece en BERT, BPE en GPT). Así el vocabulario se mantiene en decenas de miles de entradas y las palabras raras se descomponen: tokenization puede partirse en token + ##ization. Cada secuencia se envuelve con tokens especiales: [CLS] al inicio y [SEP] al final en los modelos BERT.

Un embedding es un vector aprendido. Dos palabras con usos parecidos acaban con vectores parecidos, y la similitud se mide con el coseno del ángulo entre ellos, no con la distancia euclídea. En un modelo contextual como BERT el vector no es fijo por palabra: se calcula en cada frase, después de que la atención mezcle el contexto.

La atención proyecta cada token en query (qué busco), key (qué ofrezco) y value (qué aporto). El producto entre una query y todas las keys mide compatibilidad; se divide por la raíz de la dimensión, se aplica softmax y el resultado pesa los values.

Un Transformer apila esas capas con conexiones residuales, normalización y una red densa por token. Los modelos encoder como BERT ven la frase completa en ambas direcciones y sirven para clasificar o extraer. Los decoder como GPT solo miran hacia atrás, porque su tarea es predecir el siguiente token.

Sintaxis: instalar y cargar un tokenizador

Necesitas transformers y, para tensores y modelos, torch. La primera ejecución descarga el vocabulario y los pesos desde Hugging Face, así que requiere conexión; después quedan en la caché local.

12

pip install transformers torch
pip install datasets sentence-transformers   # opcionales, para las secciones siguientes

12345678

from transformers import AutoTokenizer

tok = AutoTokenizer.from_pretrained("distilbert-base-uncased")
lote = tok("Machine learning is fun", return_tensors="pt")

print(lote["input_ids"])                          # tensor([[101, 3698, 4083, 2003, 4569, 102]])
print(tok.convert_ids_to_tokens(lote["input_ids"][0]))
print(lote["attention_mask"].shape)

AutoTokenizer elige la clase correcta a partir del nombre del modelo. La salida es un diccionario con input_ids (los enteros), attention_mask (1 donde hay token real, 0 donde hay relleno) y, si el modelo lo usa, token_type_ids. La forma es (1, 6): un lote de una secuencia de seis tokens.

Ejemplo básico: de texto a ids

Al procesar muchos textos, las secuencias tienen longitudes distintas y un tensor no admite filas de tamaños diferentes. Se recortan con truncation=True y se rellenan con padding=True hasta la longitud máxima del lote.

123456789

from transformers import AutoTokenizer

tok = AutoTokenizer.from_pretrained("distilbert-base-uncased")
frases = ["the cat sat", "machine learning is fun and useful"]

lote = tok(frases, padding=True, truncation=True, max_length=512, return_tensors="pt")
print(lote["input_ids"].shape)       # torch.Size([2, 8])
print(lote["attention_mask"])
print(tok.decode(lote["input_ids"][0], skip_special_tokens=True))

La primera frase tiene cinco tokens y la segunda ocho, así que la primera se rellena con tres ceros y su máscara termina en 0, 0, 0. Sin máscara, el modelo trataría esos ceros como contenido. decode hace el camino inverso y devuelve el texto, útil para depurar tokenizaciones raras.

Ejemplo intermedio: similitud coseno

La similitud coseno compara direcciones e ignora la longitud: cos(a, b) = (a·b) / (‖a‖·‖b‖). Vale 1 para vectores paralelos, 0 para perpendiculares y −1 para opuestos. Los vectores siguientes son de cuatro dimensiones para que puedas comprobar las cuentas; un embedding real tiene 384 o 768.

1234567891011121314

import math

def coseno(a, b):
    producto = sum(x * y for x, y in zip(a, b))
    norma_a = math.sqrt(sum(x * x for x in a))
    norma_b = math.sqrt(sum(y * y for y in b))
    return producto / (norma_a * norma_b)

rey = [0.8, 0.6, 0.0, 0.1]
reina = [0.75, 0.55, 0.2, 0.12]
manzana = [-0.2, 0.1, 0.9, -0.3]

print(round(coseno(rey, reina), 3))     # 0.978
print(round(coseno(rey, manzana), 3))   # -0.133

«Rey» y «reina» comparten dirección (0.978); «rey» y «manzana» apuntan a lados opuestos (−0.133). El coseno ya divide por las normas, así que no hace falta normalizar; el producto escalar y la distancia euclídea sí crecen con la magnitud, y por eso conviene normalizar si usas esos dos. Con sentence-transformers, normalize_embeddings=True deja los vectores listos para comparar.

12345678

from sentence_transformers import SentenceTransformer, util

modelo = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
frases = ["Un gato duerme en el sofá", "El perro descansa en el sillón"]
vectores = modelo.encode(frases, normalize_embeddings=True)

print(vectores.shape)                              # (2, 384)
print(util.cos_sim(vectores[0], vectores[1]).item())  # cercano a 1: mismo tema

Caso práctico: clasificar y ajustar un Transformer

Primero, la vía rápida: un pipeline descarga un modelo ya ajustado y hace todo el recorrido por ti. Es la forma más eficiente de comprobar si un modelo sirve antes de invertir en entrenamiento.

12345

from transformers import pipeline

clasificador = pipeline("sentiment-analysis")   # distilbert afinado en SST-2
print(clasificador("I loved every chapter of this course"))
print(clasificador("The ending was a mess"))

La salida es una lista con label y score. Ese modelo está entrenado en inglés: con texto en español las etiquetas no son fiables. Para español existen alternativas como pysentimiento/robertuito-sentiment-analysis; cambiar el modelo es cambiar un argumento, porque la interfaz es la misma.

num_labels=2 sustituye la cabeza de preentrenamiento por una de dos clases; el resto de los pesos se conserva. DataCollatorWithPadding rellena cada lote a la longitud de su secuencia más larga, y load_best_model_at_end devuelve los pesos de la mejor época.

123456789101112131415161718192021222324252627282930313233343536373839404142

import numpy as np
from datasets import load_dataset
from sklearn.metrics import accuracy_score, f1_score
from transformers import (AutoModelForSequenceClassification, AutoTokenizer,
                          DataCollatorWithPadding, Trainer, TrainingArguments)

nombre = "distilbert-base-uncased"
tok = AutoTokenizer.from_pretrained(nombre)
datos = load_dataset("imdb", split={"train": "train[:2000]", "test": "test[:500]"})
datos = datos.map(lambda l: tok(l["text"], truncation=True, max_length=256), batched=True)
datos = datos.rename_column("label", "labels")

modelo = AutoModelForSequenceClassification.from_pretrained(nombre, num_labels=2)

def metricas(eval_pred):
    logits, etiquetas = eval_pred
    pred = np.argmax(logits, axis=-1)
    return {"accuracy": accuracy_score(etiquetas, pred),
            "f1": f1_score(etiquetas, pred, average="binary")}

args = TrainingArguments(
    output_dir="./resultados",
    learning_rate=2e-5,
    per_device_train_batch_size=16,
    num_train_epochs=2,
    eval_strategy="epoch",
    save_strategy="epoch",
    load_best_model_at_end=True,
    report_to="none",
)

entrenador = Trainer(
    model=modelo,
    args=args,
    train_dataset=datos["train"],
    eval_dataset=datos["test"],
    data_collator=DataCollatorWithPadding(tok),
    compute_metrics=metricas,
    processing_class=tok,          # transformers >= 4.46
)
entrenador.train()
print(entrenador.evaluate())

Visualización: una matriz de atención

Esta matriz es una cabeza de atención de juguete sobre seis tokens, con valores redondeados. Cada fila es un token que consulta y cada columna, un token consultado; la diagonal es la atención hacia sí mismo. En un modelo real las cifras salen de softmax(Q·Kᵀ/√d_k).

Comprueba una fila con una calculadora: 0.05 + 0.45 + 0.25 + 0.10 + 0.05 + 0.10 = 1.00. Esa es la firma del softmax. En un decoder como GPT la mitad superior se enmascara con −∞ antes del softmax, de modo que un token no puede mirar al futuro; en un encoder como BERT no hay máscara y la matriz es completa.

Visualización: cómo se tokeniza una frase

El programa siguiente ejecuta el primer paso del recorrido y muestra los tres objetos que acompañan a cualquier texto: la forma del tensor, la máscara y la lista de tokens.

—

Los ids dependen del vocabulario: 1996 es the, 4937 es cat y 2938 es sat. En otro modelo cambian por completo, y por eso nunca se reutiliza un tokenizador con los pesos de otro modelo. Si vieras [UNK], la palabra no estaba en el vocabulario y el modelo pierde esa información.

Errores comunes

Preentrenamiento y ajuste

Buenas prácticas

• Usa siempre el tokenizador que corresponde al modelo; no los mezcles.
• Empieza con un pipeline o un modelo preentrenado antes de entrenar desde cero.
• Con pocos datos, congela el encoder y entrena solo la cabeza (requires_grad=False).
• Evalúa con F1 si las clases están desbalanceadas; la accuracy sola engaña.
• Fija seed y guarda la versión del modelo base: los resultados cambian entre versiones.

Ejercicios

lote = tok(frases, padding=, truncation=, max_length=512, return_tensors="pt")
print(lote["input_ids"].shape)

Soluciones explicadas

En el primer ejercicio, contar tokens y no palabras revela el coste real: la frase de seis palabras ocupa ocho ids. Ese dato decide si tu max_length pierde información; si el percentil 95 del corpus está en 300, truncar a 128 elimina la mitad del contenido.

En el segundo, normalizar antes de comparar evita que los vectores largos dominen. La similitud alta entre las dos primeras frases no depende de compartir palabras exactas —«duerme» frente a «descansa»—, sino de que el modelo las sitúa en direcciones parecidas.

Resumen

• El texto se convierte en ids mediante un tokenizador de subpalabras y un vocabulario fijo.
• [CLS] y [SEP] delimitan la secuencia; attention_mask distingue tokens reales de relleno.
• truncation y padding igualan longitudes; el límite de BERT es 512 tokens.
• Un embedding es un vector denso; la similitud se mide con coseno, que ignora la magnitud.
• La atención calcula pesos con softmax(Q·Kᵀ/√d_k) y cada fila suma 1.
• El fine-tuning parte de pesos preentrenados; el encoder (BERT) ve toda la frase y el decoder (GPT) solo el pasado.

Evaluación