Procesamiento de lenguaje natural

Un modelo no ve palabras: ve números. Todo sistema de NLP es una cadena de decisiones que transforma texto crudo en tensores. La calidad de esa cadena determina el techo del modelo mucho más de lo que suele admitirse.

El pipeline completo

Tokenización: la decisión fundamental

La tokenización por subpalabras resuelve el problema de las palabras raras: «aprendizaje» puede dividirse en aprend + izaje. Así el modelo comparte estadística entre variantes morfológicas y puede representar palabras que nunca vio, porque están compuestas por piezas conocidas.

Código: tokenizar de tres formas

import re
from collections import Counter

texto = "El aprendizaje automático no es magia; es estadística bien aplicada."

# 1) Tokenización por palabras con regex (mejor que split)
palabras = re.findall(r"\b\w+\b", texto.lower())
print(palabras)

# 2) Por caracteres
print(list(texto[:30]))

# 3) Subpalabras con un tokenizador real (requiere transformers)
from transformers import AutoTokenizer

tok = AutoTokenizer.from_pretrained("dccuchile/bert-base-spanish-wwm-cased")
ids = tok(texto)["input_ids"]
print(ids)
print(tok.convert_ids_to_tokens(ids))

# Ver el vocabulario: cuántas piezas empiezan con "##" (continuación)
vocab = tok.get_vocab()
print("tamaño del vocabulario:", len(vocab))
print("piezas de continuación:", sum(1 for k in vocab if k.startswith("##")))

Limpieza: qué quitar y qué conservar

• HTML y entidades: eliminar etiquetas, conservar el texto.
• URLs y correos: sustituir por un token especial o eliminarlos según la tarea.
• Emojis: pueden ser señal fuerte de sentimiento; no los borres por defecto.
• Stopwords: rara vez conviene eliminarlas en modelos modernos; sí puede ayudar en TF-IDF.
• Duplicados: pueden inflar la evaluación si aparecen en train y test.

Antes de los embeddings y los Transformers, el texto se representaba contando palabras. Estas representaciones ignoran el orden, pero siguen siendo baselines difíciles de superar en muchos problemas con pocos datos. Entenderlas es entender qué información captura y qué pierde un modelo de lenguaje.

Bolsa de palabras

Se construye un vocabulario con los términos del corpus y cada documento se representa como un vector de conteos. El orden y la gramática desaparecen: «el perro muerde al hombre» y «el hombre muerde al perro» producen el mismo vector.

TF-IDF

Un término frecuente en un documento pero raro en el corpus es discriminativo. TF-IDF combina ambas señales:

Implementación y baseline

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

# X_texto: lista de documentos; y: etiquetas
X_train, X_test, y_train, y_test = train_test_split(
    X_texto, y, test_size=0.2, stratify=y, random_state=42
)

modelo = make_pipeline(
    TfidfVectorizer(
        ngram_range=(1, 2),      # unigramas y bigramas
        min_df=3,                # ignora términos muy raros
        max_df=0.9,              # ignora términos casi universales
        sublinear_tf=True,       # aplica 1 + log(tf)
        strip_accents="unicode",
        lowercase=True
    ),
    LogisticRegression(max_iter=2000, class_weight="balanced")
)

modelo.fit(X_train, y_train)
y_pred = modelo.predict(X_test)
print(classification_report(y_test, y_pred))

# Términos más importantes para la clase positiva
vectorizador = modelo.named_steps["tfidfvectorizer"]
clf = modelo.named_steps["logisticregression"]
import numpy as np
vocab = np.array(vectorizador.get_feature_names_out())
pesos = clf.coef_[0]
for i in np.argsort(pesos)[-12:][::-1]:
    print(f"{vocab[i]:>20s}  {pesos[i]:+.3f}")

Qué captura y qué pierde

Un embedding representa cada palabra con un vector denso de decenas o cientos de dimensiones, aprendido de modo que palabras con contextos similares queden cerca. Es la transición entre contar palabras y modelar significado.

La hipótesis distribucional

«Conocerás una palabra por las compañías que mantiene». Word2Vec aprende vectores prediciendo el contexto: si dos palabras aparecen en contextos parecidos, sus vectores se acercan. No hay definiciones ni diccionarios; solo regularidades de uso.

Negative sampling en una frase

En lugar de normalizar sobre todo el vocabulario, se entrena un clasificador binario: pares reales (palabra, contexto) deben puntuar alto y pares falsos (palabra, contexto aleatorio) deben puntuar bajo. Con 5–20 negativos por positivo se obtienen embeddings útiles con una fracción del costo.

from gensim.models import Word2Vec
from gensim.utils import simple_preprocess

# corpus: lista de documentos (strings)
frases = [simple_preprocess(doc, deacc=False, min_len=2) for doc in corpus]

modelo = Word2Vec(
    sentences=frases,
    vector_size=100,
    window=5,
    min_count=5,
    workers=4,
    sg=1,               # skip-gram; sg=0 usa CBOW
    negative=10,
    epochs=10,
    seed=42
)

print(modelo.wv.most_similar("aprendizaje", topn=8))
print(modelo.wv.similarity("modelo", "algoritmo"))

# Guardar solo los vectores (más ligero que el modelo completo)
modelo.wv.save("vectores.kv")

# Cargar con KeyedVectors
from gensim.models import KeyedVectors
kv = KeyedVectors.load("vectores.kv")
print(kv["datos"].shape)

Limitaciones que conviene nombrar

• Un vector por palabra: «banco» tiene el mismo vector en «banco financiero» y «banco del parque». Los embeddings contextuales resuelven esto.
• Sesgos del corpus: si el corpus asocia ciertas profesiones con un género, el espacio reproduce y amplifica esa asociación.
• Vocabulario fijo: las palabras nuevas quedan fuera. Los modelos basados en subpalabras mitigan el problema.
• No son interpretables dimensión a dimensión: cada eje no tiene un significado limpio; solo las relaciones geométricas son útiles.

De palabra a documento

Para clasificar un documento con embeddings de palabras se suele promediar los vectores (ponderados por TF-IDF) o usar una RNN/Transformer. El promedio es simple y sorprendentemente competitivo en tareas de tema, pero pierde orden y composición. En tareas de sentimiento con negaciones, esa pérdida importa.

Una red recurrente procesa el texto palabra por palabra, actualizando un estado que resume lo leído. Fue la arquitectura dominante en NLP hasta 2017 y todavía es útil para secuencias cortas y modelos ligeros.

Por qué recurrencia

Una red densa sobre una bolsa de palabras no distingue «no me gustó» de «me gustó, no». La recurrencia introduce orden: el estado en el paso $t$ depende del estado en $t-1$ y del token actual.

El problema del gradiente que se desvanece

Al retropropagar a través de $T$ pasos se multiplican $T$ jacobianos. Si sus normas son menores que 1, el gradiente se vuelve exponencialmente pequeño; si son mayores, explota. LSTM y GRU introducen compuertas y una ruta de memoria que mitiga el problema.

import torch
import torch.nn as nn
from torch.utils.data import DataLoader

class ClasificadorTexto(nn.Module):
    def __init__(self, vocab_size, emb_dim=128, hidden=128, n_classes=2, pad_idx=0):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, emb_dim, padding_idx=pad_idx)
        self.lstm = nn.LSTM(
            emb_dim, hidden, batch_first=True, bidirectional=True, dropout=0.2
        )
        self.dropout = nn.Dropout(0.3)
        self.fc = nn.Linear(hidden * 2, n_classes)

    def forward(self, x, lengths):
        emb = self.embedding(x)
        packed = nn.utils.rnn.pack_padded_sequence(
            emb, lengths.cpu(), batch_first=True, enforce_sorted=False
        )
        packed_out, (h, _) = self.lstm(packed)
        # h: (2, batch, hidden) -> concatenar direcciones
        h = torch.cat([h[0], h[1]], dim=1)
        return self.fc(self.dropout(h))

modelo = ClasificadorTexto(vocab_size=30000)
criterio = nn.CrossEntropyLoss()
optimizador = torch.optim.AdamW(modelo.parameters(), lr=1e-3)

Cuándo usar una RNN hoy

• Secuencias cortas y recursos limitados (dispositivos, latencia estricta).
• Tareas de etiquetado token a token con dependencias locales (NER, POS).
• Series temporales con patrones secuenciales claros y datasets pequeños.
• Como baseline antes de probar un Transformer.

La atención permite que cada token consulte a todos los demás y construya una representación dependiente del contexto. Es la pieza que hizo posible que una misma palabra tenga vectores distintos según la frase, y la base de BERT, GPT y los LLM actuales.

La intuición antes de la fórmula

En «El banco estaba junto al río», la palabra «banco» debe mirar a «río» para resolverse como orilla. En «Fui al banco a pedir un crédito», debe mirar a «crédito». La self-attention calcula, para cada token, cuánto debe pesar cada otro token al construir su nueva representación.

Por qué reemplazó a la recurrencia

• Paralelización: todos los tokens se procesan a la vez, no secuencialmente.
• Dependencias largas: cualquier par de posiciones se conecta en un paso, sin recorrer toda la secuencia.
• Escalabilidad: permite entrenar con grandes corpus y modelos de miles de millones de parámetros.
• Costo: la atención es $O(n^2d)$; para secuencias muy largas hay variantes eficientes.

Encoder, decoder y máscaras

import torch
import torch.nn.functional as F

def atencion(Q, K, V, mask=None):
    d_k = Q.size(-1)
    scores = Q @ K.transpose(-2, -1) / d_k ** 0.5
    if mask is not None:
        scores = scores.masked_fill(mask == 0, float("-inf"))
    pesos = F.softmax(scores, dim=-1)
    return pesos @ V, pesos

# batch=2, tokens=4, dimensión=8
Q = torch.randn(2, 4, 8)
K = torch.randn(2, 4, 8)
V = torch.randn(2, 4, 8)
salida, pesos = atencion(Q, K, V)
print(salida.shape, pesos.shape)   # (2,4,8) y (2,4,4)

# Máscara causal para generación
n = 4
causal = torch.tril(torch.ones(n, n)).bool()
_, pesos_causal = atencion(Q, K, V, mask=causal)
print(pesos_causal[0].round(decimals=2))  # triangular: cada fila solo mira hasta su posición

El preentrenamiento cambió las reglas: en lugar de entrenar desde cero con tus pocos datos, partes de un modelo que ya aprendió lenguaje en un corpus enorme y lo adaptas a tu tarea. Es la práctica estándar en NLP aplicado.

Preentrenamiento y ajuste

Objetivos de preentrenamiento

• Masked Language Modeling (BERT): se enmascara un 15 % de tokens y el modelo debe predecirlos usando ambos contextos. Fuerza representaciones bidireccionales.
• Next Sentence Prediction: se predice si dos frases son consecutivas. Hoy se considera poco útil y muchos modelos lo omiten.
• Autoregresivo (GPT): predecir el siguiente token. Permite generar y escalar a modelos enormes.
• SentencePiece / BPE: tokenización por subpalabras que hace posible un vocabulario manejable y multilingüe.

Fine-tuning con Hugging Face

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

# 1) Datos: dos columnas de texto y una etiqueta entera
dataset = load_dataset("csv", data_files={"train": "train.csv", "test": "test.csv"})
etiquetas = dataset["train"].features["label"].names

# 2) Tokenizador del modelo base
modelo_base = "dccuchile/bert-base-spanish-wwm-cased"
tok = AutoTokenizer.from_pretrained(modelo_base)

def tokenizar(batch):
    return tok(batch["texto"], truncation=True, padding="max_length", max_length=128)

dataset = dataset.map(tokenizar, batched=True)

# 3) Modelo con cabeza de clasificación
modelo = AutoModelForSequenceClassification.from_pretrained(
    modelo_base, num_labels=len(etiquetas)
)

def metricas(eval_pred):
    logits, labels = eval_pred
    preds = np.argmax(logits, axis=-1)
    return {"f1_macro": f1_score(labels, preds, average="macro")}

args = TrainingArguments(
    output_dir="modelo_sentimiento",
    eval_strategy="epoch",
    save_strategy="epoch",
    learning_rate=2e-5,
    per_device_train_batch_size=16,
    num_train_epochs=3,
    weight_decay=0.01,
    load_best_model_at_end=True,
    metric_for_best_model="f1_macro",
    logging_steps=50,
    seed=42
)

trainer = Trainer(
    model=modelo,
    args=args,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
    compute_metrics=metricas
)

trainer.train()
trainer.save_model("modelo_final")
tok.save_pretrained("modelo_final")

Elegir un modelo base

En NLP, una métrica alta puede esconder un modelo que aprendió el dataset en lugar del idioma. Evaluar bien exige mirar los datos, segmentar por subgrupos y analizar errores concretos.

Métricas por tarea

Análisis de errores sistemático

1. Muestrea 100–200 errores de validación, estratificados por clase y confianza.
2. Etiqueta el tipo de error: ambigüedad, etiqueta incorrecta, falta de contexto, sesgo, truncamiento, dominio.
3. Cuantifica las categorías y prioriza las que más impactan.
4. Convierte los hallazgos en acciones: más datos, mejor esquema, cambios de preprocessing o de modelo.

import numpy as np
import pandas as pd
from sklearn.metrics import classification_report, confusion_matrix

probs = modelo.predict_proba(X_test)
preds = probs.argmax(axis=1)
confianza = probs.max(axis=1)

print(classification_report(y_test, preds, digits=3))
print(pd.DataFrame(
    confusion_matrix(y_test, preds),
    index=[f"real_{c}" for c in clases],
    columns=[f"pred_{c}" for c in clases]
))

# Errores con alta confianza: los más peligrosos
errores = pd.DataFrame({
    "texto": X_test,
    "real": y_test,
    "pred": preds,
    "confianza": confianza
})
errores = errores[errores.real != errores.pred].sort_values("confianza", ascending=False)
print(errores.head(25).to_string())

# Rendimiento por longitud del texto (posible truncamiento)
longitudes = [len(t.split()) for t in X_test]
bins = pd.qcut(longitudes, q=4, labels=["corto", "medio", "largo", "muy largo"])
print(pd.crosstab(bins, y_test == preds, normalize="index"))

Sesgos y subgrupos

Un modelo puede tener buen rendimiento global y fallar sistemáticamente en ciertos dialectos, géneros o dominios. Reporta métricas por subgrupo cuando tengas la información; si no la tienes, al menos analiza errores por fuente y por longitud. La equidad no se deduce de una métrica agregada.

Un modelo de lenguaje no «sabe»: predice texto plausible. Esa diferencia es crucial cuando se usa para decisiones que afectan personas. Este cierre no es una lista de prohibiciones, sino un marco para usar estas herramientas con responsabilidad.

Riesgos que aparecen en producción

Un protocolo mínimo de uso responsable

1. Define el propósito y el daño posible: ¿qué decisión toma una persona a partir de la salida?
2. Verifica con fuentes: en tareas factuales, exige citas o recuperación de documentos (RAG).
3. Mide por subgrupos: no aceptes una métrica agregada como prueba de equidad.
4. Documenta límites: idioma, dominio, longitud, tipo de texto y fecha de corte del modelo.
5. Mantén supervisión humana: en decisiones de alto impacto, el modelo propone y una persona decide.
6. Registra y audita: entradas, salidas, versiones y cambios. Sin trazabilidad no hay rendición de cuentas.

RAG: conectar el modelo con documentos

Una forma práctica de reducir alucinaciones es Retrieval-Augmented Generation: dado un documento o pregunta, se recuperan fragmentos relevantes de una base de conocimiento y se le pide al modelo responder solo con esa evidencia. La recuperación se evalúa por separado (recall de fragmentos) y la generación por fidelidad a las fuentes.

1. Indexar documentos: dividir en fragmentos, calcular embeddings, guardar en un índice vectorial.
2. Recuperar: embedder la pregunta y buscar los k fragmentos más similares.
3. Construir el prompt: instrucción + fragmentos + pregunta + "si no está en el contexto, di que no lo sabes".
4. Generar y citar: pedir que cada afirmación incluya el fragmento de origen.
5. Evaluar: recall@k de recuperación, fidelidad de la respuesta y tasa de abstenciones correctas.