Introducción visual a las redes neuronales: del perceptrón a las GNN

Una red neuronal aprende una función a partir de ejemplos. Recibe números, los combina con pesos, añade sesgos, aplica transformaciones no lineales y produce una predicción. Durante el entrenamiento compara esa predicción con la respuesta correcta y modifica sus parámetros para equivocarse menos.

La frase anterior contiene casi toda la idea. Lo que cambia entre un perceptrón, una CNN, una LSTM y una GNN no es el propósito de aprender, sino la forma en que la arquitectura organiza y comparte la información.

En este recorrido construiremos la intuición en este orden:

Perceptrón: una frontera lineal.
Red multicapa (MLP): varias fronteras que forman regiones no lineales.
CNN: filtros que recorren datos con estructura espacial.
RNN: un estado que avanza por una secuencia.
LSTM: una memoria recurrente con compuertas.
GNN: mensajes que circulan entre nodos conectados.

Las animaciones reducen diez dimensiones a dos mediante PCA solo para dibujarlas. El modelo siempre se entrena con las diez características originales: el plano es un mapa, no los datos completos.

El experimento: dos conjuntos de 1,000 observaciones

Generaremos dos clases, A y B. Cada una contiene 1,000 observaciones y cada observación tiene diez características:

\mathbf{x}^{(i)}=(x_1,x_2,\ldots,x_{10})\in\mathbb{R}^{10}, \qquad y^{(i)}\in\{0,1\}.

En total tenemos una matriz $X\in\mathbb{R}^{2000\times10}$ y un vector de etiquetas $\mathbf y\in\{0,1\}^{2000}$ . Reservamos 80 % de cada clase para entrenamiento y 20 % para prueba:

entrenamiento: 1,600 observaciones;
prueba: 400 observaciones;
diez características disponibles para ambos conjuntos.

Esta separación es importante. La exactitud de entrenamiento indica cuánto aprendió el modelo de los ejemplos que vio; la exactitud de prueba estima qué tan bien responde ante observaciones nuevas.

1. El perceptrón: una neurona que decide

El perceptrón recibe las diez características, calcula una suma ponderada y aplica una función escalón:

z=\mathbf w^\top\mathbf x+b =\sum_{j=1}^{10}w_jx_j+b,

\hat y= \begin{cases} 1,&z\geq 0,\\ 0,&z<0. \end{cases}

Cada peso $w_j$ expresa cuánto influye la característica $x_j$ . El sesgo $b$ desplaza el umbral. La ecuación $\mathbf w^\top\mathbf x+b=0$ define un hiperplano: una línea en 2D, un plano en 3D y una frontera de nueve dimensiones en nuestro espacio de diez características.

Cuando el perceptrón se equivoca actualiza sus parámetros:

\mathbf w\leftarrow\mathbf w+\eta(y-\hat y)\mathbf x, \qquad b\leftarrow b+\eta(y-\hat y),

donde $\eta$ es la tasa de aprendizaje. Si acierta, $y-\hat y=0$ y no cambia nada. Si clasifica una observación del lado incorrecto, mueve la frontera en la dirección necesaria.

Los puntos sólidos pertenecen al entrenamiento y los círculos a prueba. La línea amarilla es la proyección de la frontera aprendida. Observa cómo cambian los errores y compara train con test.

Qué sucede durante la animación

Se generan 1,000 observaciones de la clase 0 y 1,000 de la clase 1.
Se mezclan y se dividen sin perder el equilibrio entre clases.
Los pesos comienzan en cero.
El perceptrón visita una observación, calcula $z$ y predice.
Si falla, actualiza los diez pesos y el sesgo.
Al terminar una época —una vuelta por los 1,600 ejemplos de entrenamiento— se mide el resultado en los 400 ejemplos reservados.

El perceptrón converge si las clases son linealmente separables. Si ninguna frontera plana puede separarlas, seguirá cometiendo errores: no es falta de paciencia, sino una limitación de la arquitectura.

2. Red multicapa: aprender fronteras no lineales

Una red multicapa o MLP apila neuronas. Una capa oculta calcula

\mathbf h=\phi(W\mathbf x+\mathbf b),

donde $W$ contiene los pesos, $\mathbf b$ los sesgos y $\phi$ es una activación no lineal. Sin $\phi$ , muchas capas lineales colapsarían en una sola transformación lineal. En el ejemplo usamos ReLU,

\operatorname{ReLU}(z)=\max(0,z),

y una salida sigmoide que convierte el último valor en una probabilidad:

P(y=1\mid\mathbf x)=\sigma(z)=\frac{1}{1+e^{-z}}.

Entrenar una MLP requiere dos recorridos. En la propagación hacia adelante calculamos la predicción. En la retropropagación usamos la regla de la cadena para saber cuánto contribuyó cada parámetro al error. Luego el descenso por gradiente actualiza cada parámetro:

\theta\leftarrow\theta-\eta\nabla_\theta\mathcal L.

Usaremos nuevamente dos conjuntos de 1,000 observaciones generados con distribuciones normales. Sus centros son distintos, pero las colas se solapan: cerca del centro habrá puntos de ambas clases. Es un caso más realista que dos grupos perfectamente separados.

La MLP recibe las diez características originales. El fondo indica su predicción y el contorno amarillo la frontera entre clases. En la zona solapada no existe una separación perfecta: algunos errores son inevitables.

La red usada aquí tiene diez entradas, dos capas ocultas de siete y cinco neuronas, y una salida. Es deliberadamente pequeña. Primero cada capa combina las diez mediciones, después la salida estima la clase y, finalmente, la retropropagación corrige los pesos. Observa que la frontera se estabiliza en la franja entre ambos grupos, en lugar de intentar acertar cada punto del área compartida.

Funciones de activación

Las activaciones deciden qué señal continúa. El escalón sirve en el perceptrón clásico, pero no ofrece un gradiente útil para retropropagación. Sigmoid produce valores entre 0 y 1; tanh entre −1 y 1; ReLU deja pasar valores positivos y anula los negativos.

La no linealidad permite que una composición de capas represente funciones que una sola transformación lineal no puede expresar.

3. CNN: filtros que buscan patrones locales

Hasta aquí trabajamos con observaciones tabulares descritas por diez características sin una posición espacial obligatoria. A partir de este apartado dejamos ese conjunto de datos para estudiar entradas organizadas como una cuadrícula 2D, por ejemplo imágenes, donde la cercanía entre valores sí contiene información.

Una red neuronal convolucional aprovecha que en una imagen los píxeles cercanos están relacionados. En vez de conectar cada entrada con cada neurona, un filtro pequeño recorre la imagen y reutiliza los mismos pesos en todas las posiciones.

Para un filtro $K$ y una imagen $X$ , una salida simplificada es

S(i,j)=\sum_m\sum_n X(i+m,j+n)K(m,n).

Esto aporta dos ideas poderosas:

conectividad local: una neurona observa una región pequeña;
pesos compartidos: el mismo detector puede encontrar un borde en cualquier parte.

Las primeras capas suelen responder a bordes o texturas; capas posteriores combinan esos patrones en formas más complejas. El pooling o una convolución con paso mayor puede reducir la resolución y ampliar el campo receptivo.

La ventana amarilla aplica el mismo kernel de 2 × 2 en 16 posiciones. A la derecha se construye, celda por celda, el mapa de características.

Aunque nuestros datos tabulares tienen diez características, una CNN solo es apropiada si esas características poseen vecindad u orden espacial significativo. Reacomodar columnas arbitrarias como si fueran píxeles inventaría una estructura que no existe.

4. RNN: un estado para las secuencias

Imagina que medimos la temperatura cada hora y queremos detectar si el día se está calentando. Leer únicamente la medición actual no basta: 24 °C puede significar que la temperatura sube desde 20 °C o que baja desde 28 °C. Necesitamos un pequeño resumen del pasado.

Una red neuronal recurrente procesa una medición a la vez. En cada paso combina dos cosas: la entrada actual $x_t$ y el resumen anterior $h_{t-1}$ . En la animación usamos una versión de una sola dimensión:

h_t=\tanh(0.70x_t+0.55h_{t-1}).

Los números 0.70 y 0.55 son pesos; durante un entrenamiento real se aprenden. Para obtener el siguiente estado:

multiplicamos la entrada actual por 0.70;
multiplicamos la memoria anterior por 0.55;
sumamos ambas contribuciones;
aplicamos $\tanh$ para mantener el resultado entre −1 y 1.

Por ejemplo, si $x_t=0.8$ y $h_{t-1}=0.14$ :

h_t=\tanh(0.70(0.8)+0.55(0.14)) =\tanh(0.637)\approx0.56.

Ese 0.56 viaja al paso siguiente. Así, cada salida depende indirectamente de entradas anteriores. Cuando las entradas y los estados contienen varios valores, los pesos se convierten en matrices, pero el procedimiento no cambia.

El círculo amarillo es el paso que se está calculando. Debajo se muestran por separado la contribución de la entrada, la del estado anterior y el nuevo valor de $h_t$.

Al entrenarla, la RNN se despliega en el tiempo y la retropropagación atraviesa todos los pasos. Este procedimiento se llama Backpropagation Through Time (BPTT), o retropropagación a través del tiempo. Repetir muchas multiplicaciones puede hacer que el gradiente se vuelva diminuto —gradiente desvanecido— o enorme —gradiente explosivo—. Por eso una RNN simple suele olvidar dependencias lejanas.

5. LSTM: memoria con compuertas

Ahora pensemos en una estación meteorológica. Durante una tormenta queremos recordar que está lloviendo aunque una lectura aislada del sensor sea débil. Cuando la tormenta termina, debemos borrar ese contexto. Una RNN simple mezcla todo en un único estado; una LSTM separa la memoria de largo plazo de la salida momentánea.

Puede entenderse como una libreta con tres controles. Cada control produce un número entre 0 y 1: cero significa “no dejes pasar nada”, uno significa “déjalo pasar todo” y un valor intermedio conserva solo una parte.

Paso 1: decidir cuánto olvidar

La compuerta de olvido mira la entrada actual y la salida anterior:

f_t=\sigma(W_f[h_{t-1},x_t]+b_f).

Después multiplica la memoria anterior: $f_tc_{t-1}$ . Si $f_t=0.90$ , conserva 90 %; si $f_t=0.10$ , casi la borra.

Paso 2: decidir qué escribir

La red propone un contenido candidato $\tilde c_t$ y calcula cuánto debe escribir mediante $i_t$ :

i_t=\sigma(W_i[h_{t-1},x_t]+b_i).

\tilde c_t=\tanh(W_c[h_{t-1},x_t]+b_c).

La cantidad nueva que entra en la libreta es $i_t\tilde c_t$ . Si el candidato dice “hay lluvia” pero $i_t$ está cerca de cero, esa observación apenas cambia la memoria.

Paso 3: actualizar la memoria

Sumamos lo conservado y lo nuevo:

c_t=\underbrace{f_tc_{t-1}}_{\text{lo que conservamos}} +\underbrace{i_t\tilde c_t}_{\text{lo que escribimos}}.

Esta suma es la idea central: la memoria no se reemplaza por completo, sino que puede circular con cambios pequeños.

Paso 4: decidir qué mostrar

La memoria interna y la salida no son lo mismo. La compuerta de salida decide qué parte se hace visible:

o_t=\sigma(W_o[h_{t-1},x_t]+b_o).

h_t=o_t\tanh(c_t).

En resumen: olvidar → escribir → actualizar → mostrar. Estas decisiones no se programan manualmente; los pesos de las compuertas también se aprenden con ejemplos.

El paso activo aparece en amarillo. Las barras muestran cuánto deja pasar cada compuerta; debajo aparece el cambio de la memoria $c_t$ y la salida visible $h_t$.

Una LSTM mitiga el olvido de largo plazo, pero no lo elimina mágicamente. También tiene más parámetros y su procesamiento secuencial es difícil de paralelizar. En muchas tareas modernas los Transformers son preferidos, aunque RNN y LSTM siguen siendo útiles cuando importan el flujo en línea, la latencia o modelos compactos.

6. GNN: aprender sobre relaciones

Supongamos que queremos estimar el tráfico en una intersección. Su propio sensor es útil, pero una avenida puede estar vacía justo antes de que llegue una fila de automóviles desde los cruces vecinos. Por eso también necesitamos conocer el tráfico alrededor.

Representamos el mapa como un grafo: cada nodo es una intersección, cada arista es una carretera directa y el valor inicial $h_v$ es la lectura del sensor del cruce $v$ .

Una capa de GNN actualiza todos los cruces mediante tres pasos.

Paso 1: localizar los vecinos

Para un nodo $v$ , $\mathcal N(v)$ es el conjunto de cruces conectados directamente. No incluimos cruces que no tengan una carretera hacia $v$ .

Paso 2: resumir sus mensajes

Calculamos, por ejemplo, el promedio de sus lecturas:

m_v=\frac{1}{|\mathcal N(v)|} \sum_{u\in\mathcal N(v)}h_u.

El promedio no depende del orden en que enumeremos las carreteras. Esta propiedad es esencial porque un grafo no tiene una “primera” arista universal.

Paso 3: combinar lo propio con el vecindario

El nodo conserva parte de su lectura y añade información vecina:

h'_v=\operatorname{ReLU}(0.6h_v+0.8m_v-0.2).

Si un cruce tiene lectura propia $h_v=0.2$ y sus vecinos promedian $m_v=0.7$ :

h'_v=\operatorname{ReLU}(0.6(0.2)+0.8(0.7)-0.2)=0.48.

Aunque su sensor marcaba poco tráfico, la nueva representación sube porque sus vecinos anticipan una posible llegada de vehículos. Los coeficientes 0.6, 0.8 y el sesgo −0.2 serían parámetros aprendidos durante el entrenamiento.

Las aristas amarillas indican por dónde llegan mensajes. Dentro de cada nodo se muestra lectura original → representación actualizada después de combinar a sus vecinos.

Con una capa, cada cruce conoce a sus vecinos directos. Con dos capas, la información ya puede venir de cruces situados a dos carreteras de distancia. Demasiadas capas pueden mezclar tanto la información que todos los nodos terminen pareciéndose; este fenómeno se llama oversmoothing.

La misma receta sirve en otros dominios: en una molécula, los nodos son átomos y las aristas son enlaces; en recomendaciones, los nodos pueden ser personas y productos; en una red social, perfiles y relaciones. Cambia el significado del mensaje, no el mecanismo de reunir vecinos y actualizar el nodo.

La misma receta, distintas suposiciones

Arquitectura	Suposición principal	Unidad que comparte parámetros	Ejemplos
Perceptrón	la frontera es lineal	una combinación de características	clasificación sencilla
MLP	las características forman un vector sin estructura especial	capas densas	datos tabulares
CNN	existe localidad espacial	filtro móvil	imágenes, mapas, espectrogramas
RNN	el orden y el pasado importan	celda recurrente	texto, audio, series de tiempo
LSTM	algunas dependencias deben conservarse más tiempo	celda con compuertas	secuencias con memoria larga
GNN	las relaciones forman un grafo	función de mensaje	moléculas, tráfico, recomendaciones

Elegir una arquitectura es introducir una suposición inductiva: le decimos al modelo qué tipo de regularidad debería buscar. Una CNN no es una MLP “más avanzada”; es una red diseñada para datos espaciales. Una GNN no sustituye a una LSTM si lo esencial es el orden temporal.

Cómo leer correctamente los resultados

Mientras exploras las animaciones, conviene vigilar cuatro cosas:

Pérdida y errores: deben disminuir, aunque no siempre de forma monótona.
Entrenamiento frente a prueba: una brecha grande sugiere sobreajuste.
Frontera de decisión: debe reflejar la estructura de los datos, no perseguir cada punto aislado.
Representación visual: PCA conserva direcciones de alta variación, pero puede ocultar separaciones que existen en las diez dimensiones.

Las redes no “entienden” una clase como lo hace una persona. Ajustan parámetros para capturar regularidades estadísticas presentes en los ejemplos y en la arquitectura. La calidad final depende de los datos, el objetivo, la evaluación y las decisiones de diseño tanto como del algoritmo de entrenamiento.

Para continuar

El perceptrón introduce pesos, sesgo y error. La MLP añade capas, activaciones y retropropagación. CNN, RNN, LSTM y GNN reorganizan esas mismas piezas para respetar la geometría del problema: espacio, tiempo, memoria o relaciones.

El siguiente paso natural es modificar una variable a la vez: aumentar el ruido, cambiar la tasa de aprendizaje, reducir los datos de entrenamiento o comparar arquitecturas sobre el mismo problema. Ahí comienza la práctica real: no solo entrenar una red, sino comprender qué supuestos hace y cuándo dejan de ser adecuados.