Logaritmos para IA: evita que desaparezcan los productos de probabilidad diminutos

En un ejemplo simplificado de puntuación de secuencias, un modelo de lenguaje pequeño asigna una probabilidad de $0.1$ a cada token elegido. Una secuencia con 400 elecciones de este tipo tiene el producto matemáticamente distinto de cero

Añade un token más con la misma probabilidad y el producto es $10^{-401}$. Son dos números positivos distintos, pero NumPy almacena ambos productos como 0.0 al calcularlos con números de coma flotante de 64 bits. Una clasificación basada en los productos almacenados ha perdido la diferencia.

Los logaritmos conservan una representación más útil: los dos productos se convierten en las sumas finitas $400\ln(0.1)\approx-921.034037$ y $401\ln(0.1)\approx-923.336622$. Al terminar esta lección podrás leer un logaritmo como una potencia inversa, derivar las leyes que convierten productos en sumas, calcular a mano la puntuación de una secuencia corta e implementar la misma idea sin fingir que el espacio logarítmico elimina todos los límites numéricos.

Esta lección invierte la operación de exponenciación desarrollada en Lección 7: Potencias para IA, que es la página localizada correspondiente del Translation Set de cuatro idiomas del curso. El Mathematics for Machine Learning companion oficial divide su recorrido entre los fundamentos matemáticos y los problemas de aprendizaje automático que los utilizan. Su capítulo introductorio motiva construir fundamentos antes de apoyarse en modelos probabilísticos; las matemáticas de logaritmos que siguen son un puente original hacia la probabilidad, no una definición atribuida al capítulo 1.

La respuesta que falta es un exponente

Un logaritmo plantea una pregunta precisa: ¿qué exponente produce este número positivo a partir de la base elegida?

Por ejemplo, $\log_2(8)=3$ porque $2^3=8$, mientras que $\log_{10}(0.01)=-2$ porque $10^{-2}=0.01$. La respuesta negativa es un exponente, no una entrada negativa.

En computación aparecen a menudo tres bases:

Algunos campos escriben log sin base, pero la convención no es universal. En esta lección escribimos $\ln$ para el logaritmo natural e incluimos un subíndice para las demás bases. NumPy sigue la misma elección práctica: numpy.log calcula el logaritmo natural elemento por elemento.

La relación inversa proporciona dos comprobaciones cuando ambas expresiones están en sus dominios reales:

La multiplicación deja un rastro aditivo

La ley del producto no es un patrón que haya que memorizar de forma aislada. Se deduce directamente de la ley de los exponentes de la lección 7.

Toma números positivos $a$ y $c$, y usa una base de logaritmo válida $b>0$, $b\ne1$. Sea

La definición dice que $a=b^u$ y $c=b^v$. Al multiplicar y aplicar la ley de exponentes de la misma base obtenemos

Por tanto, el exponente que produce $ac$ es $u+v$:

La división resta exponentes bajo los mismos supuestos:

Elevar un número positivo a una potencia real $r$ multiplica su exponente:

La positividad es esencial en las tres leyes: $a>0$ y $c>0$ mantienen definidos todos los logaritmos reales, y $c>0$ también mantiene distinto de cero el denominador del cociente.

La suma no sigue la ley del producto. Como contraejemplo rápido,

pero

Por tanto, en general $\log(a+c)\ne\log(a)+\log(c)$. Más adelante se presenta una operación estable para sumar valores que ya están almacenados como logaritmos, deliberadamente distinta de la conversión de producto a suma.

Cuatro elecciones de tokens, resueltas en ambas representaciones

Supón que dos continuaciones candidatas contienen cuatro elecciones de tokens cada una. Para este cálculo pequeño, considera cada $p_i$ indicado como la probabilidad condicional positiva del modelo para el token elegido en la posición $i$. Multiplicar los cuatro factores produce una puntuación de secuencia; sumar sus logaritmos naturales produce la log-probabilidad correspondiente. Para una secuencia observada fija bajo el modelo, estas puntuaciones también se llaman su verosimilitud y log-verosimilitud. Las lecciones posteriores desarrollarán toda la maquinaria de probabilidad y estimación; aquí solo hay que calcular y comparar las dos representaciones.

El producto de la candidata A es el doble que el de la candidata B. Su puntuación logarítmica también es mayor: $-7.824046>-8.517193$. Ese orden está garantizado porque $\ln$ tiene base $e>1$ y es estrictamente creciente. “Mayor” entre puntuaciones logarítmicas negativas significa más cerca de cero. La puntuación no se convirtió en una probabilidad después del logaritmo; se convirtió en una representación de esta que facilita la comparación.

Binary64 llega a cero mientras la puntuación logarítmica sigue cambiando

Los ordenadores no pueden almacenar todos los números reales. Number de JavaScript y float64 de NumPy usan el formato de coma flotante binary64. NumPy informa de sus límites de máquina mediante numpy.finfo: el valor float64 normal positivo más pequeño es aproximadamente $2.2250738585072014\times10^{-308}$. Los valores subnormales positivos llenan parte de la brecha entre ese número y cero, pero con menor precisión; el subnormal positivo más pequeño es aproximadamente $4.9406564584124654\times10^{-324}$. numpy.nextafter confirma que este es el siguiente flotante representable después de cero en la dirección positiva.

Mueve cualquiera de los controles deslizantes con el puntero o las flechas. El panel superior sigue la multiplicación binary64 directa por la región normal, la estrecha franja subnormal y el cero. El panel inferior sigue el valor aditivo finito $n\ln(p)$. La línea continua con un círculo y la discontinua con un cuadrado siguen siendo distinguibles sin color, y la tabla muestra el estado seleccionado y las filas de transición.

En el estado inicial renderizado por el servidor, $p=0.10$ y $n=400$. La multiplicación directa ya ha producido cero, pero $400\ln(0.10)=-921.034037\ldots$ es finita. El valor logarítmico conserva una puntuación aditiva para los factores positivos. Llamar a $\exp(-921.034037\ldots)$ en float64 sigue devolviendo cero, porque cambiar la representación no puede crear un valor float64 positivo por debajo del rango del formato.

La transición exacta depende del tipo de datos, los valores y el orden de las operaciones de coma flotante. El explorador modela deliberadamente la multiplicación binary64 repetida; no es un umbral universal para todos los programas de probabilidad.

NumPy refleja la ruta segura

El siguiente programa se ejecutó con NumPy 2.5.2. La multiplicación directa usa np.prod, mientras que la acumulación en el espacio logarítmico usa el logaritmo natural elemento a elemento documentado por numpy.log, seguido de una suma.

import numpy as np

for n in (323, 324, 400, 401):
    factors = np.full(n, 0.1, dtype=np.float64)
    direct = np.prod(factors)
    log_score = np.log(factors).sum()
    print(f"n={n}: direct={direct:.4e}, log_score={log_score:.6f}")

limits = np.finfo(np.float64)
print(f"smallest normal:    {limits.smallest_normal:.4e}")
print(f"smallest subnormal: {limits.smallest_subnormal:.4e}")
print(f"next after zero:    {np.nextafter(0.0, 1.0):.4e}")

n=323: direct=9.8813e-324, log_score=-743.734985
n=324: direct=0.0000e+00, log_score=-746.037570
n=400: direct=0.0000e+00, log_score=-921.034037
n=401: direct=0.0000e+00, log_score=-923.336622
smallest normal:    2.2251e-308
smallest subnormal: 4.9407e-324
next after zero:    4.9407e-324

Los productos de 400 y 401 factores coinciden en cero al almacenarse, mientras sus puntuaciones logarítmicas mantienen el orden. En la práctica, un sistema que necesite comparar productos candidatos puede conservar las puntuaciones logarítmicas y elegir la mayor sin exponenciar cada puntuación. Este es el beneficio numérico concreto: los factores multiplicativos positivos se convierten en puntuaciones aditivas finitas. No repara entradas inválidas, redondeos de otras operaciones ni una conversión final cuyo resultado sea demasiado pequeño para el tipo elegido.

Sumar probabilidades alternativas requiere otra identidad. Si $x=\ln(a)$ y $y=\ln(c)$, entonces

no $x+y$. La función de NumPy numpy.logaddexp calcula directamente ese logaritmo de una suma. Para dos alternativas ya logaritmadas, $x=-1000$ y $y=-1001$:

x, y = -1000.0, -1001.0

with np.errstate(divide="ignore"):
    naive = np.log(np.exp(x) + np.exp(y))

stable = np.logaddexp(x, y)
print(naive)
print(stable)
print(np.exp(stable))

-inf
-999.6867383124818
0.0

La ruta ingenua exponencia demasiado pronto y convierte ambas alternativas en cero. np.logaddexp conserva su puntuación logarítmica combinada finita. Exponenciar esa puntuación aún produce underflow, exactamente como muestra la última línea. Usa sum(log_factors) para un producto de factores positivos; usa logaddexp al sumar alternativas que ya están representadas por valores logarítmicos.

Límites que conviene hacer explícitos

El dominio y las condiciones de base del logaritmo real evitan varios errores comunes:

Para arrays de valores reales, NumPy sigue las convenciones de coma flotante en torno a este límite: np.log(0.0) devuelve -inf y señala una división por cero, mientras que np.log(-1.0) devuelve nan y señala una operación no válida. Son valores de máquina útiles, no permiso para borrar la distinción matemática. Un factor cuya probabilidad es realmente cero aporta $-\infty$ a la puntuación logarítmica; un producto positivo que se redondeó a cero de coma flotante debería haberse pasado a logaritmo antes de multiplicar. Una vez que el producto ya es cero, np.log(product) no puede reconstruir los factores perdidos.

Sustituir ceros silenciosamente por una constante positiva pequeña también cambia los valores declarados por el modelo. Si el recorte es una decisión de modelado intencional, registra la regla en lugar de presentarlo como aritmética exacta.

Por último, la dirección de la clasificación depende de la base. Para toda base $b>1$ —incluidas $e$, $2$ y $10$— el logaritmo es creciente, de modo que el producto positivo mayor tiene el valor logarítmico mayor. Una base válida entre cero y uno produce un logaritmo decreciente e invierte ese orden. Las implementaciones de log-probabilidad suelen usar $e>1$; por eso la puntuación logarítmica menos negativa ocupa una posición superior.

Una puntuación finita puede ser el resultado útil

Las secuencias iniciales no necesitaron convertir sus probabilidades microscópicas de nuevo a forma decimal para seguir siendo distinguibles. Sus puntuaciones logarítmicas conservaron la comparación multiplicativa como una suma ordinaria, y las leyes de producto, cociente y potencia explican por qué funciona esa representación.

Esta base sustentará lecciones posteriores sobre probabilidad, estimación basada en verosimilitud, entropía y cálculos estables de modelos. El siguiente paso del currículo cambia el foco a las ecuaciones como restricciones y a los conjuntos de valores que las satisfacen. Por ahora, el punto práctico de parada es exacto: mantén los factores positivos en el espacio logarítmico al combinarlos y compararlos, y vuelve al espacio de probabilidades solo cuando el resultado sea necesario y representable.

Comprueba tu comprensión

combined = np.logaddexp(-1000.0, -1001.0)
# -999.6867383124818