Funciones de Pérdida: Midiendo Qué Tan Equivocados Estamos

¿Qué Es una Función de Pérdida?

Una función de pérdida cuantifica qué tan lejos está la predicción del modelo de la respuesta correcta. Toma la salida del modelo y el objetivo verdadero, y devuelve un único número — la pérdida — que mide la magnitud del error. Entrenar una red neuronal es, en su esencia, el proceso de minimizar esta función: ajustando los pesos para que las predicciones se acerquen cada vez más a la verdad. La elección de la función de pérdida define qué significa "más cerca" y afecta directamente lo que el modelo aprende.

Piensa en la función de pérdida como una brújula para el optimizador. Sin ella, el descenso por gradiente no tiene dirección — no sabría si un cambio en los pesos mejoró o empeoró las cosas. La pérdida proporciona esa señal: una pérdida menor significa mejores predicciones, una pérdida mayor significa peores. Cada cálculo de gradiente, cada actualización de pesos, cada época de entrenamiento está impulsada por el único objetivo de empujar la pérdida hacia abajo.

Dos propiedades clave que toda función de pérdida necesita:

• Diferenciable (al menos casi en todas partes): necesitamos gradientes para la retropropagación. Una pérdida que no podemos diferenciar es una pérdida que no podemos optimizar con descenso por gradiente. Todo el ciclo de entrenamiento depende de calcular $\frac{\partial \mathcal{L}}{\partial \theta}$ — el gradiente de la pérdida con respecto a cada parámetro. Si la función de pérdida no tiene una derivada bien definida, esta cadena se rompe.
• Acotada inferiormente : típicamente por 0, para que el optimizador sepa cuándo detenerse (o al menos cuándo la mejora adicional es marginal). Una pérdida de 0 significa predicciones perfectas — la salida del modelo coincide exactamente con el objetivo. Sin una cota inferior, el optimizador podría perseguir la pérdida hacia $-\infty$ indefinidamente, lo que significaría que la pérdida no mide realmente el error de manera significativa.

En las secciones siguientes, examinaremos las funciones de pérdida más importantes en el aprendizaje profundo: el Error Cuadrático Medio para regresión, la Entropía Cruzada para clasificación, y la Entropía Cruzada Binaria para problemas binarios. Cada una codifica una noción diferente de "qué tan equivocado" está el modelo, y elegir la correcta es una de las decisiones más importantes en el diseño de modelos.

Error Cuadrático Medio (MSE)

La función de pérdida más intuitiva es el Error Cuadrático Medio — la distancia cuadrada promedio entre las predicciones y los objetivos:

Desglosemos cada componente de esta fórmula.

$y_i$ es el valor verdadero (objetivo) para la muestra $i$. Esta es la verdad fundamental — el número que queremos que el modelo prediga. En una tarea de predicción de precios de viviendas, $y_i$ podría ser el precio de venta real de la vivienda $i$.

$\hat{y}_i$ es el valor predicho por el modelo para la muestra $i$. La notación con sombrero ($\hat{\cdot}$) es una convención estándar que significa "estimado" o "predicho." Esta es la salida del paso forward de la red.

$(y_i - \hat{y}_i)^2$ es el error cuadrado para una sola muestra. Elevar al cuadrado hace dos cosas críticas. Primero, hace que todos los errores sean positivos — una predicción que se excede por 5 y otra que se queda corta por 5 contribuyen ambas un error de 25. Sin elevar al cuadrado, los errores positivos y negativos podrían cancelarse entre sí, haciendo que el error promedio sea engañosamente pequeño. Segundo, elevar al cuadrado penaliza los errores grandes desproporcionadamente: un error de 10 contribuye 100 a la pérdida, mientras que un error de 1 contribuye solo 1. Esto significa que el modelo se concentra en corregir sus peores errores primero.

$\frac{1}{N}$ promedia los errores cuadrados sobre todo el lote de $N$ muestras. Esta normalización es importante porque hace que la pérdida sea independiente del tamaño del lote. Sin ella, un lote de 64 muestras tendría una pérdida 64 veces mayor que un lote de 1, haciendo que el ajuste de la tasa de aprendizaje dependa del tamaño del lote.

¿Por qué cuadrado y no absoluto? Una alternativa natural es el Error Absoluto Medio (MAE): $\frac{1}{N} \sum |y_i - \hat{y}_i|$. El MAE funciona perfectamente como pérdida, pero tiene un problema práctico: la función de valor absoluto $|x|$ no es diferenciable en $x = 0$. El gradiente es $-1$ para errores negativos y $+1$ para errores positivos, con un salto abrupto en cero. El MSE, por el contrario, es suave en todas partes. Su gradiente con respecto a la predicción es:

Este gradiente es proporcional al error mismo — errores grandes producen gradientes grandes, acelerando la corrección, mientras que errores pequeños producen gradientes pequeños, permitiendo un ajuste fino. Esta propiedad de auto-escalado hace que el MSE sea particularmente bien comportado para la optimización.

Usado para: tareas de regresión donde el modelo predice un valor continuo — precios de viviendas, pronósticos de temperatura, rendimientos bursátiles, posiciones de objetos en una imagen, o cualquier problema donde el objetivo es un número real en lugar de una categoría.

El gráfico a continuación muestra el paisaje de pérdida del MSE para una sola muestra con valor verdadero $y = 3.0$. A medida que la predicción $\hat{y}$ varía, la pérdida traza una parábola — suave, convexa y con un mínimo claro en $\hat{y} = 3.0$. El gradiente (rojo) pasa por cero en el mínimo y crece linealmente con la distancia al objetivo:

import numpy as np
import json
import js

# True value: y = 3.0. Plot MSE as prediction varies.
y_true = 3.0
y_pred = np.linspace(-1, 7, 200)
mse = (y_true - y_pred) ** 2
gradient = -2 * (y_true - y_pred)

plot_data = [{
    "title": "Paisaje de Pérdida MSE (objetivo = 3.0)",
    "x_label": "Predicción ŷ",
    "y_label": "Pérdida / Gradiente",
    "x_data": y_pred.tolist(),
    "lines": [
        {"label": "Pérdida MSE", "data": mse.tolist(), "color": "#3b82f6"},
        {"label": "Gradiente", "data": gradient.tolist(), "color": "#ef4444"}
    ]
}]
js.window.py_plot_data = json.dumps(plot_data)

Pérdida de Entropía Cruzada

La entropía cruzada es la función de pérdida estándar para clasificación. Mientras que el MSE mide la distancia entre números, la entropía cruzada mide qué tan bien una distribución de probabilidad predicha coincide con la distribución verdadera. Responde a una pregunta diferente: no "¿qué tan lejos está el número?" sino "¿qué tan sorprendidos deberíamos estar por la respuesta correcta, dado lo que el modelo predijo?"

Para una sola muestra donde la clase verdadera es $c$ y el modelo produce probabilidades predichas $p_1, p_2, \ldots, p_K$ (típicamente desde una capa softmax), la pérdida de entropía cruzada es notablemente simple:

Eso es todo — solo el logaritmo negativo de la probabilidad predicha para la clase correcta. Analicemos por qué esto funciona tan bien.

$p_c$ es la probabilidad predicha para la clase correcta. Este es el único término que importa — no nos interesan las probabilidades asignadas a las clases incorrectas. Si el modelo predice $[0.1, 0.7, 0.2]$ para un problema de 3 clases y la clase verdadera es 1, entonces $p_c = 0.7$. La pérdida depende enteramente de cuánta probabilidad el modelo asignó a la respuesta correcta.

$-\log$ crea la estructura de penalización. Cuando $p_c = 1$ (predicción perfecta — el modelo tiene 100% de confianza en la clase correcta), $-\log(1) = 0$: ninguna pérdida. Cuando $p_c \to 0$ (el modelo asigna probabilidad cercana a cero a la respuesta correcta — piensa que la respuesta correcta es esencialmente imposible), $-\log(p_c) \to \infty$: la pérdida explota hacia infinito. Esto crea un gradiente extremadamente fuerte cuando el modelo está equivocado con confianza, forzando una corrección rápida de los errores catastróficos.

¿Por qué $-\log$? La justificación matemática proviene de la estimación de máxima verosimilitud (MLE). Si tratamos al modelo como definiendo una distribución de probabilidad sobre las clases, la verosimilitud de observar las etiquetas verdaderas dadas las predicciones del modelo es $\prod_i p_{c_i}$. Maximizar esta verosimilitud es equivalente a minimizar la log-verosimilitud negativa: $-\sum_i \log p_{c_i}$. Esto es exactamente la entropía cruzada. Así que la pérdida de entropía cruzada no es una elección arbitraria — es la forma principiada, basada en teoría de la información, de entrenar un clasificador probabilístico.

La forma completa para un lote promedia sobre todas las $N$ muestras:

Existe una formulación equivalente usando vectores de etiquetas codificados en one-hot $\mathbf{y}_i$, donde $y_{i,k} = 1$ si $k = c_i$ (la clase correcta) y $y_{i,k} = 0$ en caso contrario:

Estas dos formas son exactamente equivalentes. Dado que $y_{i,k}$ es 0 para todas las clases excepto la correcta ($k \neq c_i$), la suma interna $\sum_{k=1}^{K} y_{i,k} \log p_{i,k}$ colapsa a solo $1 \cdot \log p_{i,c_i} = \log p_{c_i}$. Todos los términos cero desaparecen. La formulación one-hot es útil porque se generaliza naturalmente a etiquetas suaves (donde la distribución objetivo no es un vector duro 0/1), lo que aparece en técnicas como la destilación de conocimiento y el suavizado de etiquetas.

El siguiente gráfico muestra la pérdida de entropía cruzada como función de $p_c$ — la probabilidad asignada a la clase correcta. Observa el precipicio pronunciado cuando $p_c$ se acerca a 0: el modelo es severamente castigado por estar equivocado con confianza.

import numpy as np
import json
import js

# Cross-entropy as a function of predicted probability for the correct class
p_correct = np.linspace(0.01, 1.0, 200)
ce_loss = -np.log(p_correct)

plot_data = [{
    "title": "Pérdida de Entropía Cruzada vs Probabilidad Predicha",
    "x_label": "p(clase correcta)",
    "y_label": "-log(p)",
    "x_data": p_correct.tolist(),
    "lines": [
        {"label": "Pérdida de entropía cruzada", "data": ce_loss.tolist(), "color": "#8b5cf6"}
    ]
}]
js.window.py_plot_data = json.dumps(plot_data)

Hagamos esto concreto con un ejemplo paso a paso. Calcularemos la entropía cruzada para un problema de 3 clases, primero cuando el modelo acierta y luego cuando está equivocado con confianza:

import numpy as np

def cross_entropy(logits, true_class):
    # Stable computation via log-softmax
    shifted = logits - np.max(logits)
    log_sum_exp = np.log(np.sum(np.exp(shifted)))
    log_probs = shifted - log_sum_exp
    return -log_probs[true_class]

# 3-class problem. True class = 1
logits = np.array([2.0, 5.0, 1.0])  # model is fairly confident about class 1
true_class = 1

probs = np.exp(logits - np.max(logits)) / np.sum(np.exp(logits - np.max(logits)))
loss = cross_entropy(logits, true_class)

print(f"Logits:    {logits}")
print(f"Softmax:   {probs.round(4)}")
print(f"True class: {true_class} (p = {probs[true_class]:.4f})")
print(f"CE loss:   -log({probs[true_class]:.4f}) = {loss:.4f}")
print()

# What if model is wrong?
logits_wrong = np.array([5.0, 1.0, 2.0])  # confident about class 0, but truth is 1
probs_wrong = np.exp(logits_wrong - np.max(logits_wrong)) / np.sum(np.exp(logits_wrong - np.max(logits_wrong)))
loss_wrong = cross_entropy(logits_wrong, true_class)
print(f"Wrong prediction:")
print(f"Logits:    {logits_wrong}")
print(f"Softmax:   {probs_wrong.round(4)}")
print(f"True class: {true_class} (p = {probs_wrong[true_class]:.4f})")
print(f"CE loss:   -log({probs_wrong[true_class]:.4f}) = {loss_wrong:.4f}")
print(f"\nConfidently wrong → much higher loss ({loss_wrong:.2f} vs {loss:.2f})")

Entropía Cruzada Binaria (BCE)

La Entropía Cruzada Binaria es un caso especial de la entropía cruzada para problemas de dos clases (binarios). En lugar de un softmax sobre $K$ clases, el modelo produce una única probabilidad $p \in (0, 1)$ mediante la función sigmoide, representando la probabilidad de la clase positiva (clase 1). La probabilidad de la clase 0 es simplemente $1 - p$.

Analicemos cada parte de esta fórmula.

$y \in \{0, 1\}$ es la etiqueta verdadera. Es 0 (clase negativa) o 1 (clase positiva). En una tarea de detección de spam, $y = 1$ significa que el correo es spam, $y = 0$ significa que no lo es.

$p \in (0, 1)$ es la probabilidad predicha de la clase 1, producida al aplicar la función sigmoide a la salida cruda (logit) del modelo. La sigmoide comprime cualquier número real al rango $(0, 1)$, dándonos una probabilidad válida.

La fórmula tiene dos términos, y la etiqueta $y$ actúa como un interruptor que selecciona cuál está activo:

• Cuando $y = 1$: el segundo término desaparece ($(1 - 1) \log(1 - p) = 0$), dejando solo $-\log p$. Esto penaliza una probabilidad predicha baja $p$ — si la etiqueta verdadera es positiva pero el modelo predice $p = 0.01$, la pérdida es $-\log(0.01) = 4.6$, que es muy alta.
• Cuando $y = 0$: el primer término desaparece ($0 \cdot \log p = 0$), dejando solo $-\log(1 - p)$. Esto penaliza una probabilidad predicha alta $p$ — si la etiqueta verdadera es negativa pero el modelo predice $p = 0.99$, la pérdida es $-\log(1 - 0.99) = -\log(0.01) = 4.6$. Simétricamente duro para predicciones equivocadas con confianza en cualquier dirección.

Puedes verificar que BCE es un caso especial de la entropía cruzada general. En un problema de 2 clases con probabilidades $[1 - p, p]$ y etiqueta one-hot $[1 - y, y]$, la entropía cruzada $-\sum_k y_k \log p_k$ se expande a $-(1 - y)\log(1 - p) - y \log p$, que es exactamente la fórmula de BCE.

BCE aparece en todo el aprendizaje profundo moderno más allá de la clasificación binaria simple. Si has leído el track de VLMs, la reconocerás en SigLIP , donde cada par imagen-texto se trata como una clasificación binaria independiente: "¿esta imagen coincide con este texto?" Cada par obtiene su propia probabilidad sigmoide y su propia pérdida BCE. Esto permite a SigLIP evitar la normalización softmax global de la pérdida contrastiva de CLIP, haciéndolo más escalable y eficiente.

MSE vs Entropía Cruzada: Cuándo Usar Cuál

Un error común de principiante es usar MSE para clasificación. Funciona en un sentido técnico — puedes calcular $(p - y)^2$ y diferenciarlo — pero la entropía cruzada es casi siempre la mejor opción para clasificación. Veamos por qué.

1. Fuerza del gradiente para errores confiados. Considera un modelo que predice $p \approx 0$ cuando la etiqueta verdadera es $y = 1$ — está equivocado con confianza. Con MSE, el gradiente es $\frac{\partial}{\partial p}(p - 1)^2 = 2(p - 1) \approx -2$. Eso es un gradiente fijo y acotado de magnitud 2, sin importar qué tan equivocado esté el modelo. Con entropía cruzada, la pérdida es $-\log(p)$, que se aproxima a infinito cuando $p \to 0$. El gradiente $-1/p$ también crece sin límite. Esto significa que la entropía cruzada crea una señal de aprendizaje enormemente fuerte para predicciones equivocadas con confianza, mientras que MSE solo da un empujón suave. En la práctica, esto se traduce en convergencia más rápida y mejor precisión final para tareas de clasificación.

2. Interpretación probabilística. La entropía cruzada optimiza directamente la distribución de probabilidad predicha — proviene de la estimación de máxima verosimilitud y tiene una base rigurosa en teoría de la información. MSE trata las probabilidades como valores continuos hacia los cuales hacer regresión, ignorando el hecho de que deben sumar 1 y vivir en un simplex de probabilidad. Usar MSE para probabilidades es como medir la distancia entre dos puntos en una esfera usando una línea recta a través del interior — funciona, pero no respeta la geometría del espacio.

3. El gradiente softmax-entropía cruzada. Cuando la entropía cruzada se combina con una capa de salida softmax (lo cual es casi siempre el caso en clasificación), el gradiente se simplifica a $p_i - y_i$ — la probabilidad predicha menos la etiqueta verdadera. Esto es limpio, numéricamente estable y escala naturalmente. MSE combinado con softmax produce un gradiente más complicado que involucra factores adicionales de $p_i(1 - p_i)$, que se aproximan a 0 cuando el modelo está confiado, suprimiendo aún más el gradiente precisamente cuando más se necesita.

La regla práctica general es directa:

• Regresión (objetivos continuos como precios, temperaturas, posiciones) → MSE . O pérdida de Huber si necesitas robustez ante valores atípicos — Huber se comporta como MSE para errores pequeños y como MAE para errores grandes, limitando la penalización para valores atípicos extremos.
• Clasificación multiclase (categorías discretas como clases de ImageNet, predicción del siguiente token) → Entropía cruzada con softmax.
• Clasificación binaria (dos clases: spam/no spam, coincide/no coincide) → BCE con sigmoide.

Quiz

Pon a prueba tu comprensión de las funciones de pérdida y cuándo usar cada una.