El mundo hecho de números

De la imagen al vector

Una imagen en escala de grises es una matriz $X \in \{0,\dots,255\}^{H \times W}$. Aplanarla, fila por fila, da el vector $\mathbf{x} \in \mathbb{R}^{HW}$ con

La carita de la lección tiene $H = W = 8$, así que $\mathbf{x}$ tiene 64 componentes. Cada valor cabe en un byte: $2^8 = 256$ niveles. Antes de entrenar es habitual normalizar, $x' = x/255 \in [0,1]$.

La vecindad se pierde al aplanar: el píxel $(i,j)$ y el $(i+1,j)$ son vecinos en la imagen, pero sus posiciones en el vector difieren en $W$ (ocho, en la carita). Un modelo que trata cada componente como una medida independiente, como el de los correos de la lección 1 o una red totalmente conectada, no sabe cuáles píxeles son vecinos; las redes convolucionales (lección 11) sí lo aprovechan y reciben la imagen como matriz.

Color, canales y tensores

Una imagen en color es un tensor $X \in \{0,\dots,255\}^{H \times W \times 3}$ con $3HW$ valores. Una foto de 12 megapíxeles, por ejemplo de $4000 \times 3000$ píxeles, tiene

es decir, unos 36 MB sin comprimir a un byte por valor. Los archivos como JPEG ocupan mucho menos, pero el modelo trabaja con los píxeles ya decodificados (o con una versión reducida: AlexNet, por ejemplo, redujo todas las imágenes de ImageNet a $256 \times 256$ —reescalando el lado corto a 256 y recortando el centro—, o sea $256 \times 256 \times 3 = 196\,608$ valores, unas 183 veces menos que la foto de 12 megapíxeles; la red recibía además recortes de $224 \times 224 \times 3 = 150\,528$ valores; Krizhevsky et al., 2012). El orden de los ejes depende de la biblioteca: alto × ancho × canales, o canales × alto × ancho. En rigor, un número, un vector y una matriz también son tensores (de 0, 1 y 2 ejes).

En la lección, el gris de cada píxel sale de su color con la receta de luma de la recomendación ITU-R BT.601 (versión 7, 2011): $Y' = 0.299\,R' + 0.587\,G' + 0.114\,B'$, aplicada a valores ya corregidos con gamma. Con tres canales de 8 bits hay $256^3 = 16\,777\,216$ colores posibles.

Desenfoque: mezclar con los vecinos

El desenfoque de la lección mezcla cada píxel con el promedio de su ventana $3\times 3$, en una proporción $\lambda$:

con $\lambda = 0,\ 0.25,\ 0.5,\ 0.75,\ 1$ en los niveles 0 a 4, y $V_{ij}$ la ventana restringida a los vecinos que existen (9 píxeles en el interior, 6 en los bordes, 4 en las esquinas). Para el píxel de la fila 3, columna 3 (contando desde 1), los nueve valores son 146, 202, 255, 202, 0, 202, 202, 0 y 202, y su promedio es $\approx 156.8$. Es un caso particular de convolución (lección 11). Medido sobre la carita (valores redondeados a enteros): en cada nivel de 1 a 4 cambian los 64 números, con un cambio medio de 15.0, 29.9, 44.9 y 59.9 niveles de gris (de 255), y el contraste (máximo menos mínimo) baja de 255 a 205, 175, 145 y 131.

Con $\lambda < 1$ la operación se puede deshacer en teoría (la matriz es invertible; con $\lambda = 0.75$ ya amplifica 40 veces el redondeo), pero con $\lambda = 1$ pierde información de verdad. La suma de una ventana es $K \otimes K$, con $K$ la matriz $8\times 8$ tridiagonal de unos, y $K$ tiene un vector nulo, $u = (1,-1,0,1,-1,0,1,-1)$: tres vecinos seguidos siempre suman cero. Por eso el desenfoque completo tiene rango $7 \times 7 = 49$, no 64, y desaparecen 15 direcciones. Ejemplo exacto: sumar $+25,-25,0,+25,-25,0,+25,-25$ a la columna 4 de la carita cambia seis píxeles y da otra imagen con el mismo desenfoque completo, número por número.

Sonido: muestreo

Una señal $s(t)$ se guarda como $x[n] = s(n/f_s)$, con $f_s$ muestras por segundo. Shannon (1949, teorema 1) lo enuncia así: si una función no tiene frecuencias por encima de $W$, queda completamente determinada por sus valores en puntos separados $1/2W$ segundos; en la práctica se pide $f_s > 2B$ para una señal sin frecuencias por encima de $B$ (en el límite exacto, $f_s = 2B$, el tono de frecuencia $B$ no queda determinado, como se ve en la demostración). Shannon atribuye a Nyquist la importancia de ese intervalo. Whisper remuestrea todo el audio a $f_s = 16\,000$ Hz (Radford et al., 2022, sección 2.2), con lo que se representan componentes de hasta 8 kHz: un minuto son $16\,000 \times 60 = 960\,000$ valores. El modelo no recibe esos valores tal cual: calcula un espectrograma logarítmico de 80 canales con ventanas de 25 ms y paso de 10 ms, es decir 100 columnas por segundo, $80 \times 100 = 8\,000$ números por segundo.

La señal de juguete de la lección suma un tono de 200 y otro de 500 ciclos por segundo y se repite cada 10 ms; se toman $n = f_s/100$ muestras por periodo. La línea discontinua es lo que reconstruiría un conversor ideal (interpolación trigonométrica de las $n$ muestras). Se comprobó con el código de la lección: con $f_s \ge 1\,100$ la reconstrucción coincide con la señal sin error; con $f_s = 1\,000$ el error relativo es 0.43 (el tono de 500 queda justo en el límite) y por debajo es aún mayor (de 0.67 a 1.65). Por eso la compuerta pide bajar a 1 000 o menos.

Texto: de códigos a vectores

Unicode asigna un número, el punto de código, a cada carácter: «N» es 78, «e» es 101, «u» es 117, «ñ» es 241 (tablas de códigos del estándar Unicode). Es una etiqueta, no un significado. Los modelos de lenguaje parten el texto en tokens (lección 20), cada token es un entero, y una tabla de embeddings $E \in \mathbb{R}^{V \times d}$ entrega a cada uno un vector $E_{\text{id}} \in \mathbb{R}^{d}$, aprendido durante el entrenamiento. En GPT-3 175B la dimensión del modelo es $d_{\text{model}} = 12\,288$ (Brown et al., 2020, tabla 2.1). Los cuatro rasgos de la lección ($d=4$) son inventados; en un modelo real los rasgos se aprenden y no tienen nombre. La cercanía en el espacio, medida por ejemplo con la distancia euclídea $\lVert \mathbf{a}-\mathbf{b}\rVert$, se llena de significado en la lección 14. En la lección, «gato» y «perro» están a 0.22; «gato» y «tigre», a 1.08; «gato» y «pan», a 1.68.

MNIST (LeCun et al., 1998) parte de dígitos escritos por empleados de la Oficina del Censo de EE. UU. y por estudiantes de secundaria (bases NIST SD-3 y SD-1). Las imágenes originales eran en blanco y negro; al normalizarlas a una caja de $20\times 20$ píxeles aparecieron los grises, y se centraron en un cuadro de $28\times 28$ por el centro de masa. La imagen de la lección es una ilustración, no un dígito del conjunto.

En código

import numpy as np

# la carita en grises (8x8), la misma de la lección
carita = np.array([
    [ 20,  20, 146, 146, 146, 146,  20,  20],
    [ 20, 146, 202, 255, 202, 202, 146,  20],
    [146, 202,   0, 202, 202,   0, 202, 146],
    [146, 202,   0, 202, 202,   0, 202, 146],
    [146, 202, 202, 202, 202, 202, 202, 146],
    [146, 202,   0, 202, 202,   0, 202, 146],
    [ 20, 146, 202,   0,   0, 202, 146,  20],
    [ 20,  20, 146, 146, 146, 146,  20,  20],
], dtype=np.uint8)

vector = carita.flatten()               # de tabla a lista, fila por fila
print(carita.shape, vector.shape)       # (8, 8) (64,)

# un píxel y el de abajo: vecinos en la imagen, lejos en el vector
i, j = 2, 2
print(i * 8 + j, (i + 1) * 8 + j)       # 18 26

# desenfoque de un píxel: promedio de su ventana 3x3
ventana = carita[i - 1:i + 2, j - 1:j + 2]
print(ventana.mean())                   # 156.77777777777777

# desenfoque de toda la imagen (en los bordes, solo los vecinos que existen)
def desenfoque(img):
    out = np.zeros(img.shape)
    for r in range(8):
        for c in range(8):
            out[r, c] = img[max(r - 1, 0):r + 2, max(c - 1, 0):c + 2].mean()
    return out

x = carita.astype(float)
otra = x.copy()
otra[:, 3] += [25, -25, 0, 25, -25, 0, 25, -25]    # otra imagen: seis píxeles distintos
print(int((otra != x).sum()), np.abs(desenfoque(x) - desenfoque(otra)).max())   # 6 0.0

# desenfoque suave (25 %): todos los números cambian, pero poco
suave = 0.75 * x + 0.25 * desenfoque(x)
print(round(np.abs(suave - x).mean(), 1), int((np.round(suave) != x).sum()))    # 15.0 64

# una foto de 12 megapíxeles en color (4000 x 3000 píxeles, 3 canales)
foto = np.zeros((3000, 4000, 3), dtype=np.uint8)
print(foto.shape, foto.size)            # (3000, 4000, 3) 36000000

# texto: el código de cada letra
print([ord(c) for c in "Neu"])          # [78, 101, 117]

Lo que viene

Con los datos ya en vectores, la lección 3 pone el primer modelo encima: una recta $y = wx + b$ y su error. Más adelante, las convoluciones (lección 11) recuperan la vecindad de los píxeles, los embeddings (lección 14) dan geometría al significado y los tokens (lección 20) explican qué «piezas» de texto lee de verdad un modelo de lenguaje.