Capas y activaciones

Una capa, en una fórmula

Una capa con $m$ neuronas y $n$ entradas guarda una matriz de pesos $W\in\mathbb{R}^{m\times n}$ (una fila por neurona) y un vector de sesgos $\mathbf{b}\in\mathbb{R}^m$. Dada la entrada $\mathbf{x}$, calcula

donde $\phi$ es la activación, aplicada a cada componente. Un pase hacia delante encadena esta fórmula capa por capa. Una red densa con tamaños $n_0, n_1,\dots,n_L$ tiene $\sum_{l=1}^{L}(n_{l-1}+1)\,n_l$ parámetros: por ejemplo, la red 2-8-8-8-1 del patio de juegos tiene $3\cdot 8 + 9\cdot 8 + 9\cdot 8 + 9\cdot 1 = 177$.

El colapso lineal

Si $\phi$ es la identidad, dos capas dan

que es una sola capa con pesos $W_2W_1$ y sesgo $W_2\mathbf{b}_1+\mathbf{b}_2$. Con los números de la lección:

Por inducción, $L$ capas lineales equivalen a una. Con $\phi=\mathrm{ReLU}$ y la entrada $(0,1)$, la capa oculta da $(2,-1)$, la ReLU lo convierte en $(2,0)$ y la salida es $2\cdot2+1\cdot0=4$, no $3$: la equivalencia se rompe.

Las activaciones

Sus derivadas importan para entrenar (lección 8): $\sigma'(z)=\sigma(z)(1-\sigma(z))\le \tfrac14$, $\tanh'(z)=1-\tanh^2(z)\le 1$ y $\mathrm{ReLU}'(z)\in\{0,1\}$ (en $z=0$ no existe; por convención se toma 0). La ReLU, «unidad lineal rectificada», tiene variantes suaves, como la GELU (Hendrycks y Gimpel, 2016), que BERT usa en lugar de la ReLU (Devlin et al., 2019).

Aproximación universal

Qué dice (Cybenko, 1989, teorema 2). Una función $\sigma$ es sigmoidal si $\sigma(t)\to1$ cuando $t\to+\infty$ y $\sigma(t)\to0$ cuando $t\to-\infty$. Si $\sigma$ es continua y sigmoidal, para toda función continua $f$ sobre el cubo unitario $K=[0,1]^n$ (con un cambio de escala, sobre cualquier cubo) y todo $\varepsilon>0$ existen $N$, $\alpha_j$, $\mathbf{w}_j$ y $b_j$ tales que

Quiénes más, y con qué condiciones. El mismo año, Hornik, Stinchcombe y White lo probaron para «funciones de aplastamiento» (no decrecientes, con límites 0 y 1, no necesariamente continuas), y para funciones medibles en un sentido más débil (aproximación en probabilidad); en una nota final reconocen el trabajo de Funahashi (1989), que llegó por su cuenta a un resultado cercano. Las hipótesis no coinciden: Cybenko no exige que $\sigma$ sea monótona, y Hornik et al. no exigen que sea continua. Hornik (1991) mostró que basta con una activación acotada y no constante (aproximación en $L^p$; si además es continua, aproximación uniforme sobre compactos). Leshno, Lin, Pinkus y Schocken (1993) cerraron la cuestión: para una activación localmente acotada y continua a trozos, una red con una capa oculta aproxima toda función continua, uniformemente sobre cada compacto, si y solo si la activación no es un polinomio. La ReLU cumple esa condición. El teorema también necesita el sesgo (el umbral): sin él, no vale.

Qué no dice. Aproxima una función conocida sobre un conjunto acotado; no dice nada fuera de él ni sobre aprender de ejemplos. No acota $N$ ni dice cómo hallar los pesos. Cybenko lo reconoce en su discusión final: su artículo se limita a la existencia, y sospecha que la gran mayoría de los problemas de aproximación exigirán un número astronómico de términos, por la maldición de la dimensionalidad. Hornik et al. añaden que un fallo en la práctica puede deberse a un aprendizaje inadecuado, a pocas neuronas o a que la relación entre entrada y salida sea aleatoria.

La construcción de la lección. No es la demostración de Cybenko, que usa el teorema de Hahn–Banach y no construye nada. Para una función $f$ de una variable, con $n$ nudos equiespaciados $t_k$ y pendientes $s_k=\frac{f(t_k+h)-f(t_k)}{h}$, $h=(b-a)/n$,

es una red con una capa oculta de $n$ neuronas ReLU que coincide con $f$ en los nudos (interpolación lineal por tramos). Si $|f''|\le M$, el error máximo es a lo sumo $\dfrac{(b-a)^2M}{8n^2}$: al duplicar las neuronas, la cota se divide por cuatro. Para la curva de la escena, $M\le 3.36$; con $n=24$ la cota es 0.026 y el error medido, 0.025. La razón de errores medidos no es siempre cuatro: 2.5 al pasar de 3 a 6 neuronas, 3.0 de 6 a 12, 4.1 de 12 a 24 y 3.8 de 24 a 48. Tampoco baja en cada paso (de 1 a 2, de 4 a 5 y de 7 a 8 neuronas sube un poco, porque los nudos equiespaciados caen en otros lugares). La meta del turno, 0.05, se alcanza con 17 neuronas (0.047; con 16, 0.057). Aquí los pesos se calculan, no se entrenan.

Profundidad: la sierra

La función tienda $g(x)=2\,\mathrm{ReLU}(x)-4\,\mathrm{ReLU}(x-\tfrac12)$ sobre $[0,1]$ usa dos neuronas: sube de 0 a 1 en $[0,\tfrac12]$ y baja de 1 a 0 en $[\tfrac12,1]$. La composición $g^{(k)}=g\circ\cdots\circ g$ ($k$ capas, $2k$ neuronas) tiene $2^k$ tramos rectos (comprobado numéricamente hasta $k=6$). Una red de una sola capa oculta con $m$ neuronas ReLU tiene a lo sumo $m+1$ tramos en una dimensión (cada neurona aporta una esquina), así que para igualarla necesita al menos $2^k-1$ neuronas. Telgarsky (2016) usa esta misma función y prueba algo más fuerte, para aproximar y no solo igualar: para cada $k$ existe una red ReLU con $2k^3+8$ capas y $3k^3+12$ neuronas tal que toda red ReLU con a lo sumo $k$ capas y a lo sumo $2^k$ neuronas queda a distancia $L^1$ de al menos $1/64$ sobre $[0,1]^d$. Es un resultado sobre funciones concretas, no una ley: no dice que toda tarea real se beneficie igual de la profundidad.

En código: el pase hacia delante y el colapso

import numpy as np

W1 = np.array([[1, 2],
               [3, -1]])        # capa oculta: una fila por neurona
W2 = np.array([[2, 1]])         # salida

def red(x, activacion):
    h = activacion(W1 @ x)      # pase hacia delante: capa oculta...
    return (W2 @ h)[0]          # ...y salida

lineal = lambda z: z
relu = lambda z: np.maximum(0, z)

print("W2 @ W1 =", W2 @ W1)     # la neurona única equivalente
for x in ([2, 1], [1, 0], [0, 1]):
    x = np.array(x)
    print(x, "sin activación:", red(x, lineal), "| una neurona:", (W2 @ W1 @ x)[0], "| con ReLU:", red(x, relu))

Salida esperada:

W2 @ W1 = [[5 3]]
[2 1] sin activación: 13 | una neurona: 13 | con ReLU: 13
[1 0] sin activación: 5 | una neurona: 5 | con ReLU: 5
[0 1] sin activación: 3 | una neurona: 3 | con ReLU: 4

En código: una red que aprende los círculos

Es la misma idea del patio de juegos (red 2-6-1, ReLU y sigmoide de salida), con descenso del gradiente simple. Las líneas con dZ son la retropropagación, que se explica en la lección 8.

import numpy as np
rng = np.random.default_rng(0)

# Datos: un grupo central (clase 0) rodeado por un anillo (clase 1)
n = 90
a0, r0 = rng.uniform(0, 2 * np.pi, n), np.sqrt(rng.uniform(0, 1, n)) * 1.15
a1, r1 = rng.uniform(0, 2 * np.pi, n), rng.uniform(1.95, 2.8, n)
X = np.vstack([np.c_[r0 * np.cos(a0), r0 * np.sin(a0)], np.c_[r1 * np.cos(a1), r1 * np.sin(a1)]])
X = (X + 0.12 * rng.normal(size=X.shape)) / 3          # coordenadas en [-1, 1]
y = np.r_[np.zeros(n), np.ones(n)]

# Red 2 → 6 (ReLU) → 1 (sigmoide)
W1 = rng.normal(0, np.sqrt(2 / 2), (2, 6)); b1 = rng.uniform(-0.5, 0.5, 6)
W2 = rng.normal(0, np.sqrt(1 / 6), (6, 1)); b2 = np.zeros(1)
sig = lambda z: 1 / (1 + np.exp(-z))

for paso in range(1500):
    Z1 = X @ W1 + b1; H = np.maximum(0, Z1); p = sig(H @ W2 + b2).ravel()   # pase hacia delante
    dZ2 = (p - y)[:, None] / len(y)                                          # error en la salida
    dW2, db2 = H.T @ dZ2, dZ2.sum(0)
    dZ1 = (dZ2 @ W2.T) * (Z1 > 0)                                            # la culpa vuelve a la capa oculta
    dW1, db1 = X.T @ dZ1, dZ1.sum(0)
    for P, G in ((W1, dW1), (b1, db1), (W2, dW2), (b2, db2)):
        P -= 0.5 * G                                                          # descenso del gradiente
print("aciertos:", ((p > 0.5) == y).mean())

Salida esperada: aciertos: 1.0. Con 6 neuronas dio 1.0 en las diez semillas probadas (0 a 9); con 3 neuronas, entre 0.81 y 1.0; con 2, entre 0.82 y 0.89 (los números aleatorios de NumPy pueden cambiar entre versiones). Son aciertos sobre los mismos puntos con los que se entrena: acertar con datos nuevos es otra pregunta (lección 10). El patio de juegos de la lección usa el optimizador Adam en lugar del descenso simple (lección 9).

Lo que viene

Calcular el gradiente de cada peso en una red así es la retropropagación (lección 8). Cómo entrenar bien —lotes, optimizadores— es la lección 9, y la 10 muestra que acertar en los puntos de entrenamiento, como aquí, no garantiza acertar con datos nuevos.