Generar es aprender una distribución

Clasificar frente a generar

Un modelo que clasifica aprende $p(y\mid x)$: dado el dato, la etiqueta; le basta la frontera. Un modelo generativo aprende la distribución de los propios datos, $p_\theta(x)$, y permite muestrear $x\sim p_\theta(x)$. Se entrena, en general, por máxima verosimilitud:

La nube de los sietes

Cada dígito se mide con $m=(m_1,m_2)$: la tinta de su mitad de arriba y la de su mitad de abajo (cada píxel vale de 0 a 1; cada mitad tiene 32 píxeles). Los óvalos de la lección son una gaussiana en dos dimensiones ajustada por máxima verosimilitud a los 179 sietes:

El óvalo pequeño es $(m-\hat\mu)^\top\hat\Sigma^{-1}(m-\hat\mu)=1$ y el grande, $=4$. En una gaussiana de dos dimensiones caen dentro $1-e^{-1/2}\approx 39\,\%$ y $1-e^{-2}\approx 86\,\%$ de las muestras. Para muestrear se toma $\varepsilon\sim\mathcal N(0,I)$ y $m=\hat\mu+L\varepsilon$, con $LL^\top=\hat\Sigma$ (Cholesky). La frontera entre seises y sietes de la escena es la del análisis discriminante lineal: la recta donde las dos gaussianas, con su covarianza promedio, dan la misma densidad.

Por qué no basta con cada píxel por separado

Sacar cada píxel de su propia distribución equivale a suponer $p(x)=\prod_{j=1}^{64}p(x_j)$: píxeles independientes. En los dígitos es falso (un trazo enciende a sus vecinos), y por eso salen manchas. Hace falta un modelo de cómo varían juntos.

Autocodificador

Un codificador $z=E_\phi(x)$ y un decodificador $\hat x=D_\theta(z)$, entrenados juntos para minimizar el error de reconstrucción:

Los modelos de la lección son diminutos: $64\to32\to2\to32\to64$ con $\tanh$ en la capa oculta y un sigmoide a la salida (4354 parámetros), entrenados con descenso del gradiente (Adam) sobre 1500 imágenes; otras 297 se reservaron para reconstruir imágenes que la red nunca vio. Error medio por imagen reservada según el tamaño del código: 3.14 con 1 número, 2.34 con 2, 1.46 con 4, 0.95 con 8 y 0.54 con 16 (adivinar siempre la imagen media daría 4.71). Con decodificador lineal y error cuadrático, un autocodificador aprende el mismo subespacio que el PCA (Goodfellow et al., 2016, §14.1); las capas no lineales lo generalizan, y Hinton y Salakhutdinov (2006) mostraron que los autocodificadores profundos aprenden códigos mucho mejores que el PCA.

Autocodificador variacional (VAE)

Se postula un código con distribución previa conocida, $p(z)=\mathcal N(0,I)$ (la «zona redonda»), y un decodificador $p_\theta(x\mid z)=\mathcal N(D_\theta(z),\sigma_{\text{obs}}^2 I)$. El codificador devuelve una nube, $q_\phi(z\mid x)=\mathcal N\big(\mu_\phi(x),\operatorname{diag}\sigma^2_\phi(x)\big)$: su centro y su tamaño. En el entrenamiento se saca un punto con el truco de reparametrización, que deja pasar el gradiente:

Lo que se maximiza es una cota inferior de $\log p_\theta(x)$ (la ELBO):

El primer término es el error de reconstrucción; el segundo, la penalización que acerca cada nube a la zona estándar. Para gaussianas diagonales tiene forma cerrada:

La pérdida usada en la lección es $\lVert x-\hat x\rVert^2/(2\sigma_{\text{obs}}^2)+D_{\mathrm{KL}}$ con $\sigma_{\text{obs}}^2=0.1$ (4420 parámetros). Los dos términos compiten: la reconstrucción separa y encoge las nubes; la penalización las junta y las ensancha. Para generar: $z\sim\mathcal N(0,I)$ y $x=D_\theta(z)$. Con un decodificador gaussiano de varianza fija, la mejor reconstrucción de un código es el promedio de las imágenes que caben en él: de ahí la borrosidad. Kingma y Welling (2019, §2.8.2) la atribuyen a que el ajuste nunca es perfecto y señalan que se atenúa con modelos de inferencia y generativos más flexibles.

Muestrear con cada modelo

Para el autocodificador no hay una zona definida de la cual muestrear; el recurso ingenuo es sacar puntos uniformes en el recuadro de sus códigos. Un clasificador sencillo (regresión logística entrenada con las mismas 1500 imágenes) etiquetó 3000 muestras de cada modelo: el autocodificador dio 22 % de cuatros, 21 % de seises y 0.7 % de ochos; el VAE, entre 6 % y 14 % de cada dígito (los datos reales tienen cerca de 10 % de cada uno). Con ocho semillas distintas el resultado se repite: el VAE siempre queda más parejo (véase train_toy.py).

En código

import numpy as np

# cinco sietes medidos con (tinta arriba, tinta abajo): ejemplo
m = np.array([[12.0, 7.8], [10.4, 8.9], [11.3, 7.4], [9.6, 8.5], [10.9, 8.1]])
mu = m.mean(axis=0)                        # centro de la nube
cov = np.cov(m.T, bias=True)               # forma del óvalo (máxima verosimilitud: divide entre N)
L = np.linalg.cholesky(cov)                # L @ L.T == cov
rng = np.random.default_rng(0)
nuevos = mu + rng.standard_normal((3, 2)) @ L.T   # muestrear: tres puntos nuevos de la nube
print(mu.round(2).tolist(), nuevos.round(1).tolist())
# [10.84, 8.14] [[10.9, 8.0], [11.4, 7.9], [10.4, 8.5]]

# Una nube de VAE: centro y tamaño (uno por cada número del código)
c, s = np.array([0.8, -0.3]), np.array([0.5, 0.8])
kl = 0.5 * np.sum(c**2 + s**2 - np.log(s**2) - 1)   # penalización frente a la zona estándar N(0, I)
z = c + s * np.array([0.2, -1.0])                   # un punto sacado de la nube (truco de reparametrización)
print(round(float(kl), 4), z.round(2).tolist())
# 0.7263 [0.9, -1.1]

Lo que viene

Los VAE fueron propuestos de forma independiente por Kingma y Welling (2013) y por Rezende, Mohamed y Wierstra (2014). Las redes generativas adversarias (lección 16) aprenden a generar sin escribir una densidad: compitiendo. La difusión (lección 17) aprende a quitar ruido, y su versión latente trabaja dentro del espacio comprimido de un autocodificador.