En el Módulo 9 vimos que las capas profundas aprenden una jerarquía de rasgos por sí solas, sin que nadie se los programe. Dejamos flotando una palabra clave: representación. Este módulo la aterriza, porque es —sin exagerar— la idea más transferible de todo el deep learning y el puente directo hacia los LLM. Antes de que una red pueda aprender algo sobre una palabra, un producto o un usuario, tiene que representarlo con números. Cómo elige esos números lo cambia todo.

La tesis del módulo

La red no solo aprende a decidir: aprende a representar. Dada una categoría suelta (una palabra, un producto), la red aprende por sí sola un vector de números —un embedding— donde la cercanía significa similitud. Esa capacidad de inventar buenas representaciones es lo que conecta esta clase con los buscadores semánticos, los sistemas de recomendación y cada LLM que existe.

El problema: cómo le doy una palabra a una red

Una red neuronal solo come números. Pero muchos datos del mundo real son categorías: palabras, ciudades, productos, colores. ¿Cómo conviertes “gato”, “perro” y “avión” en números para alimentar la red?

El primer intento obvio es el one-hot (codificación “uno caliente”): tienes un vocabulario de N categorías, y cada una se representa con un vector de N posiciones, todas en 0 excepto un único 1 en la posición que le toca.

 vocabulario de 5 palabras, one-hot:

 gato   = [ 1  0  0  0  0 ]
 perro  = [ 0  1  0  0  0 ]
 león   = [ 0  0  1  0  0 ]
 avión  = [ 0  0  0  1  0 ]
 barco  = [ 0  0  0  0  1 ]  ...y así 1 solo por fila

Funciona, pero es una representación pobre por dos razones de fondo:

No dice nada de significado. En one-hot, “gato” y “perro” están exactamente a la misma distancia que “gato” y “avión”. Todos los pares son igual de distintos. La representación no captura que gato y perro se parecen y avión es otra cosa.
No escala. Con un vocabulario real de 50.000 palabras, cada una es un vector de 50.000 posiciones lleno de ceros. Enorme, disperso (sparse: casi todo ceros) y un desperdicio de memoria y cómputo.

La solución: embeddings

Un embedding (incrustación, o vector de representación) es un vector denso —de pocas dimensiones y con valores reales en todas sus posiciones— que la red aprende para cada categoría. En vez de 50.000 posiciones con un solo 1, usas, digamos, 300 números reales que capturan las propiedades de esa palabra.

 one-hot (disperso, 50.000 dims):
 gato = [0 0 0 ... 1 ... 0 0 0]   ← casi todo ceros

 embedding (denso, ej. 4 dims):
 gato  = [ 0.8   0.2  -0.1   0.9 ]
 perro = [ 0.7   0.3  -0.2   0.8 ]   ← cerca de gato
 avión = [-0.6   0.9   0.5  -0.4 ]   ← lejos de ambos

La magia está en que la cercanía es similitud: como la red aprende estos números para resolver bien su tarea, termina poniendo cerca en el espacio a las categorías que se comportan parecido. “Gato” y “perro” quedan vecinos; “avión” queda en otro barrio. Nadie programó esa cercanía — emergió del entrenamiento. Esta es exactamente la idea que sostiene los buscadores semánticos y el RAG que viste en Embeddings y RAG: cercanía de vectores = cercanía de significado.

Ojo: las dimensiones de un embedding no tienen etiquetas legibles. No hay una columna “es un animal” y otra “vuela”. Son ejes abstractos que la red usa a su manera; solo la geometría del conjunto (qué está cerca de qué) es interpretable.

Una capa oculta YA es una representación aprendida

Aquí está el salto conceptual del módulo. Un embedding no es un truco separado de lo que ya sabes: es lo que hace cualquier capa oculta de una red.

Cuando en el Módulo 3 una capa oculta tomaba una entrada y producía un vector de activaciones, ese vector es una representación aprendida de la entrada. La red comprime lo que recibe en un puñado de números útiles para las capas siguientes. Un embedding es simplemente ese mismo mecanismo aplicado desde la entrada: en lugar de recibir números crudos, le das a la red una capa cuyo trabajo es inventar el vector para cada categoría.

Por eso decimos que el deep learning aprende representation learning (aprendizaje de representaciones): antes, un humano diseñaba a mano las características de los datos (feature engineering); ahora la red las descubre sola. Las primeras capas de una CNN inventan detectores de bordes; una capa de embedding inventa vectores de palabras. Es el mismo principio.

Código: nn.Embedding en PyTorch

En PyTorch esto es una capa lista para usar: nn.Embedding. Por dentro es una tabla de vectores (uno por categoría) que se entrena como cualquier otro peso de la red.

import torch
import torch.nn as nn

# Vocabulario de 10.000 palabras, cada una representada
# por un vector denso de 128 dimensiones (el embedding).
vocab_size = 10_000
embed_dim = 128
embedding = nn.Embedding(vocab_size, embed_dim)

# La entrada son ÍNDICES enteros (el id de cada palabra),
# NO vectores one-hot. Aquí un lote de 2 frases de 4 palabras.
ids = torch.tensor([
    [5, 812, 3, 99],     # frase 1
    [5, 40, 7001, 3],    # frase 2
])

vectores = embedding(ids)
print(vectores.shape)   # torch.Size([2, 4, 128])
# Cada uno de los 8 índices se convirtió en su vector de 128 dims.
# Esos 10.000 x 128 números se AJUSTAN durante el entrenamiento
# por backpropagation, igual que cualquier otro peso.

Dos detalles que valen oro:

nn.Embedding recibe índices enteros, no one-hots. Internamente es un simple lookup (búsqueda en tabla): “dame la fila 812”. Es equivalente a multiplicar un one-hot por una matriz, pero mucho más rápido y sin gastar memoria en ceros.
La tabla arranca con valores aleatorios y se aprende. Al terminar el entrenamiento, esa tabla es el conocimiento de la red sobre cada palabra.

El puente a NLP y a los LLM

Esto no es un rincón académico: es la puerta de entrada a todo el procesamiento de lenguaje moderno. Cuando en Del texto a números veas que un Transformer empieza convirtiendo cada token en un vector, eso es exactamente un nn.Embedding. La primera capa de cualquier LLM —GPT, Llama, el que sea— es una tabla de embeddings gigantesca que traduce cada token a un vector denso antes de que la atención haga su trabajo.

Dicho de otro modo: el bloque que acabas de entender en 128 dimensiones de juguete es, escalado a miles de dimensiones y miles de millones de palabras de entrenamiento, la base literal sobre la que se para ChatGPT.

One-hot vs embedding

	One-hot	Embedding
Tamaño del vector	N (todo el vocabulario)	Pequeño y fijo (ej. 128)
Contenido	Un 1, el resto ceros (disperso)	Números reales en todas las dims (denso)
¿Captura significado?	No: todos equidistantes	Sí: cercanía = similitud
¿Se aprende?	No, es fijo por diseño	Sí, se ajusta con backprop
Escala a vocabularios grandes	Mal (vectores enormes)	Bien (dimensión fija)
Dónde vive hoy	Casos simples, targets	Toda red seria; base de los LLM

Errores comunes

Alimentar one-hots a nn.Embedding. La capa espera índices enteros, no vectores. Pasarle one-hots es el error de novato clásico.
Creer que las dimensiones significan algo legible. No hay eje “animal” ni “color”. Solo la geometría del conjunto (qué está cerca de qué) tiene sentido.
Pensar que los embeddings son solo para texto. Sirven para cualquier categoría: usuarios, productos, ciudades. Los sistemas de recomendación viven de esto.
Confundir “aprendido” con “mágico”. El embedding es tan bueno como la tarea que lo entrenó. Si entrenas con datos pobres, la geometría también será pobre.

La frase para llevarse

“El one-hot dice qué palabra es; el embedding dice a qué se parece. La red no solo aprende a responder — aprende a representar el mundo en vectores donde la distancia es significado. Esa idea es el corazón de cada LLM.”

Qué viene

Módulo 11: de redes a secuencias — RNN y por qué llegó la atención. Ya sabemos representar una palabra suelta con un embedding. Pero el lenguaje es una secuencia: el orden importa y el largo varía. Veremos cómo el deep learning abordó las secuencias antes de los Transformers —las RNN— y por qué sus límites hicieron nacer el mecanismo de atención.

Redes Neuronales — Módulo 10: embeddings y representaciones aprendidas