Funciones de pérdida: MSE, Cross-Entropy y cuándo usar cada una

Introducción

Cuando empezamos con Machine Learning, aprendemos que el Error Cuadrático Medio (MSE) es la función de pérdida por defecto para problemas de regresión.

Pero en cuanto queremos predecir categorías (¿es spam o no es spam? ¿qué número es este dígito?) el MSE deja de ser la herramienta adecuada.

Aparece entonces la Cross-Entropy (entropía cruzada), que es la función de pérdida estándar para clasificación.

En este post vamos a entender:

1. qué es una función de pérdida y para qué sirve,
2. por qué el MSE no funciona bien en clasificación,
3. qué es la Cross-Entropy y por qué sí funciona,
4. qué otras funciones de pérdida existen y cuándo conviene cada una.

---

1. ¿Qué es una función de pérdida?

Una función de pérdida (loss function) es una función matemática que mide qué tan mal está haciendo su trabajo el modelo.

Dado un valor real y una predicción, la función de pérdida devuelve un número:

• número bajo → el modelo se equivocó poco,
• número alto → el modelo se equivocó mucho.

El entrenamiento de un modelo consiste, fundamentalmente, en:

ajustar los parámetros del modelo para minimizar la función de pérdida.

El algoritmo que hace ese ajuste se llama gradiente descendente, y necesita que la función de pérdida sea derivable para poder calcular en qué dirección mover los parámetros.

Si querés entender cómo funciona el gradiente descendente con derivadas, podés leer: Derivadas del Error Cuadrático Medio

---

2. Regresión vs. clasificación: el problema de fondo

Antes de hablar de funciones de pérdida, hay que entender el tipo de problema.

Regresión

Predecir un valor continuo.

Ejemplos:

• precio de una casa (120.000, 250.000, 87.500…),
• temperatura del día siguiente,
• consumo eléctrico de una fábrica.

La salida del modelo puede ser cualquier número real.

Clasificación

Predecir a qué categoría pertenece algo.

Ejemplos:

• ¿este email es spam o no spam? (0 o 1)
• ¿este figura es cuadrada o no? (0 o 1)
• ¿qué dígito es este? (0, 1, 2… 9)

La salida del modelo es una probabilidad entre 0 y 1 (o un vector de probabilidades).

---

3. ¿Por qué el MSE no funciona bien en clasificación?

El MSE funciona perfecto para regresión porque los errores crecen de forma suave y simétrica.

Pero en clasificación el problema es diferente.

El modelo de clasificación trabaja con probabilidades

En regresión logística, la salida del modelo no es directamente 0 o 1. Es una probabilidad: por ejemplo, 0.87 (87% de probabilidad de que sea spam).

Esa probabilidad viene de la función sigmoide:

$\hat{y} = \sigma(z) = \frac{1}{1 + e^{-z}}$

La sigmoide aplana los valores: siempre devuelve algo entre 0 y 1.

El MSE genera gradientes muy pequeños con la sigmoide

Cuando la sigmoide está muy cerca de 0 o de 1 (lo cual pasa cuando el modelo está seguro de su predicción, aunque esté equivocado), su derivada se vuelve casi cero.

Eso hace que los gradientes del MSE también se vuelvan casi cero, y el entrenamiento avanza muy lento o directamente se estanca.

A ese fenómeno se le llama vanishing gradient (gradiente que desaparece).

El MSE no penaliza bien las predicciones muy equivocadas

Si el modelo predice ŷ = 0.001 cuando el valor real es y = 1, eso es un error gravísimo.

Con MSE:

$\text{MSE} = (1 - 0.001)^2 = 0.998^2 \approx 0.996$

No está mal. Pero con Cross-Entropy:

$\text{CE} = -\log(0.001) \approx 6.9$

El error es mucho más grande, lo que fuerza al modelo a corregirse más agresivamente.

Esa penalización más fuerte hace que el entrenamiento sea más efectivo.

---

4. ¿Qué es la Cross-Entropy?

La Cross-Entropy (entropía cruzada) es una función que mide la diferencia entre dos distribuciones de probabilidad:

• la distribución real (los valores verdaderos),
• la distribución predicha (lo que dijo el modelo).

Para clasificación binaria (dos clases: 0 y 1)

La fórmula es:

$\mathcal{L} = -\frac{1}{n} \sum_{i=1}^{n} \left[ y_i \cdot \log(\hat{y}_i) + (1 - y_i) \cdot \log(1 - \hat{y}_i) \right]$

Donde:

• $y_i$ = valor real (0 o 1),
• $\hat{y}_i$ = probabilidad predicha por el modelo (entre 0 y 1),
• $\log$ = logaritmo natural.

¿Cómo se lee esa fórmula?

La fórmula tiene dos términos dentro del corchete:

$-\left[\underbrace{y_i \cdot \log(\hat{y}_i)}_{\text{término A}} + \underbrace{(1-y_i) \cdot \log(1-\hat{y}_i)}_{\text{término B}}\right]$

Según el valor real, uno de los dos términos siempre vale cero y desaparece, dejando solo el otro.

Caso 1: el valor real es y = 1

• Término A: $y_i \cdot \log(\hat{y}_i) = 1 \cdot \log(\hat{y}_i) = \log(\hat{y}_i)$ → sobrevive
• Término B: $(1 - y_i) \cdot \log(1 - \hat{y}_i) = 0 \cdot \log(\ldots) = 0$ → desaparece

Resultado: $-[\log(\hat{y}_i) + 0] = -\log(\hat{y}_i)$

El $-\log(\hat{y}_i)$ es el término A simplificado (con $y_i = 1$ multiplicando, que no cambia nada).

• Si el modelo predice ŷ = 0.99 (muy seguro, correcto): $-\log(0.99) \approx 0.01$ → pérdida baja ✓
• Si el modelo predice ŷ = 0.01 (muy seguro, equivocado): $-\log(0.01) \approx 4.6$ → pérdida alta ✓

Caso 2: el valor real es y = 0

• Término A: $y_i \cdot \log(\hat{y}_i) = 0 \cdot \log(\hat{y}_i) = 0$ → desaparece
• Término B: $(1 - y_i) \cdot \log(1 - \hat{y}_i) = 1 \cdot \log(1 - \hat{y}_i) = \log(1 - \hat{y}_i)$ → sobrevive

Resultado: $-[0 + \log(1 - \hat{y}_i)] = -\log(1 - \hat{y}_i)$

• Si el modelo predice ŷ = 0.01 (muy seguro, correcto): $-\log(1 - 0.01) = -\log(0.99) \approx 0.01$ → pérdida baja ✓
• Si el modelo predice ŷ = 0.99 (muy seguro, equivocado): $-\log(1 - 0.99) = -\log(0.01) \approx 4.6$ → pérdida alta ✓

La idea intuitiva

La Cross-Entropy penaliza muy fuerte al modelo cuando dice estar seguro y se equivoca. Y casi no lo penaliza cuando acierta con alta confianza.

Eso la hace perfecta para entrenar clasificadores.

---

5. Ejemplo numérico paso a paso

Tenemos 4 ejemplos, y el modelo dio estas probabilidades:

Ejemplo	Real y	Predicción ŷ	Interpretación
1	1	0.90	Acertó con confianza
2	1	0.10	Se equivocó con confianza
3	0	0.05	Acertó con confianza
4	0	0.80	Se equivocó con confianza

Cálculo de la pérdida por ejemplo:

• Ejemplo 1: $-[1 \cdot \log(0.90) + 0 \cdot \log(0.10)] = -\log(0.90) \approx 0.105$
• Ejemplo 2: $-[1 \cdot \log(0.10) + 0 \cdot \log(0.90)] = -\log(0.10) \approx 2.303$
• Ejemplo 3: $-[0 \cdot \log(0.05) + 1 \cdot \log(0.95)] = -\log(0.95) \approx 0.051$
• Ejemplo 4: $-[0 \cdot \log(0.80) + 1 \cdot \log(0.20)] = -\log(0.20) \approx 1.609$

Cross-Entropy total:

$\mathcal{L} = \frac{0.105 + 2.303 + 0.051 + 1.609}{4} \approx 1.017$

Los ejemplos 2 y 4 (donde el modelo estaba seguro y se equivocó) dominaron la pérdida. Eso es exactamente lo que queremos.

---

6. Implementación en Python

import numpy as np

# Valores reales
y_real = np.array([1, 1, 0, 0])

# Probabilidades predichas por el modelo
y_pred = np.array([0.90, 0.10, 0.05, 0.80])

# Cross-Entropy manual
# Clip para evitar log(0) que sería infinito
y_pred_clip = np.clip(y_pred, 1e-15, 1 - 1e-15)

perdidas = -(y_real * np.log(y_pred_clip) + (1 - y_real) * np.log(1 - y_pred_clip))

print("Pérdida por ejemplo:")
for i, (yr, yp, p) in enumerate(zip(y_real, y_pred, perdidas)):
    print(f"  Ejemplo {i+1}: real={yr}, pred={yp:.2f} → pérdida={p:.4f}")

print(f"\nCross-Entropy total: {perdidas.mean():.4f}")

Resultado:

Pérdida por ejemplo:
  Ejemplo 1: real=1, pred=0.90 → pérdida=0.1054
  Ejemplo 2: real=1, pred=0.10 → pérdida=2.3026
  Ejemplo 3: real=0, pred=0.05 → pérdida=0.0513
  Ejemplo 4: real=0, pred=0.80 → pérdida=1.6094

Cross-Entropy total: 1.0172

Con sklearn

from sklearn.metrics import log_loss

y_real = [1, 1, 0, 0]
y_pred = [0.90, 0.10, 0.05, 0.80]

print(f"Cross-Entropy (log_loss): {log_loss(y_real, y_pred):.4f}")

---

7. ¿Por qué Cross-Entropy funciona mejor que MSE para gradiente descendente?

La derivada de la Cross-Entropy con respecto a los parámetros del modelo, cuando se combina con la función sigmoide, simplifica a:

$\frac{\partial \mathcal{L}}{\partial w} = \frac{1}{n} \sum X \cdot (\hat{y} - y)$

Esa derivada no depende de la derivada de la sigmoide.

Eso significa que los gradientes no se aplastan, el entrenamiento no se estanca, y el modelo converge de manera mucho más eficiente.

Esa es la razón matemática profunda por la que se eligió Cross-Entropy para clasificación: no es arbitrario, es la consecuencia natural de combinar la sigmoide con el logaritmo.

---

8. Otras funciones de pérdida importantes

El MSE y la Cross-Entropy son las más conocidas, pero hay otras que vale la pena conocer desde el principio.

Categorical Cross-Entropy (para múltiples clases)

Cuando hay más de dos categorías (por ejemplo, clasificar dígitos del 0 al 9), usamos la versión multiclase:

$\mathcal{L} = -\sum_{c=1}^{C} y_c \cdot \log(\hat{y}_c)$

Donde:

• $C$ = número de clases,
• $y_c$ = 1 si la clase correcta es $c$, 0 en otro caso (one-hot encoding),
• $\hat{y}_c$ = probabilidad predicha para la clase $c$ (salida de softmax).

Se usa junto con la función softmax, que convierte un vector de valores en probabilidades que suman 1.

import numpy as np

# Clase real: dígito "2" → one-hot [0, 0, 1, 0, ..., 0]
y_real = np.array([0, 0, 1, 0, 0, 0, 0, 0, 0, 0])

# Probabilidades predichas por la red (salida de softmax)
y_pred = np.array([0.02, 0.01, 0.85, 0.03, 0.01, 0.02, 0.01, 0.02, 0.02, 0.01])

# Categorical Cross-Entropy
loss = -np.sum(y_real * np.log(np.clip(y_pred, 1e-15, 1)))
print(f"Categorical Cross-Entropy: {loss:.4f}")
# → solo penaliza la clase correcta (índice 2): -log(0.85) ≈ 0.1625

MAE — Mean Absolute Error (Error Absoluto Medio)

$\text{MAE} = \frac{1}{n} \sum |y_i - \hat{y}_i|$

Parecido al MSE pero sin elevar al cuadrado.

Característica	MSE	MAE
Sensible a outliers	Mucho	Poco
Derivada en 0	Sí	No (no derivable en 0)
Penaliza errores grandes	Mucho más	Proporcionalmente

Cuándo usarlo: cuando los datos tienen outliers importantes y no querés que dominen el entrenamiento.

Huber Loss

Una combinación de MSE y MAE:

$\mathcal{L}_\delta(y, \hat{y}) = \begin{cases} \frac{1}{2}(y - \hat{y})^2 & \text{si } |y - \hat{y}| \leq \delta \\ \delta \cdot |y - \hat{y}| - \frac{1}{2}\delta^2 & \text{si } |y - \hat{y}| > \delta \end{cases}$

• Para errores pequeños: se comporta como MSE (suave, derivable).
• Para errores grandes: se comporta como MAE (menos sensible a outliers).

Es la función de pérdida más robusta para regresión cuando hay outliers.

import numpy as np

def huber_loss(y_real, y_pred, delta=1.0):
    error = np.abs(y_real - y_pred)
    return np.where(
        error <= delta,
        0.5 * error**2,
        delta * error - 0.5 * delta**2
    ).mean()

y_real = np.array([100, 200, 300, 400, 1000])  # el 1000 es un outlier
y_pred = np.array([105, 195, 310, 390, 410])

print(f"MSE:        {((y_real - y_pred)**2).mean():.2f}")
print(f"MAE:        {np.abs(y_real - y_pred).mean():.2f}")
print(f"Huber(δ=1): {huber_loss(y_real, y_pred):.2f}")

KL Divergence (Kullback-Leibler)

$D_{KL}(P \| Q) = \sum P(x) \cdot \log\frac{P(x)}{Q(x)}$

Mide cuánto se aleja una distribución de probabilidad predicha ($Q$) de la real ($P$).

Aparece en modelos más avanzados. No es necesaria para empezar, pero es bueno saber que existe y que mide cuánto se diferencia una distribución predicha de la real.

---

9. Mapa de cuándo usar cada función de pérdida

Problema	Función de pérdida
Regresión simple	MSE
Regresión robusta (con outliers)	MAE o Huber Loss
Clasificación binaria (2 clases)	Binary Cross-Entropy
Clasificación multiclase	Categorical Cross-Entropy
Modelos avanzados	KL Divergence

---

10. Resumen visual

¿Qué tipo de problema tenés?
        │
        ├── Regresión (valor continuo)
        │       ├── Sin outliers → MSE
        │       └── Con outliers → MAE o Huber
        │
        └── Clasificación (categorías)
                ├── 2 clases → Binary Cross-Entropy
                └── Más de 2 clases → Categorical Cross-Entropy

---

Conclusión

Las funciones de pérdida no son intercambiables. Cada una está diseñada para un tipo de problema específico.

Los puntos clave para recordar:

1. MSE es ideal para regresión, pero no sirve para clasificación porque los gradientes se aplanan con la sigmoide.
2. Cross-Entropy es la función natural para clasificación: penaliza fuerte las predicciones equivocadas con alta confianza y genera gradientes limpios.
3. Huber Loss es una alternativa robusta al MSE cuando hay outliers.
4. Categorical Cross-Entropy es la extensión de Cross-Entropy para múltiples clases, usada cuando hay más de dos categorías posibles.
5. Elegir bien la función de pérdida es tan importante como elegir el algoritmo: de ella depende que el modelo aprenda correctamente.

Elegir mal la función de pérdida puede hacer que un modelo con buena arquitectura entrene mal o directamente no converja.

---

Frase final

El MSE le dice al modelo “cuánto te equivocaste”. La Cross-Entropy le dice “qué tan seguro estabas cuando te equivocaste”. Para clasificación, esa segunda pregunta es la que importa.