Secuencias y memoria

La celda recurrente

Con una entrada $x_t\in\mathbb{R}^{D}$ y un estado $h_{t-1}\in\mathbb{R}^{H}$, la RNN de Elman calcula

con $W_x\in\mathbb{R}^{H\times D}$, $W_h\in\mathbb{R}^{H\times H}$ y $b\in\mathbb{R}^{H}$. Son $H(H+D)+H$ parámetros, los mismos en todos los pasos: no crecen con el largo de la frase. Para predecir la palabra siguiente se agrega una capa de salida, $\hat y_t=\mathrm{softmax}(W_y h_t)$ (lección 19). En la lección, $H=6$, $D=4$, sin sesgo ($60$ parámetros) y con pesos al azar sin entrenar: solo se ve la mecánica.

La culpa a través del tiempo

La pérdida total es $L=\sum_t L_t$. La culpa que llega al estado $h_k$ desde el paso $T$ es la regla de la cadena (lección 8) aplicada a lo largo del tiempo:

Es un producto de $T-k$ matrices. La escena muestra el tamaño de ese producto, $\|\partial h_T/\partial h_k\|_F/\sqrt{H}$ (la ganancia típica ante un empujón en una dirección al azar; $1$ = no se pierde nada). Como $|1-h^2|\le 1$, si la norma de $W_h$ (su mayor valor singular) es $g<1$, el producto cae como una exponencial: $\|\partial h_T/\partial h_k\|\le g^{\,T-k}$. Con una sigmoide el techo de la derivada es $1/4$ y todo cae más rápido (lección 8). En general, Pascanu, Mikolov y Bengio (2013) muestran, para una no linealidad con $|\sigma'|\le\gamma$ ($\gamma=1$ para tanh, $\tfrac14$ para sigmoide), que $\lambda_1<1/\gamma$ **basta** para que la contribución lejana se desvanezca y que $\lambda_1>1/\gamma$ es necesario para que explote ($\lambda_1$: el autovalor mayor en valor absoluto de $W_h$).

Con $\lambda_1>1/\gamma$ no hay garantía de explosión: la tanh se satura ($1-h^2\approx0$) y apaga unidades, como se ve en la escena, donde con pesos grandes la culpa se vuelve errática, enorme en unas frases y casi nula en otras. Dos remedios clásicos: recortar la norma del gradiente contra la explosión (Pascanu et al., 2013) y rediseñar la celda contra el desvanecimiento. Bengio, Simard y Frasconi (1994) añaden un dilema: para guardar un dato de forma estable ante el ruido hace falta que la dinámica contraiga, y eso hace que los gradientes de largo plazo se desvanezcan.

La LSTM

Con compuertas $f_t,i_t,o_t\in(0,1)^H$, un candidato $\tilde c_t$ y el producto elemento a elemento $\odot$:

La cinta $c_t$ se actualiza por suma, no por reescritura. A lo largo de ella, $\partial c_t/\partial c_{t-1}=\mathrm{diag}(f_t)$ (más caminos indirectos por $h$), de modo que la culpa se multiplica solo por la compuerta de olvido: con $f\approx1$ llega casi intacta, el «carrusel de error constante» del artículo de 1997. La LSTM original tenía compuertas de entrada y de salida; la de olvido la añadieron Gers, Schmidhuber y Cummins (2000). Un truco práctico: iniciar el sesgo $b_f$ cerca de $1$ para que la cinta empiece abierta (Jozefowicz et al., 2015). Una capa tiene $4H(H+D)+4H$ parámetros: cuatro veces los de la RNN. Con $H=D=1000$ son $8\,004\,000$. Las LSTM apiladas llegaron lejos: el sistema de traducción neuronal de Google (Wu et al., 2016) usaba ocho capas LSTM en el codificador y ocho en el decodificador, con atención y conexiones residuales.

En la lección las compuertas son números fijos y hay una sola celda: $c_t=f\,c_{t-1}+i_t\tanh(v_t)$, $h_t=o\tanh(c_t)$, donde $v_t$ son pistas de número gramatical ilustrativas (plural para «flores», singular para «mercado») y $i_t=1$ en la palabra clave. Una red entrenada calcula $f_t$ e $i_t$ de la palabra y del estado. En 2019, Lakretz et al. hallaron que, en una LSTM entrenada como modelo de lenguaje, la información de número de largo alcance la manejan sobre todo dos «unidades de número», justo lo que hace nuestra celda de juguete.

En código

import numpy as np

def influencia(g, pasos):
    """Cuánto de un empujón en el estado inicial sobrevive tras `pasos` pasos (RNN de 2 unidades con tanh)."""
    c, s = np.cos(0.8), np.sin(0.8)
    Wh = g * np.array([[c, -s], [s, c]])        # un giro de 0,8 rad, escalado por g
    x = np.array([0.5, -0.3])                   # la «palabra» que llega en cada paso
    h, P = np.zeros(2), np.eye(2)
    for _ in range(pasos):
        h = np.tanh(Wh @ h + x)
        P = ((1 - h**2)[:, None] * Wh) @ P      # P = J_t · P, con J_t = diag(1 − h²) · Wh
    return np.linalg.norm(P) / np.sqrt(2)

for g in (0.5, 0.9, 1.5, 2.0):
    print(g, [round(float(influencia(g, n)), 4) for n in (1, 5, 10, 20)])
# 0.5 [0.4266, 0.0083, 0.0001, 0.0]
# 0.9 [0.7679, 0.0989, 0.0152, 0.0004]
# 1.5 [1.2798, 0.8562, 1.218, 1.154]
# 2.0 [1.7064, 2.2703, 2.4696, 1.3574]

Con $g=0.5$ o $0.9$ el empujón se apaga; con $g=2$ se amplifica; en torno a $g=1.5$ y con esta entrada fija hay una ventana estrecha en que se mantiene. Basta moverse un poco para salir de ella.

import math

pistas = [0, 1.2, 0.3, -0.5, 0.2, -0.1, -0.9]    # pista de número de cada palabra (ilustrativa)

def celda(f, i, o):
    c = 0.0
    for t, v in enumerate(pistas, start=1):
        entrada = 1.0 if t == 2 else i               # «flores» abre la compuerta de entrada
        c = f * c + entrada * math.tanh(v)           # la cinta: olvidar un poco, escribir un poco
    return o * math.tanh(c)                          # lo que se lee al final (positivo = plural)

print(round(celda(0.6, 0.8, 1.0), 3))    # -0.5   (la pista se pierde y gana «mercado»: singular)
print(round(celda(1.0, 0.1, 1.0), 3))    # 0.638  (plural)
print(round(0.97 ** 5, 2))                # 0.86   (culpa que llega a «flores» por la cinta)

Lo que viene

La RNN y la LSTM leen en fila y comprimen todo en un vector; la atención (lección 21) deja que cada palabra mire directamente a las demás, en paralelo. Antes, la lección 13 cuenta por qué el deep learning despegó hacia 2012: datos, GPUs y algunos trucos, entre ellos las conexiones residuales, que en profundidad cumplen un papel parecido al de la cinta de la LSTM.