Objetivo del módulo

Aprender a convertir palabras en características numéricas que una red neuronal pueda procesar, desde la codificación más simple hasta los embeddings. Al terminar, el lector sabrá:

describir la codificación one-hot y la bolsa de palabras, y sus limitaciones;
explicar qué son los embeddings y las bolsas de embeddings, y por qué sustituyen a la primera capa lineal de una red;
usar nn.Embedding y nn.EmbeddingBag de PyTorch, incluido el parámetro offsets para procesar varios documentos a la vez.

Clasificar correos

Una aplicación de procesamiento del lenguaje natural (PLN) debe clasificar los correos de una empresa: trabajo, personal o publicidad no deseada. Para decidir puede fijarse en tres cosas: la presencia de ciertas palabras («factura», «oferta»), su frecuencia y el significado en contexto. Pero una red neuronal no entiende letras: solo opera con números. El primer paso de cualquier modelo de texto, desde un clasificador sencillo hasta un modelo de lenguaje grande (LLM), es convertir las palabras en vectores de características.

Fig. 1 — De la frase al vector: tokenizar, asignar un índice a cada token y convertir cada índice en un vector.

Una característica (feature) es un número que describe algún aspecto de la entrada; un vector de características es la lista de esos números. En una imagen, las características son los valores de los píxeles; en un texto hay que inventarlas, y la forma de hacerlo decide qué podrá aprender el modelo. Este módulo recorre tres respuestas, de la más simple a la que usan los modelos actuales: one-hot, bolsa de palabras y embeddings.

Corpus y vocabulario

Para verlo con un ejemplo mínimo se usan tres frases, y la tarea es identificar de qué animal habla cada una:

«I like cats» (me gustan los gatos)
«I hate dogs» (odio a los perros)
«I'm impartial to hippos» (los hipopótamos me son indiferentes)

Un conjunto de frases, documentos o secuencias se llama corpus (o conjunto de datos). Tras tokenizar, cada token distinto recibe un índice; la lista de tokens con sus índices es el vocabulario. Aquí tiene 9 tokens, porque el tokenizador separa «I'm» en «I» y «'m». El siguiente código construye el vocabulario como lo haría torchtext: primero los tokens más frecuentes y, a igualdad, en orden alfabético.

import re from collections import Counter import torch dataset = ["I like cats", "I hate dogs", "I'm impartial to hippos"] def tokenizar(texto): # separa «I'm» en «I» y «'m», como spaCy return re.findall(r"'\w+|\w+", texto) frecuencias = Counter(t for frase in dataset for t in tokenizar(frase)) orden = sorted(frecuencias, key=lambda t: (-frecuencias[t], t)) # frecuencia, luego alfabético vocab = {token: i for i, token in enumerate(orden)} print(vocab) # {'I': 0, "'m": 1, 'cats': 2, 'dogs': 3, 'hate': 4, 'hippos': 5, 'impartial': 6, 'like': 7, 'to': 8} index = [torch.tensor([vocab[t] for t in tokenizar(f)]) for f in dataset] print(index) # [tensor([0, 7, 2]), tensor([0, 4, 3]), tensor([0, 1, 6, 8, 5])]

Qué hace el código

Cada parte tiene una función concreta:

tokenizar usa una expresión regular: '\w+ captura fragmentos como «'m» y \w+ captura palabras. Así «I'm» se divide en «I» y «'m».
Counter cuenta cuántas veces aparece cada token en todo el corpus.
sorted(..., key=lambda t: (-frecuencias[t], t)) ordena primero por frecuencia descendente (de ahí el signo menos) y, en caso de empate, alfabéticamente.
enumerate asigna a cada token su posición en esa lista: ese número es su índice, y el diccionario vocab guarda la correspondencia.
La última línea convierte cada frase en un tensor de índices: el formato que esperan las capas de PyTorch.

En PyTorch los índices empiezan en 0. «I» aparece tres veces y recibe el índice 0; el resto aparece una vez y se ordena alfabéticamente (el apóstrofo va antes que las letras). Por eso «I like cats» se convierte en [0, 7, 2].

Codificación one-hot

La codificación one-hot convierte datos categóricos, como los tokens, en vectores que una red puede procesar. Cada vector tiene tantas posiciones como palabras hay en el vocabulario; todas valen 0 excepto la que corresponde al índice del token, que vale 1.

Fig. 2 — Codificación one-hot: cada token es un vector con tantas posiciones como palabras tiene el vocabulario y un único 1.

x_{like} = (0, 0, 0, 0, 0, 0, 0, 1, 0) \in {0, 1}^{∣ V ∣}, ∣ V ∣ = 9

Así, cada token de un documento se representa con su propio vector, el que la red recibe como característica x de esa palabra. Una forma de verlo: el vector one-hot es una fila de interruptores, uno por palabra del vocabulario, en la que solo se enciende el de la palabra actual. No dice nada sobre la palabra salvo cuál es.

Límites del one-hot

Tamaño: con un vocabulario real de decenas de miles de palabras, cada vector tiene decenas de miles de posiciones, casi todas cero (son vectores dispersos).
Sin noción de parecido: el producto escalar de dos vectores one-hot distintos siempre es 0, de modo que «cats» está tan lejos de «dogs» como de «hate».

Fig. 3 — Los vectores one-hot no expresan parecidos; los embeddings aprendidos colocan cerca las palabras con usos similares (ilustración en 2 dimensiones).

Mini-quiz · Codificación one-hot

1. Con un vocabulario de 9 tokens, ¿cuántas posiciones tiene el vector one-hot de «like»?

2. Si «like» tiene el índice 7, ¿dónde está el 1 de su vector one-hot?

3. ¿Por qué los vectores one-hot no capturan que «cats» y «dogs» se parecen?

Ejercicio 1.1 · Codificar a mano

Con el vocabulario del ejemplo (I 0, 'm 1, cats 2, dogs 3, hate 4, hippos 5, impartial 6, like 7, to 8), escribe los vectores one-hot de «I hate dogs».

Solución

I → (1, 0, 0, 0, 0, 0, 0, 0, 0); hate → (0, 0, 0, 0, 1, 0, 0, 0, 0); dogs → (0, 0, 0, 1, 0, 0, 0, 0, 0). Cada vector tiene un único 1, en la posición del índice del token.

Ejercicio 1.2 · El coste del one-hot

Un corpus de correos tiene un vocabulario de 20 000 palabras. ¿Cuántos valores ocupa en one-hot un correo de 100 palabras y cuántos de ellos son unos?

Solución

20000 \times 100 = 2000000 valores, de los que solo 100 son unos (0, 005 %)

Casi toda la memoria se gasta en ceros. Por eso en la práctica no se construyen estos vectores, sino que se trabaja directamente con los índices.

Bolsa de palabras

Con un vector por token, ¿cómo se representa un documento entero? La bolsa de palabras (bag of words) lo representa como la suma (o la media) de los vectores one-hot de sus palabras. Para «I like cats» se suman los vectores de «I», «like» y «cats»: el resultado tiene un 1 en las posiciones 0, 7 y 2.

Fig. 4 — Bolsa de palabras: el documento se representa como la suma (o la media) de los vectores one-hot de sus palabras.

x_{doc} = t \in doc \sum x_{t} o bien x ˉ_{doc} = \frac{1}{n} t \in doc \sum x_{t}

Con la suma, cada posición cuenta cuántas veces aparece esa palabra; con la media, el vector no depende de la longitud del documento. En ambos casos se pierde el orden: «el perro muerde al hombre» y «el hombre muerde al perro» producen la misma bolsa.

# continúa el código anterior (vocab, index) import torch.nn.functional as F uno = F.one_hot(index[0], num_classes=len(vocab)) # «I like cats»: una fila por palabra print(uno) # tensor([[1, 0, 0, 0, 0, 0, 0, 0, 0], # [0, 0, 0, 0, 0, 0, 0, 1, 0], # [0, 0, 1, 0, 0, 0, 0, 0, 0]]) bolsa = uno.sum(dim=0) # bolsa de palabras print(bolsa) # tensor([1, 0, 1, 0, 0, 0, 0, 1, 0])

Qué hace el código

F.one_hot(indices, num_classes) convierte cada índice en un vector one-hot de num_classes posiciones; con tres índices devuelve una matriz de 3 × 9, una fila por palabra. sum(dim=0) suma esas filas (recorre la dimensión 0, la de las palabras) y deja un único vector de 9 posiciones: la bolsa de palabras. Para la media bastaría con uno.float().mean(dim=0).

La bolsa en una red

El vector de la bolsa de palabras puede ser la entrada de una red neuronal: la primera capa lineal lo transforma, las siguientes calculan una puntuación por clase y se elige la de mayor valor. Para «I like cats», la salida más alta corresponde a «gatos».

Fíjate en la primera capa: recibe 9 números, casi todos ceros. Los ceros no aportan nada a la multiplicación, así que todo el trabajo lo hacen las pocas posiciones encendidas. Esta observación es la que lleva a los embeddings.

Fig. 5 — Una red neuronal recibe el vector de la bolsa de palabras y asigna la frase a la clase con la puntuación más alta.

Mini-quiz · Bolsa de palabras

1. ¿Cómo se obtiene la bolsa de palabras de un documento?

2. ¿Qué información pierde la bolsa de palabras?

3. ¿Qué ventaja tiene usar la media en lugar de la suma?

Ejercicio 2.1 · Contar con la bolsa

Con el mismo vocabulario, calcula la bolsa de palabras (suma) de «I like I like cats». ¿Qué frase distinta tendría exactamente la misma bolsa?

Solución

(2, 0, 1, 0, 0, 0, 0, 2, 0): «I» y «like» aparecen dos veces y «cats» una. Cualquier reordenación, por ejemplo «cats like I like I», da el mismo vector, porque la bolsa solo cuenta.

Ejercicio 2.2 · Suma frente a media

Calcula la bolsa de palabras de «I like cats» usando la media en lugar de la suma.

Solución

Se divide la suma entre 3 palabras: (1/3, 0, 1/3, 0, 0, 0, 0, 1/3, 0) ≈ (0,33; 0; 0,33; 0; 0; 0; 0; 0,33; 0). Las posiciones activas son las mismas; solo cambia la escala.

De one-hot a embedding

Al introducir en la primera capa lineal el vector one-hot de «cats», que solo tiene un 1 en la posición 2, todos los pesos se multiplican por 0 excepto los de esa posición. La salida es, simplemente, la fila de pesos de «cats». Construir el vector one-hot y multiplicar es un rodeo: basta con el índice para leer esa fila.

Fig. 6 — Una capa de embedding equivale a multiplicar el vector one-hot por la matriz de pesos: el resultado es la fila de esa palabra.

x_{i}^{⊤} W = W_{i, :} W \in R^{∣ V ∣ \times d}

La capa que recibe el índice y devuelve esa fila se llama capa de embedding, y su salida es el vector de embedding (o simplemente embedding) de la palabra. En la práctica funciona como una tabla de consulta: el índice es el número de fila y la capa devuelve lo que hay escrito en ella. La diferencia con un diccionario normal es que el contenido de la tabla no se escribe a mano, sino que se aprende: durante el entrenamiento, la retropropagación ajusta las filas de las palabras que aparecen en cada lote.

La matriz de embeddings

Los pesos de la capa forman la matriz de embeddings: tiene una fila por palabra del vocabulario y tantas columnas como la dimensión del embedding, d. Sus valores se aprenden durante el entrenamiento, como cualquier otro peso de la red.

Baja dimensión: unos cientos de valores frente a decenas de miles del one-hot, lo que reduce el cálculo.
Densos: todos los valores aportan información.
Similitud aprendida: las palabras que se usan de forma parecida acaban con vectores cercanos.

Fig. 7 — Un embedding es mucho más pequeño que un vector one-hot y todos sus valores aportan información.

nn.Embedding en PyTorch

nn.Embedding(n_embedding, embedding_dim) crea la capa a partir del número de tokens del vocabulario y la dimensión deseada. Recibe un tensor de índices y devuelve un vector por índice: para «I like cats», una matriz de 3 filas.

# continúa el código anterior import torch.nn as nn torch.manual_seed(0) embedding_dim = 3 # tamaño de cada vector n_embedding = len(vocab) # 9 palabras distintas embeds = nn.Embedding(n_embedding, embedding_dim) print(embeds) # Embedding(9, 3) i_like_cats = embeds(index[0]) # una fila por palabra print(i_like_cats.shape) # torch.Size([3, 3]) impartial_to_hippos = embeds(index[-1]) # último documento print(impartial_to_hippos.shape) # torch.Size([5, 3]) # Comprobación: one-hot × matriz de pesos = fila de la palabra uno_cats = F.one_hot(torch.tensor(vocab["cats"]), n_embedding).float() print(torch.allclose(uno_cats @ embeds.weight, embeds.weight[2])) # True

Qué hace el código

Línea a línea:

torch.manual_seed(0) fija la semilla aleatoria para que los resultados se puedan repetir.
nn.Embedding(9, 3) crea una matriz de pesos de 9 × 3 con valores aleatorios, accesible en embeds.weight.
embeds(index[0]) recibe los índices [0, 7, 2] y devuelve las filas 0, 7 y 2: una matriz de 3 × 3. Con el último documento, de 5 tokens, devuelve 5 × 3.
Las dos últimas líneas comprueban la idea central: el one-hot de «cats» multiplicado por la matriz (@ es el producto matricial) coincide con la fila 2 (allclose compara con tolerancia numérica).

Los valores concretos de los embeddings son aleatorios hasta que se entrena la red: por eso no se muestran aquí. Lo importante son las formas y la equivalencia.

Mini-quiz · Embeddings

1. ¿Qué devuelve una capa de embedding cuando recibe el índice 7?

2. ¿Qué forma tiene la matriz de nn.Embedding(9, 3)?

3. ¿Qué ventaja tienen los embeddings frente a los vectores one-hot?

Ejercicio 3.1 · Contar parámetros

Un modelo usa un vocabulario de 50 000 palabras y embeddings de dimensión 300. ¿Cuántos parámetros tiene la capa de embedding? ¿Cuántos valores ocuparía la matriz que forman los 50 000 vectores one-hot?

Solución

50000 \times 300 = 15000000 par a ˊ metros 50000 \times 50000 = 2, 5 \times 1 0^{9}

La capa de embedding necesita 15 millones de parámetros; los vectores one-hot de todo el vocabulario formarían una matriz de 2500 millones de valores casi todos nulos.

Ejercicio 3.2 · Leer la matriz

Con la matriz de la ilustración (I = (0,1; 0,2; 0,3), hate = (0,4; 0,5; 0,6), dogs = (0,5; 0,6; 0,7)), ¿qué devuelve la capa de embedding para «I hate dogs»?

Solución

Una matriz de 3 × 3 con una fila por palabra: [[0,1; 0,2; 0,3], [0,4; 0,5; 0,6], [0,5; 0,6; 0,7]]. La capa no combina las filas: devuelve un vector por token.

Bolsa de embeddings

Si a la primera capa lineal se le da la bolsa de palabras en lugar de un solo one-hot, la salida es la suma de los embeddings de las palabras del documento. Una vez más, no hace falta construir la bolsa: basta con los índices.

x_{doc}^{⊤} W = t \in doc \sum W_{t, :} = W_{I} + W_{like} + W_{cats}

Esto es lo que hace una bolsa de embeddings (embedding bag): recibe los índices de los tokens de un documento y devuelve un único vector que combina sus embeddings. Como no guarda los vectores intermedios, es más rápida y ahorra memoria que aplicar nn.Embedding y sumar después.

Fig. 8 — Embedding devuelve un vector por token; EmbeddingBag los combina en un único vector por documento.

nn.EmbeddingBag

Se crea igual que nn.Embedding, y el parámetro mode decide cómo se combinan los vectores: "mean" (media, el valor por defecto), "sum" (suma) o "max" (máximo por componente). Además del tensor de índices recibe offsets, la posición donde empieza cada documento; con un solo documento siempre es [0].

# continúa el código anterior bolsa_emb = nn.EmbeddingBag(n_embedding, embedding_dim, mode="sum") bolsa_emb.weight = embeds.weight # comparte la matriz para poder comparar suma = bolsa_emb(index[0], offsets=torch.tensor([0])) # un solo documento print(suma.shape) # torch.Size([1, 3]) print(torch.allclose(suma[0], embeds(index[0]).sum(dim=0))) # True: suma de filas print(torch.allclose(bolsa.float() @ embeds.weight, suma[0])) # True: bolsa × matriz

Qué hace el código

Línea a línea:

mode="sum" hace que la bolsa sume los embeddings en lugar de promediarlos.
bolsa_emb.weight = embeds.weight hace que ambas capas compartan la misma matriz; así se pueden comparar sus resultados. En un modelo real cada capa tiene sus propios pesos.
offsets=torch.tensor([0]) indica que hay un único documento que empieza en la posición 0. La salida tiene forma (1, 3): un vector para todo el documento.
Las comprobaciones confirman las dos lecturas equivalentes: la bolsa de embeddings es la suma de las filas de nn.Embedding y también la bolsa de palabras multiplicada por la matriz.

Error común

Suponer que nn.EmbeddingBag suma los embeddings. Por defecto calcula la media; para obtener la suma, que es lo que equivale a multiplicar la bolsa de palabras por la matriz, hay que indicar mode="sum". Las dos opciones son válidas, pero no dan los mismos números.

Mini-quiz · Bolsa de embeddings

1. Al pasar a una capa lineal el vector de la bolsa de palabras, ¿qué se obtiene?

2. ¿Qué modo usa nn.EmbeddingBag si no se indica nada?

3. ¿Qué forma tiene la salida de EmbeddingBag para un documento de 5 tokens con dimensión 3?

Ejercicio 4.1 · Suma y media a mano

Con la matriz de la ilustración, calcula lo que devuelve una bolsa de embeddings para «I hate dogs» con mode="sum" y con mode="mean".

Solución

suma media = (0, 1 + 0, 4 + 0, 5; 0, 2 + 0, 5 + 0, 6; 0, 3 + 0, 6 + 0, 7) = (1, 0; 1, 3; 1, 6) = (1, 0; 1, 3; 1, 6) /3 \approx (0, 33; 0, 43; 0, 53)

La media es la suma dividida entre el número de tokens del documento.

Ejercicio 4.2 · Elegir la capa

Para cada caso, ¿conviene nn.Embedding o nn.EmbeddingBag? (a) Clasificar reseñas por sentimiento con un modelo sencillo. (b) Una red recurrente que procesa la frase palabra a palabra.

Solución

(a) EmbeddingBag: el clasificador solo necesita un vector por reseña y la bolsa es más eficiente. (b) Embedding: la red recurrente necesita un vector por palabra y en orden, justo lo que la bolsa descarta.

Varios documentos: offsets

En PLN es habitual juntar todos los documentos de un lote en un único tensor de una dimensión, sin relleno. Para que la bolsa sepa dónde termina cada documento, se le pasan los offsets: la posición inicial de cada uno.

Fig. 9 — Los offsets indican la posición inicial de cada documento dentro del tensor plano.

Concatenar los tensores de índices con torch.cat: se obtiene index_flat.
Contar los tokens de cada documento: [3, 3, 5].
Calcular la suma acumulada de las longitudes, empezando en 0, con torch.cumsum, y quitar el último valor: [0, 3, 6].

offset_{k} = j < k \sum n_{j} (n_{j} = n u ˊ mero de tokens del documento j)

# continúa el código anterior index_flat = torch.cat(index) # todos los documentos seguidos print(index_flat) # tensor([0, 7, 2, 0, 4, 3, 0, 1, 6, 8, 5]) longitudes = [len(muestra) for muestra in index] # [3, 3, 5] offset = torch.cumsum(torch.tensor([0] + longitudes), dim=0)[:-1] print(offset) # tensor([0, 3, 6]) media = nn.EmbeddingBag(n_embedding, embedding_dim) # mode="mean" por defecto media.weight = embeds.weight my_embeddings = media(index_flat, offsets=offset) print(my_embeddings.shape) # torch.Size([3, 3]): un vector por documento

Qué hace el código

Línea a línea:

torch.cat(index) pega los tres tensores de índices en uno solo de 11 posiciones.
[0] + longitudes antepone un 0 a la lista [3, 3, 5]; torch.cumsum calcula la suma acumulada [0, 3, 6, 11]; [:-1] quita el último valor, que no es el inicio de ningún documento.
nn.EmbeddingBag sin mode usa la media. La salida tiene forma (3, 3): una fila por documento.

Comparado con rellenar las frases hasta igualarlas, los offsets no gastan memoria en tokens de relleno. Es como guardar varias canciones seguidas en una cinta y apuntar en qué segundo empieza cada una.

Error común

Construir los offsets con la suma acumulada sin quitar el último valor, o sin empezar en 0. Si el primer offset no es 0, PyTorch da un error; si falta un offset, no hay error, pero dos documentos se mezclan en la misma bolsa y el modelo aprende de datos equivocados.

Mini-quiz · Offsets

1. ¿Qué indica cada valor de offsets?

2. Si los documentos tienen 3, 3 y 5 tokens, ¿cuáles son los offsets?

3. ¿Qué hace torch.cat(index)?

Ejercicio 5.1 · Calcular offsets

Un lote tiene cuatro documentos de 2, 5, 1 y 4 tokens. Calcula los offsets y la longitud de index_flat.

Solución

Suma acumulada empezando en 0: [0, 2, 7, 8, 12]; sin el último valor, los offsets son [0, 2, 7, 8]. index_flat tiene 12 posiciones.

import torch longitudes = torch.tensor([2, 5, 1, 4]) offsets = torch.cumsum(torch.cat([torch.tensor([0]), longitudes]), dim=0)[:-1] print(offsets) # tensor([0, 2, 7, 8]) print(longitudes.sum()) # tensor(12): longitud de index_flat

Ejercicio 5.2 · Encontrar el fallo

Con los tres documentos del ejemplo, alguien pasa offsets=torch.tensor([0, 3]). El código no da error y devuelve dos vectores. ¿Qué ha pasado?

Solución

Falta el offset 6. La primera bolsa toma las posiciones 0–2 («I like cats») y la segunda, de la 3 a la 10, mezcla «I hate dogs» con «I'm impartial to hippos». La salida tiene forma (2, 3) en lugar de (3, 3). Comprobar que haya un offset por documento evita el problema.

Proyecto: clasificar correos

Este apartado reúne todo lo aprendido en un programa completo que se puede ejecutar de principio a fin: un clasificador que asigna cada correo a trabajo, personal o spam (publicidad no deseada). Usa un corpus pequeño escrito para el ejemplo; con datos reales el código es el mismo y solo cambia la lista de correos.

Fig. 10 — Un clasificador de texto mínimo: los índices de cada correo pasan por EmbeddingBag y una capa lineal.

El programa sigue los pasos del módulo en orden: tokenizar, construir el vocabulario, convertir en índices, agrupar en lotes con offsets, combinar los embeddings con una bolsa y clasificar con una capa lineal. Solo necesita PyTorch (pip install torch).

# ===== 1. Datos: correos etiquetados ===== import re from collections import Counter import torch import torch.nn as nn from torch.utils.data import DataLoader torch.manual_seed(42) CLASES = ["trabajo", "personal", "spam"] entrenamiento = [ ("adjunto el informe trimestral para la reunión del lunes", 0), ("la reunión con el cliente se mueve al jueves", 0), ("revisa el presupuesto del proyecto antes del viernes", 0), ("necesito tu informe de ventas para la presentación", 0), ("el cliente aprobó el presupuesto del proyecto", 0), ("convocatoria de reunión del equipo de proyecto", 0), ("envía la factura del proveedor a contabilidad", 0), ("la presentación para el cliente está lista", 0), ("cena el sábado en casa de mamá", 1), ("feliz cumpleaños te queremos mucho", 1), ("vamos al cine el domingo con los niños", 1), ("las fotos de las vacaciones en la playa", 1), ("mamá pregunta si vienes a comer el domingo", 1), ("te llamo esta noche para hablar de las vacaciones", 1), ("los niños quieren ir a la playa el sábado", 1), ("gracias por la cena fue un cumpleaños precioso", 1), ("has ganado un premio gratis haz clic aquí", 2), ("oferta exclusiva descuento del 90 por ciento solo hoy", 2), ("gana dinero rápido desde casa sin esfuerzo", 2), ("tu cuenta será bloqueada haz clic para verificar", 2), ("premio garantizado reclama tu regalo gratis", 2), ("descuento increíble compra ahora oferta limitada", 2), ("felicidades eres el ganador de un premio", 2), ("dinero fácil oferta gratis solo hoy", 2), ] prueba = [ ("el informe del cliente para la reunión", 0), ("presupuesto de la presentación del viernes", 0), ("comemos el domingo en casa de mamá", 1), ("fotos del cumpleaños de los niños", 1), ("haz clic y gana un regalo gratis", 2), ("oferta de dinero rápido solo hoy", 2), ] # ===== 2. Tokenizar y construir el vocabulario ===== def tokenizar(texto): return re.findall(r"\w+", texto.lower()) frecuencias = Counter(t for texto, _ in entrenamiento for t in tokenizar(texto)) itos = ["<unk>"] + sorted(frecuencias, key=lambda t: (-frecuencias[t], t)) stoi = {t: i for i, t in enumerate(itos)} def a_indices(texto): return [stoi.get(t, stoi["<unk>"]) for t in tokenizar(texto)] # ===== 3. Lotes con índices planos y offsets ===== def collate_fn(lote): etiquetas, indices, offsets = [], [], [0] for texto, etiqueta in lote: ids = torch.tensor(a_indices(texto), dtype=torch.long) etiquetas.append(etiqueta) indices.append(ids) offsets.append(ids.size(0)) offsets = torch.tensor(offsets[:-1]).cumsum(dim=0) return torch.tensor(etiquetas), torch.cat(indices), offsets cargador = DataLoader(entrenamiento, batch_size=4, shuffle=True, collate_fn=collate_fn) # ===== 4. Modelo: EmbeddingBag + capa lineal ===== class ClasificadorCorreos(nn.Module): def __init__(self, n_vocab, dim, n_clases): super().__init__() self.embedding = nn.EmbeddingBag(n_vocab, dim, mode="mean") self.salida = nn.Linear(dim, n_clases) def forward(self, indices, offsets): return self.salida(self.embedding(indices, offsets)) modelo = ClasificadorCorreos(len(itos), dim=16, n_clases=len(CLASES)) criterio = nn.CrossEntropyLoss() optimizador = torch.optim.Adam(modelo.parameters(), lr=0.01) # ===== 5. Entrenamiento ===== for epoca in range(1, 31): total = 0.0 for etiquetas, indices, offsets in cargador: optimizador.zero_grad() perdida = criterio(modelo(indices, offsets), etiquetas) perdida.backward() optimizador.step() total += perdida.item() if epoca % 10 == 0: print(f"época {epoca}: pérdida media {total / len(cargador):.3f}") # ===== 6. Evaluación ===== modelo.eval() with torch.no_grad(): etiquetas, indices, offsets = collate_fn(prueba) predicciones = modelo(indices, offsets).argmax(dim=1) aciertos = (predicciones == etiquetas).sum().item() print(f"exactitud en prueba: {aciertos}/{len(prueba)}") # ===== 7. Clasificar correos nuevos ===== def clasificar(texto): with torch.no_grad(): ids = torch.tensor(a_indices(texto), dtype=torch.long) probs = modelo(ids, torch.tensor([0])).softmax(dim=1)[0] return CLASES[probs.argmax().item()], round(probs.max().item(), 2) print(clasificar("reclama tu premio gratis ahora")) print(clasificar("mañana enviamos el informe al cliente")) print(clasificar("las vacaciones con los niños en la playa")) # ===== 8. Qué han aprendido los embeddings ===== def parecidas(palabra, k=3): W = modelo.embedding.weight.detach() sim = torch.cosine_similarity(W[stoi[palabra]].unsqueeze(0), W) sim[stoi[palabra]] = -1 # excluir la propia palabra return [itos[i] for i in sim.topk(k).indices.tolist()] print("gratis →", parecidas("gratis")) print("reunión →", parecidas("reunión"))

Cómo funciona el proyecto

Datos. Cada correo es una pareja (texto, etiqueta), con la etiqueta como índice de CLASES. Hay 24 correos de entrenamiento y 6 de prueba que el modelo no ve al entrenar.
Vocabulario. Se construye solo con los datos de entrenamiento, para no «filtrar» información de la prueba. El token <unk> ocupa el índice 0, y a_indices envía a él cualquier palabra desconocida (stoi.get(t, 0)), en lugar de dar un error.
Lotes. collate_fn recibe 4 correos, convierte cada uno en índices, los concatena en un único tensor y calcula los offsets con la suma acumulada, exactamente como en el apartado de offsets. Devuelve etiquetas, índices y offsets.
Modelo. EmbeddingBag (media, dimensión 16) produce un vector por correo y nn.Linear lo convierte en 3 puntuaciones, una por clase.
Entrenamiento. En cada lote: se ponen a cero los gradientes (zero_grad), se calcula la pérdida de entropía cruzada entre puntuaciones y etiquetas, se retropropaga (backward) y el optimizador Adam actualiza los pesos, incluidos los embeddings. Una época es una pasada completa por los datos.
Evaluación. modelo.eval() y torch.no_grad() desactivan el cálculo de gradientes; argmax elige la clase con mayor puntuación y se cuentan los aciertos.
Uso. clasificar procesa un correo nuevo con un único offset, [0], y softmax convierte las puntuaciones en probabilidades.
Inspección. parecidas compara el embedding de una palabra con todos los demás mediante la similitud del coseno y devuelve los más cercanos.

Resultados

Esta es la salida del programa:

época 10: pérdida media 0.301 época 20: pérdida media 0.039 época 30: pérdida media 0.014 exactitud en prueba: 6/6 ('spam', 1.0) ('trabajo', 0.61) ('personal', 0.99) gratis → ['esfuerzo', 'felicidades', 'tu'] reunión → ['necesito', 'ventas', 'jueves']

La pérdida baja de una época a otra: el modelo aprende. Acierta los 6 correos de prueba.
«mañana enviamos el informe al cliente» se clasifica como trabajo con menos seguridad (0,61): «mañana» y «enviamos» no estaban en el vocabulario y pasan a <unk>, así que la decisión depende solo de «informe», «cliente» y las palabras comunes.
Los vecinos de «gratis» son palabras de los correos de spam y los de «reunión», palabras de trabajo: los embeddings se han organizado según la tarea. Aparecen también palabras poco informativas, como «tu», porque 24 correos son muy pocos para aprender buenos embeddings.

Con un corpus tan pequeño, acertar 6 de 6 no garantiza que el modelo funcione con correos reales: sirve para comprobar que todas las piezas encajan. Para un uso real se necesitan miles de ejemplos y una evaluación más amplia.

Recomendaciones

Trabaja con índices, no con one-hot. Construir vectores one-hot solo tiene sentido para explicar el concepto; nn.Embedding y nn.EmbeddingBag consiguen lo mismo sin gastar memoria en ceros.
Elige la capa según la tarea. EmbeddingBag para clasificar documentos cuando el orden importa poco; Embedding cuando el modelo necesita un vector por palabra y en orden (redes recurrentes, transformers).
Prevé las palabras desconocidas. Reserva un índice para <unk> y construye el vocabulario solo con los datos de entrenamiento. Si el relleno es inevitable, usa padding_idx para que su embedding no se entrene.
Escoge bien la dimensión. Entre 50 y 300 es lo habitual en clasificadores; una dimensión mayor necesita más datos para no sobreajustar.
Aprovecha embeddings preentrenados. Con pocos datos, cargar vectores aprendidos en grandes corpus (por ejemplo GloVe o fastText) con nn.Embedding.from_pretrained suele mejorar mucho los resultados.
Revisa offsets y modo. Comprueba que haya un offset por documento y que el primero sea 0, y decide de forma explícita entre mode="mean" y mode="sum".
Guarda el vocabulario con el modelo. Los pesos solo tienen sentido con la misma correspondencia palabra → índice; si cambia el vocabulario, hay que reentrenar.
Fija la semilla y separa los datos. torch.manual_seed hace los experimentos repetibles, y medir siempre en datos que el modelo no ha visto evita conclusiones engañosas.
Cuando el orden importe, da el siguiente paso. La bolsa de embeddings no distingue «no es spam» de «es spam, no»; para eso se necesitan modelos que procesen la secuencia, como las redes recurrentes o los transformers.

Términos clave

Término	Significado
Corpus	Conjunto de frases, documentos o secuencias con el que se trabaja.
Vocabulario	Lista de tokens distintos, cada uno con un índice entero.
Codificación one-hot	Vector del tamaño del vocabulario con un 1 en la posición del token y 0 en el resto.
Bolsa de palabras	Representación de un documento como suma o media de los one-hot de sus palabras; pierde el orden.
Embedding	Vector denso y de baja dimensión que representa una palabra; se aprende al entrenar.
Matriz de embeddings	Pesos de la capa de embedding: una fila por palabra y una columna por dimensión.
Bolsa de embeddings	Capa que combina (media, suma o máximo) los embeddings de un documento en un solo vector.
Offsets	Posiciones de inicio de cada documento dentro del tensor plano de índices.
Época	Una pasada completa por todos los datos de entrenamiento.
Similitud del coseno	Medida de cuánto apuntan dos vectores en la misma dirección; se usa para comparar embeddings.
Suma acumulada	Secuencia de sumas parciales (`torch.cumsum`); con las longitudes, da los offsets.

Síntesis del módulo

Las redes necesitan números: cada token se identifica por su índice en el vocabulario.
La codificación one-hot convierte cada token en un vector con un único 1; es simple, pero enorme y sin noción de parecido.
La bolsa de palabras representa un documento como suma o media de one-hot; cuenta palabras y pierde el orden.
Un one-hot por la primera capa lineal selecciona una fila: esa fila es el embedding, y nn.Embedding la obtiene directamente a partir del índice.
La bolsa de palabras por la matriz es la suma de embeddings: nn.EmbeddingBag la calcula (media por defecto) y, con offsets, procesa varios documentos en un solo tensor.
Un clasificador completo une todas las piezas: vocabulario con <unk>, lotes con offsets, EmbeddingBag y una capa lineal que se entrenan juntas.

Autoevaluación

1. ¿Por qué hay que convertir las palabras en vectores antes de usar una red neuronal?

2. Con un vocabulario de 30 000 palabras, ¿cuántos unos tiene el vector one-hot de una palabra?

3. «El gato persigue al ratón» y «el ratón persigue al gato», ¿tienen la misma bolsa de palabras?

4. ¿Qué operación sustituye la capa de embedding?

5. ¿Cuántos parámetros tiene nn.Embedding(10000, 64)?

6. ¿De dónde salen los valores de un embedding?

7. Para «I like cats», ¿qué devuelven nn.Embedding y nn.EmbeddingBag con dimensión 3?

8. ¿Cómo se obtiene la suma de embeddings con nn.EmbeddingBag?

9. Documentos de 4, 2 y 6 tokens: ¿cuáles son los offsets?

10. ¿Qué ventaja tienen los offsets frente a rellenar los documentos hasta la misma longitud?