Pérdidas, métricas y formulación del entrenamiento de redes neuronales

Entrenamiento como minimización de una función de pérdida

Entrenar una red neuronal consiste en ajustar sus parámetros (pesos y sesgos) para que sus predicciones se parezcan lo más posible a los valores reales. Esto se formula como un problema de optimización: encontrar los parámetros θ que minimizan una función de pérdida (loss) sobre un conjunto de datos.

De forma general, si tu modelo produce una predicción ŷ = f(x; θ), y el valor real es y, defines una pérdida por ejemplo ℓ(y, ŷ). Para un dataset de N ejemplos, la pérdida empírica típica es:

L(θ) = (1/N) * Σᵢ ℓ(yᵢ, f(xᵢ; θ))

El objetivo del entrenamiento es minimizar L(θ). En la práctica, se usa descenso por gradiente (y variantes) con mini-batches: se estima el gradiente con un subconjunto de datos y se actualiza θ iterativamente.

Guía práctica paso a paso: cómo plantear el entrenamiento

• 1) Define la tarea y el tipo de salida: regresión (salida continua), clasificación binaria (probabilidad de clase positiva), clasificación multiclase (distribución de probabilidad sobre clases).
• 2) Elige una pérdida coherente con la salida: MSE para regresión; entropía cruzada binaria para binaria; entropía cruzada categórica para multiclase.
• 3) Decide métricas de evaluación: no siempre coinciden con la pérdida (por ejemplo, puedes optimizar entropía cruzada y reportar F1).
• 4) (Opcional) Añade regularización: L2 o L1 como término adicional en la pérdida para controlar complejidad.
• 5) Entrena con mini-batches: calcula pérdida en el batch, retropropaga gradientes, actualiza parámetros, repite por épocas.
• 6) Valida: monitoriza pérdida y métricas en un conjunto de validación para detectar sobreajuste y ajustar hiperparámetros.

Pérdidas típicas y su interpretación intuitiva

Error cuadrático medio (MSE) para regresión

En regresión, el objetivo es aproximar un valor real. Una pérdida clásica es el error cuadrático medio:

ℓ(y, ŷ) = (y - ŷ)²

Y en promedio sobre el dataset:

Continúa en nuestra aplicación.

• Escuche el audio con la pantalla apagada.
• Obtenga un certificado al finalizar.
• ¡Más de 5000 cursos para que explores!

O continúa leyendo más abajo...

Descargar la aplicación

MSE = (1/N) * Σᵢ (yᵢ - ŷᵢ)²

Intuición: penaliza más los errores grandes (por el cuadrado). Esto suele producir modelos que “prefieren” evitar grandes desviaciones, incluso si eso implica pequeños errores en muchos puntos.

Interpretación probabilística (intuitiva): si asumes que el valor real y es la predicción ŷ más ruido gaussiano (normal) con varianza constante, minimizar MSE equivale (a grandes rasgos) a maximizar la probabilidad de los datos bajo ese supuesto. En otras palabras, MSE encaja bien cuando el ruido se parece a una campana normal y los outliers no dominan.

Ejemplo: si predices precios y te equivocas en 1000€ en un caso y 100€ en otro, el error de 1000€ pesa 100 veces más que el de 100€ en MSE (porque 1000² / 100² = 100).

Entropía cruzada binaria (Binary Cross-Entropy) para clasificación binaria

En clasificación binaria, el modelo suele producir una probabilidad p de pertenecer a la clase positiva (por ejemplo, “fraude” = 1). Con etiqueta y ∈ {0,1}, la pérdida por ejemplo es:

ℓ(y, p) = -[ y * log(p) + (1 - y) * log(1 - p) ]

Intuición: castiga con fuerza cuando el modelo está muy seguro y se equivoca. Por ejemplo, si y=1 pero p es muy pequeño, log(p) es un número muy negativo y la pérdida se dispara.

Interpretación probabilística (intuitiva): esta pérdida corresponde al negativo del logaritmo de la verosimilitud de una variable Bernoulli. Minimizarla equivale a maximizar la probabilidad asignada a las etiquetas correctas. Por eso se dice que “entrena probabilidades”: empuja al modelo a asignar alta probabilidad a la clase verdadera.

Detalle práctico importante: en implementaciones, se suele usar una versión numéricamente estable que combina la función de salida (logits) con la pérdida (por ejemplo, BCEWithLogitsLoss en PyTorch) para evitar problemas con log(0).

Entropía cruzada multiclase (Categorical Cross-Entropy) para clasificación multiclase

En multiclase con K clases, el modelo produce un vector de probabilidades p (una distribución) donde p_k es la probabilidad asignada a la clase k. Si la clase correcta es c, la pérdida típica es:

ℓ(y, p) = -log(p_c)

Si representas y como one-hot, también puede escribirse como:

ℓ(y, p) = - Σ_k y_k * log(p_k)

Intuición: solo “mira” la probabilidad asignada a la clase correcta y la quiere cercana a 1. Si el modelo asigna p_c = 0.9, la pérdida es baja; si asigna p_c = 0.01, la pérdida es alta.

Interpretación probabilística (intuitiva): equivale al negativo del log-likelihood de una distribución categórica (multinomial de un solo intento). Minimizarla maximiza la probabilidad asignada a la clase verdadera.

Detalle práctico importante: igual que en binaria, se suele usar una versión estable que recibe logits (por ejemplo, CrossEntropyLoss en PyTorch, que internamente aplica softmax + log de forma estable).

Pérdida vs métrica: qué son y por qué no son lo mismo

Pérdida (loss) es la función que el optimizador minimiza durante el entrenamiento. Debe ser (en general) diferenciable o al menos tener gradientes útiles para ajustar parámetros. Métrica es una medida para evaluar desempeño de forma interpretable y alineada con el objetivo del negocio o del problema, aunque no sea diferenciable (por ejemplo, accuracy).

Ejemplo típico: puedes entrenar un clasificador con entropía cruzada (porque optimiza probabilidades y es estable para gradientes) y reportar F1 o AUC (porque el dataset está desbalanceado y accuracy sería engañosa).

Métricas comunes en clasificación

Para definirlas, usa la matriz de confusión en binaria:

• TP (true positives): positivos correctamente detectados
• FP (false positives): negativos marcados como positivos
• TN (true negatives): negativos correctamente detectados
• FN (false negatives): positivos no detectados

Accuracy

Proporción de aciertos:

Accuracy = (TP + TN) / (TP + TN + FP + FN)

Cuándo usarla: clases relativamente balanceadas y coste similar de FP y FN. Cuándo evitarla: datasets muy desbalanceados (por ejemplo, 99% no-fraude).

Precisión (Precision)

De los predichos como positivos, cuántos eran realmente positivos:

Precision = TP / (TP + FP)

Útil cuando: los falsos positivos son caros (por ejemplo, bloquear transacciones legítimas).

Recall (sensibilidad)

De los positivos reales, cuántos detectaste:

Recall = TP / (TP + FN)

Útil cuando: los falsos negativos son caros (por ejemplo, no detectar una enfermedad).

F1-score

Media armónica entre precisión y recall:

F1 = 2 * (Precision * Recall) / (Precision + Recall)

Útil cuando: necesitas un equilibrio entre FP y FN, especialmente con desbalance. Si te importa más recall que precisión (o viceversa), considera variantes como Fβ.

AUC-ROC

El AUC-ROC resume el rendimiento del clasificador a través de todos los umbrales de decisión posibles, midiendo la capacidad de ordenar positivos por encima de negativos. No depende de un umbral fijo.

Útil cuando: quieres evaluar la calidad del ranking/probabilidades y comparar modelos sin fijar umbral. Precaución: en desbalance extremo, a veces es más informativo mirar también PR-AUC (área bajo la curva precisión-recall).

Guía práctica: elegir métricas según el problema

• Clases balanceadas: accuracy + entropía cruzada para entrenar.
• Desbalance moderado: reporta F1 y/o AUC; ajusta umbral para el trade-off precisión/recall.
• FP muy costoso: optimiza el umbral para alta precisión; reporta precisión y recall.
• FN muy costoso: prioriza recall; reporta recall y precisión para controlar FP.
• Necesitas probabilidades calibradas: entropía cruzada suele ser mejor que optimizar directamente accuracy; evalúa también calibración (p. ej., Brier score) si aplica.

Regularización básica: L2 y L1 como término añadido a la pérdida

La regularización añade una penalización a la pérdida para desalentar modelos demasiado complejos y reducir sobreajuste. Se implementa como un término extra:

L_total(θ) = L_datos(θ) + λ * Ω(θ)

donde λ controla la fuerza de la regularización y Ω(θ) penaliza los parámetros (normalmente los pesos, a veces excluyendo sesgos).

Regularización L2 (Ridge / weight decay)

Penaliza el cuadrado de los pesos:

Ω(θ) = Σ_j w_j²

Efecto: empuja los pesos a ser pequeños y distribuidos; rara vez los hace exactamente cero. Suele mejorar generalización y estabilidad.

Interpretación intuitiva: entre dos modelos que explican igual de bien los datos, prefieres el que lo hace con pesos más “moderados”.

Nota práctica: en muchos optimizadores se implementa como weight decay, que es equivalente a L2 en SGD clásico y muy cercano en otros casos (dependiendo del optimizador). En frameworks es común configurar weight_decay en el optimizador.

Regularización L1 (Lasso)

Penaliza el valor absoluto de los pesos:

Ω(θ) = Σ_j |w_j|

Efecto: promueve soluciones dispersas (sparse), empujando algunos pesos a cero. Puede actuar como una forma de selección de características en modelos lineales; en redes profundas, puede inducir sparsidad pero su efecto depende de la arquitectura y la escala.

Cuándo considerarla: cuando buscas interpretabilidad/sparsidad o quieres forzar que el modelo use menos conexiones efectivas.

Guía práctica paso a paso: añadir regularización sin complicarte

• 1) Empieza sin regularización y establece una línea base de pérdida y métricas en validación.
• 2) Añade L2 como primera opción: prueba valores de λ (o weight_decay) en escala logarítmica, por ejemplo 1e-5, 1e-4, 1e-3, 1e-2.
• 3) Observa el patrón: si la pérdida de entrenamiento baja mucho pero la validación empeora, suele indicar sobreajuste; aumentar regularización puede ayudar. Si ambas pérdidas son altas, quizá estás subajustando (regularización demasiado fuerte o modelo insuficiente).
• 4) Considera L1 si necesitas sparsidad; prueba valores pequeños y monitoriza si degrada demasiado el desempeño.
• 5) Reporta métricas relevantes: la regularización puede mejorar AUC o F1 aunque la accuracy cambie poco; elige métricas alineadas con tu objetivo.

Ejemplo integrado: configurar pérdida, métricas y regularización

Clasificación binaria (fraude vs no fraude)

• Salida del modelo: probabilidad p de fraude.
• Pérdida para entrenar: entropía cruzada binaria (idealmente con logits para estabilidad).
• Métricas a reportar: AUC-ROC y F1 (por desbalance), además de precisión/recall.
• Umbral: no asumas 0.5; ajusta el umbral en validación para el trade-off deseado.
• Regularización: L2 (weight decay) para reducir sobreajuste.

Regresión (predicción de demanda)

• Salida del modelo: valor continuo ŷ.
• Pérdida para entrenar: MSE.
• Métricas a reportar: además de MSE, puedes reportar MAE o RMSE por interpretabilidad (en unidades del objetivo).
• Regularización: L2 para estabilizar pesos; L1 si buscas sparsidad.

Implementación conceptual (pseudo-código) del bucle de entrenamiento

# Dado: modelo f(x; θ), loss_datos, regularización Ω, λ, optimizador opt
for epoch in range(E):
  for (x_batch, y_batch) in loader:
    y_pred = f(x_batch; θ)
    L_datos = loss_datos(y_batch, y_pred)
    L_total = L_datos + λ * Ω(θ)
    opt.zero_grad()
    L_total.backward()
    opt.step()
  # al final de la época: evaluar métricas en validación (accuracy/F1/AUC/etc.)

Este esquema separa claramente: (1) lo que optimizas (pérdida total) y (2) lo que reportas para entender el rendimiento (métricas). En plataformas de aprendizaje como Coursera, edX o Udacity verás esta separación de forma recurrente: entrenas con una loss diferenciable y evalúas con métricas alineadas al objetivo.