Clasificación, entropía cruzada y cómo no engañarte a ti mismo

La misma fábrica que en el Capítulo 1, pero una pregunta más difícil. En lugar de aceptar o rechazar, la pregunta es ¿esta pieza es defectuosa?; y los defectos son raros, lo que hace difícil la mitad de medición de este capítulo y engañosamente fácil la mitad de modelado.

import numpy as np

rng = np.random.default_rng(4)
N = 20_000
width  = rng.normal(22.0, 0.9, N)      # millimetres
weight = rng.normal(57.0, 3.0, N)      # grams

z_true = -5.90 + 1.90 * (width - 22.0) + 0.42 * (weight - 57.0)
y = (rng.random(N) < 1 / (1 + np.exp(-z_true))).astype(float)

perm = rng.permutation(N)
train, val, test = perm[:12_000], perm[12_000:16_000], perm[16_000:]

N = 20000  defects = 337  base rate = 0.0169
defects per split = 203 60 74

Tres particiones, no dos. La razón merece su propia sección y la tendrá más abajo; por ahora, entrena con la primera, ajusta con la segunda y no mires la tercera.

Las features se estandarizan —se resta la media y se divide por la desviación típica— usando solo las estadísticas de entrenamiento, por la razón que el Capítulo 1 demostró con la cota de convergencia del perceptrón: los datos no centrados vuelven hostil la geometría. De qué filas puedes calcular esa media se convierte en una pregunta viva más adelante en este capítulo.

El perceptrón devolvía un signo. Un signo no puede distinguir rechazar de rechazar, pero por poco, y esa diferencia es exactamente lo que una fábrica necesita para decidir qué piezas debería reinspeccionar primero una persona.

Así que sigue literalmente la receta del Capítulo 2. Escribe lo que afirmas sobre cómo se produce una etiqueta, toma la verosimilitud, toma el logaritmo, cámbiale el signo, y tienes una pérdida. Para un resultado de sí/no, la afirmación es una distribución Bernoulli: hay una probabilidad $p$ de que la pieza sea defectuosa, y

que es solo una forma compacta de escribir «$p$ si $y = 1$, y $1-p$ si $y = 0$». Toma el logaritmo de eso y cámbiale el signo, y la pérdida para un ejemplo es

Esto es entropía cruzada binaria. No se eligió porque sea cómoda; es la log-verosimilitud negativa de la única distribución que puede tener el lanzamiento de una moneda. No había nada más disponible.

Lo que aún falta es de dónde sale $p$. El modelo calcula una suma ponderada $s = \mathbf{w}\cdot\mathbf{x} + b$, que es un número real y recorre toda la recta, y una probabilidad tiene que vivir en $(0,1)$. La función que se mueve entre ambas es la sigmoide logística:

logit -4.0  ->  p = 0.0180        loss when y=1 and p=0.9  : 0.1054
logit -1.0  ->  p = 0.2689        loss when y=1 and p=0.5  : 0.6931
logit  0.0  ->  p = 0.5000        loss when y=1 and p=0.01 : 4.6052
logit  4.0  ->  p = 0.9820

Lee la columna de la derecha como una lista de precios. Acertar con un 90 % de confianza cuesta 0,105. Negarse a comprometerse cuesta 0,693 —que es $\log 2$, el precio de encogerse de hombros—. Equivocarse con seguridad cuesta 4,6, cuarenta y cuatro veces más, y el precio sube sin límite a medida que el modelo se vuelve más seguro de un error. La entropía cruzada no se limita a contar errores: cobra por la arrogancia.

El Capítulo 3 decía: para entrenar cualquier cosa, obtén la derivada de la pérdida respecto a cada parámetro. Hazlo para un ejemplo. Con $s = \mathbf{w}\cdot\mathbf{x} + b$ y $p = \sigma(s)$:

Así que la actualización es predicción menos verdad, por la entrada. Nada más. Aquí está el entrenador completo, que es el descenso del Capítulo 3 con una línea cambiada:

def sigmoid(z):
    return np.where(z >= 0, 1.0 / (1.0 + np.exp(-z)),
                    np.exp(np.minimum(z, 0)) / (1.0 + np.exp(np.minimum(z, 0))))


def fit_logistic(X, y, lr=0.5, epochs=4000):
    w, b = np.zeros(X.shape[1]), 0.0
    for _ in range(epochs):
        p = sigmoid(X @ w + b)
        g = p - y                        
        w -= lr * (X.T @ g) / len(y)     
        b -= lr * g.sum() / len(y)       
    return w, b

El np.where en sigmoid no es cosmético. Calcular $1/(1+e^{-s})$ directamente desborda con $s$ negativos grandes; la rama elige la forma algebraicamente idéntica que mantiene negativo el exponente. Esta es la caja de coma flotante del Capítulo 2 cobrando su primera deuda, y cobrará una mayor dentro de dos secciones.

La explicación estándar para preferir la entropía cruzada al error cuadrático es el argumento de verosimilitud anterior: el error cuadrático es lo que obtienes al suponer ruido gaussiano; las etiquetas no son gaussianas; por tanto, no lo hagas. Es correcto y no convence a nadie, porque puedes escribir $L = (p - y)^2$ sobre una sigmoide y entrenará.

El argumento que sí cala va del gradiente. Pon error cuadrático encima de una sigmoide y la regla de la cadena da

Ese $p(1-p)$ extra es el que se cancelaba antes. Ahora no lo hace, y se va a cero siempre que el modelo tiene confianza, incluso cuando el modelo está equivocado con confianza. Evalúa ambos en unas cuantas puntuaciones, para un ejemplo cuya etiqueta verdadera es 1:

En $s = -8$ el modelo está tan equivocado como puede estarlo, y el error cuadrático responde con un gradiente 1.491 veces menor que el de la entropía cruzada. Cuanto peor es el error, menos aprende el modelo de él. El gradiente de la entropía cruzada, mientras tanto, se satura en $-1$: estar máximamente equivocado produce una señal máximamente grande, y no mayor.

Haz la carrera. Dos mil puntos equilibrados, pesos iniciales idénticos elegidos para estar equivocadamente seguros ($\mathbf{w} = [-6, -6]$), tasa de aprendizaje idéntica; solo cambia la pérdida. Ambas ejecuciones se puntúan con entropía cruzada para que las columnas sean comparables.

La entropía cruzada ha terminado en la época 50. El error cuadrático sigue en un 24 % de accuracy en la época 100 —y no se había movido del 23 % en la época 10—, peor que adivinar, porque empezó equivocadamente seguro y el gradiente que lo habría rescatado se ha multiplicado por 0,0007. Escapa alrededor de la época 500 y aterriza en el mismo sitio. Así que el resumen honesto es que el error cuadrático sobre una sigmoide no es incorrecto; es lento exactamente donde más importa la velocidad. En un modelo de dos parámetros pierdes 450 épocas. En una red con cien capas, donde alguna unidad en algún lugar siempre está equivocadamente segura, pierdes la ejecución de entrenamiento.

Tres cantidades, necesarias de verdad en el Capítulo 8 para la perplejidad y en el Capítulo 11 para la penalización que mantiene una política con fine-tuning cerca de su referencia. Son más fáciles de lo que dice su fama.²

Entropía es el número medio de bits que debes gastar para comunicar una muestra de una distribución, si usas el mejor código posible para ella:

Entropía cruzada es lo que gastas cuando usas un código construido para $q$ sobre datos que en realidad vienen de $p$:

Divergencia KL es el exceso —el desperdicio, en bits— causado por creer $q$ cuando la verdad es $p$:

Comprueba las tres en la cinta:

test defect rate                                = 0.0185
entropy of that coin                            = 0.1329 bits
cross-entropy of the constant predictor on test = 0.1330 bits
KL(test coin || fair coin)                      = 0.8671 bits
H + KL                                          = 1.0000 bits
cross-entropy of the p=0.5 predictor on test    = 1.0000 bits

Ahí se ven dos cosas. Primero, un modelo que se limita a informar de la tasa base de entrenamiento, 1,69 %, consigue una entropía cruzada de 0,1330 bits, casi exactamente la entropía de las etiquetas de prueba, como debe ser, ya que tiene la distribución correcta y ninguna otra información. La entropía es el suelo que te compra la ignorancia sobre el individuo. Segundo, un modelo que se encoge de hombros y dice 0,5 paga exactamente 1 bit, y la brecha entre ambos, 0,8671 bits, es precisamente la divergencia KL. $H + D_{\mathrm{KL}} = H(p,q)$ no es una identidad para memorizar; es una factura que puedes ver sumarse.

Y la conexión de vuelta con el entrenamiento: cuando la etiqueta es una única clase conocida, la distribución «verdadera» es one-hot, su entropía es cero y la entropía cruzada equivale a la divergencia KL. Minimizar la entropía cruzada y acercar la distribución del modelo a la verdad son el mismo acto.

Defectuoso no es una sola cosa. En moldeo, una pieza puede salir como un short shot (material insuficiente), flash (demasiado material, expulsado del molde) o quemada. Cuatro resultados, así que cuatro logits, y deben convertirse en cuatro probabilidades que sumen uno. Eso es softmax:

Tiene una propiedad que parece un accidente y en realidad es toda la implementación:

para cualquier constante $c$, porque $e^{z_i + c} = e^{c} e^{z_i}$ y el $e^c$ se cancelan arriba y abajo. Solo las diferencias entre logits significan algo. El nivel absoluto no es información.

Por suerte, porque el nivel absoluto es lo que rompe el ordenador:

logits            = [800. 801. 799.]
naive softmax     = [nan nan nan]
shifted by -max   = [0.2447 0.6652 0.09  ]
same softmax after adding 1000 to every logit: True

$e^{800}$ desborda un float de 64 bits, la suma se convierte en infinito, e infinito dividido por infinito es nan: no un error, no un cuelgue, solo un agujero silencioso donde antes había tres probabilidades. Restar el logit máximo no cambia nada matemáticamente y lo cambia todo numéricamente, porque el exponente mayor se vuelve exactamente $e^0 = 1$. Es el truco logsumexp del Capítulo 2 con ropa de trabajo, y toda implementación seria lo hace:

def softmax(Z):
    Z = Z - Z.max(axis=1, keepdims=True)   
    E = np.exp(Z)
    return E / E.sum(axis=1, keepdims=True)


def fit_softmax(X, Y, lr=1.0, epochs=6000):
    W, b = np.zeros((X.shape[1], Y.shape[1])), np.zeros(Y.shape[1])
    for _ in range(epochs):
        G = (softmax(X @ W + b) - Y) / len(X)   
        W -= lr * (X.T @ G)
        b -= lr * G.sum(0)
    return W, b

El gradiente vuelve a ser predicción menos verdad, ahora con $Y$ one-hot. El caso binario fue un caso especial desde el principio.

Entrenado con 3.000 piezas y probado con 1.000, con tres mediciones cada una (anchura, peso, temperatura de fusión), alcanza 94,00 % de accuracy. Esto es lo que ese número esconde:

El modelo encuentra menos de la mitad de los short shots. La accuracy no puede verlo, porque el 86 % de las piezas están bien y acertarlas basta para sostener la media. Macro F1 —la media de las puntuaciones F1 por clase, que pondera una clase rara igual que una común— es 0,7983, frente a un micro F1 de 0,9400 que, por definición, es idéntico a la accuracy. Cuando alguien comunique un único número F1, pregunta cuál.

Esto es lo último del modelado. El resto del capítulo va de los números.

Toma el modelo binario entrenado y crea dos variantes multiplicando cada logit por una constante: 0,35 para una versión dubitativa, 4 para una sobreconfiada. Multiplicar por un número positivo no puede cambiar ningún signo, así que los tres modelos predicen exactamente la misma etiqueta para las 4.000 piezas de prueba. La accuracy no puede distinguirlos. La entropía cruzada no tiene ningún problema:

El modelo dubitativo paga un pequeño impuesto por cada pieza, incluidas las miles que acierta. El sobreconfiado es casi gratis cuando acierta y catastrófico cuando falla: una pieza de ese conjunto de prueba le cuesta por sí sola 27,63 nats. Los dos llegan a casi el mismo total por rutas opuestas, y el modelo entrenado, cuyas probabilidades están calibradas con los datos, queda tres veces por debajo de ambos.

Esta es la forma más precisa de expresar la diferencia entre una pérdida y una métrica. La pérdida es lo que optimizas: debe ser diferenciable, y ve todo lo que dijo el modelo, incluida su seguridad. La métrica es aquello por lo que te juzgan: puede ser una función escalón, una regla de negocio, un recuento de defectos no detectados. No son el mismo objeto y no siempre coinciden; por eso defines ambas antes de empezar, y nunca dejas que la pérdida sustituya a la métrica solo porque esté en pantalla.

Antes de cualquier modelo, el requisito: ¿qué puntuación obtiene la respuesta más perezosa posible? En esta cinta, decir siempre que está bien:

always-say-fine baseline: accuracy = 0.9815
confusion (tn, fp, fn, tp) = (3926, 0, 74, 0)

98,15 %. Ahora el modelo logístico entrenado, con el umbral por defecto de 0,5:

logistic @0.5: accuracy=0.9830 precision=0.8000 recall=0.1081 F1=0.1905
confusion (tn, fp, fn, tp) = (3924, 2, 66, 8)

98,30 %. Ha superado al baseline por 0,15 puntos porcentuales, y cualquier informe que se detenga en la accuracy lo llamará victoria. La matriz de confusión dice lo que ocurrió en realidad:

Ha encontrado 8 piezas defectuosas de 74 y ha dejado pasar 66. Tres números nombran las tres formas de leer esa tabla:

• Precision $= \mathrm{TP}/(\mathrm{TP}+\mathrm{FP}) = 8/10 = 0.800$. De las piezas que marcó, cuántas eran realmente defectuosas. Este es el coste de las inspecciones desperdiciadas.
• Recall $= \mathrm{TP}/(\mathrm{TP}+\mathrm{FN}) = 8/74 = 0.108$. De las piezas defectuosas, cuántas capturó. Este es el coste de enviar una pieza defectuosa a un cliente.
• F1 $= 2PR/(P+R) = 0.190$, su media armónica, que se mantiene cerca de la menor de las dos y por tanto se niega a dejarse halagar por una sola.

Cuál importa depende de la fábrica, no de las matemáticas: una inspección cuesta unos segundos y un defecto enviado cuesta una notificación de retirada, así que aquí domina el recall y 0,108 es un fracaso.

Pero el problema no es el modelo. Es el umbral, y el umbral no forma parte del modelo: es una decisión de negocio aplicada después a una probabilidad. Barrámoslo:

Lee la columna de accuracy hacia abajo. Cae de principio a fin —del 98,30 % al 65,93 %— mientras el modelo pasa de detectar 8 defectos a detectar 71 de 74. Todo lo útil que puede hacer este modelo empeora su accuracy. Un equipo que optimizara el número del titular enviaría la versión que no encuentra nada.

¿Por qué tres particiones y no dos? Porque en el momento en que usas un conjunto de ejemplos para elegir algo —un umbral, una tasa de aprendizaje, cuál de seis modelos enviar— ese conjunto se ha usado para ajustar, y su puntuación deja de ser insesgada.³ Medido en esta cinta: barrer el umbral en el conjunto de validación elige 0,196, y el modelo luego obtiene F1 = 0,4122 en el conjunto de prueba intacto. Si el barrido se hubiera ejecutado directamente en el conjunto de prueba, el mejor valor alcanzable allí era 0,4186, un número que nadie tiene derecho a comunicar.

La brecha es pequeña aquí, 0,006, porque es un hiperparámetro barrido una vez contra 4.000 ejemplos de validación. Crece con cada decisión extra y con cada reducción del conjunto de validación. Observa también que la dirección no está garantizada en una ejecución concreta: el umbral elegido puntuó 0,3902 en validación y 0,4122 en prueba, así que esta vez la validación lo subestimó. El sesgo es sistemático a través de muchas decisiones, no visible en una sola.⁴

Ahora el ejercicio. El registro de la cinta llega con una tercera columna, station_seconds: cuánto tiempo pasó cada pieza en la estación de inspección. Añadirla es un cambio de una línea en el preprocesamiento. Esto es lo que hace:

El recall pasa del 10,8 % al 77,0 %. F1 se multiplica por más de cuatro. Y fíjate en lo que hizo la accuracy: 98,30 % → 99,20 %, una ganancia de nueve décimas de punto, que es el tipo de número que en una diapositiva de resumen se redondea a «aproximadamente 99 % en ambos casos». La accuracy no vio el fallo antes y ahora no ve el fraude.

Antes de seguir leyendo: el modelo está haciendo trampas. Averigua cómo.

station = 1.8 + rng.exponential(0.35, N)                     # a part just passing through
audited = rng.random(N) < 0.006                              # random spot checks
station[audited] += rng.uniform(6.0, 26.0, audited.sum())
station[y == 1] = 9.0 + rng.exponential(7.0, (y == 1).sum())  

La línea resaltada es la fuga: el tiempo de permanencia de una pieza defectuosa se extrae de una distribución distinta, porque una persona la retiró de la cinta. Este es el bug grave más común en machine learning aplicado, y tiene nombre: fuga de objetivo —información en las features de entrenamiento que no estaría disponible en el momento en que hay que hacer la predicción—.⁵ No lanza ninguna excepción. Produce un número mejor. Todos los incentivos de un proyecto apuntan a conservarla.

La defensa es una pregunta, hecha a cada columna: en el instante en que necesito esta predicción, ¿existe ya este valor? En una cinta en vivo, station_seconds se desconoce hasta después de que la pieza haya sido inspeccionada, que es lo que se suponía que el modelo debía sustituir.

Supón que puntúas un modelo con 20 ejemplos y acierta 17. Informas de un 85 %.

17 correct out of 20 -> accuracy 0.8500
  Wilson    95% CI : [0.6396, 0.9476]
  bootstrap 95% CI : [0.7000, 1.0000]
  P(a 65% model scores 17 or more out of 20) = 0.0444
  P(an 85% model scores 17 or more out of 20) = 0.6477

La lectura honesta de 17/20 es en algún lugar entre el 64 % y el 95 %. Un modelo realmente del 65 % produce este resultado el 4,4 % de las veces —una ejecución de cada veintitrés—, y si probaste un puñado de prompts y comunicaste el mejor, fabricaste tú mismo esa ejecución. Diecisiete de veinte no puede distinguir un modelo del 85 % de uno del 65 %.

Dos formas de poner un intervalo a una tasa, y ambas pertenecen a tu caja de herramientas:

def wilson(k, n, z=1.959963985):
    """95% interval for k successes in n trials. Correct at small n; no simulation."""
    ph, d = k / n, 1 + z * z / n
    centre = (ph + z * z / (2 * n)) / d
    half = z * (ph * (1 - ph) / n + z * z / (4 * n * n)) ** 0.5 / d
    return centre - half, centre + half


def bootstrap_ci(correct, n_resamples=10_000, alpha=0.05, seed=0):
    """95% interval for the mean of any per-example score array. Works on F1 too."""
    rng = np.random.default_rng(seed)
    correct = np.asarray(correct, dtype=float)
    draws = correct[rng.integers(0, len(correct), size=(n_resamples, len(correct)))]
    lo, hi = np.quantile(draws.mean(axis=1), [alpha / 2, 1 - alpha / 2])
    return float(correct.mean()), float(lo), float(hi)

Usa Wilson⁶ para una tasa de éxito simple; se comporta bien con cualquier $n$ y no necesita aleatoriedad. Observa arriba que con $n = 20$ el extremo superior del bootstrap es 1,0000: al remuestrear 20 puntos es fácil extraer 20 correctos, así que no puede representar un intervalo más estrecho que su propia granularidad. Usa el bootstrap⁷ cuando no exista fórmula, que es la mayoría de los casos interesantes: F1, macro-medias, BLEU, pass@1, la puntuación de un juez basado en rúbrica. En esta cinta, el F1 de 0,4122 del modelo ajustado lleva un intervalo bootstrap de [0,3009, 0,5156]; ese es el número que debería aparecer en el informe, porque la estimación puntual por sí sola invita a una comparación que no puede sostener.

Una medición más, porque cambia cómo deberías comparar dos modelos. Dos modelos puntuados sobre los mismos 500 ejemplos:

model A: 0.8580  95% CI [0.8260, 0.8880]
model B: 0.8120  95% CI [0.7780, 0.8460]
the two intervals overlap: True
paired difference A-B: 0.0460  95% CI [0.0260, 0.0680]
they disagree on 31 of 500 examples (A right 27, B right 4)

Sus intervalos se solapan, y la regla popular —barras de error solapadas significa que no hay diferencia significativa— llamaría inconclusa la comparación. No lo es. Los dos modelos se ejecutaron sobre los mismos ejemplos, así que la cantidad correcta es la diferencia por ejemplo, cuyo intervalo es [0.0260, 0.0680], cómodamente por encima de cero. Solo discrepan en 31 de 500 elementos, y A gana 27 de esos desacuerdos; los ejemplos compartidos, fáciles y difíciles por igual, se cancelan en lugar de añadir ruido. Compara modelos de forma pareada y llegarás a la misma conclusión con una fracción de los datos.

Ahora tienes un modelo que emite probabilidades calibradas, una pérdida derivada de una afirmación sobre los datos en lugar de elegida por comodidad, un gradiente que es literalmente predicción menos verdad y —más importante— la maquinaria para averiguar si algo de eso funciona. El intervalo de Wilson de diez líneas de arriba se reutiliza literalmente: sostiene las variantes de prompt en el Capítulo 15, las tablas de recuperación en el Capítulo 19 y el conjunto dorado en el Capítulo 29. El bootstrap es a lo que recurres cuando no existe fórmula.

Pero el modelo sigue teniendo una sola capa. Dibuja una línea, y el Capítulo 1 demostró con cuatro filas de XOR que una línea no basta. La solución es apilar: una primera capa que curva el espacio, una segunda que dibuja la línea en el espacio curvado.

Ahí es donde se agota el gradiente limpio de este capítulo. Todo lo anterior funcionó porque $\partial L/\partial s = p - y$ podía escribirse a mano, una vez, para un modelo con una capa entre la entrada y la pérdida. Pon una segunda capa en medio y la pregunta cambia de forma: ¿cuál es la derivada de la pérdida respecto a un peso que no toca la salida en absoluto, uno cuya influencia llega solo a través de otra capa, quizá por varios caminos a la vez?

Esa derivada existe. Calcularla a mano es inviable para cualquier cosa mayor que un juguete, y calcularla parámetro a parámetro es inviable a otra escala. Lo que se necesita es un procedimiento que obtenga todas las derivadas de la red a partir de una única pasada hacia atrás sobre el mismo grafo que la pasada hacia delante acaba de recorrer.

Eso es el Capítulo 5, y es el motor sobre el que corre el resto de este curso.

También merece la pena leer junto a este capítulo: Bishop, Pattern Recognition and Machine Learning §1.2, §1.5, §1.6 y §4.3, que cubre probabilidad, teoría de la decisión, teoría de la información y clasificación lineal en el orden que sigue este capítulo; Murphy, Probabilistic Machine Learning: An Introduction, capítulos 6 y 10; Prince, Understanding Deep Learning §5.4–5.7; y Saito y Rehmsmeier, The Precision-Recall Plot Is More Informative than the ROC Plot When Evaluating Binary Classifiers on Imbalanced Datasets (PLOS ONE, 2015): por qué el AUC citado arriba no debería ser el único número independiente del umbral que miras cuando el 1,7 % de las piezas son defectuosas.