SolveConPython

Hasta ahora ya construimos varias piezas clave:

1. La neurona: suma ponderada + bias
2. Las funciones de activación: introducen no linealidad
3. La salida activada: un número interpretable

Pero todavía falta algo fundamental.

¿Cómo sabe una red neuronal si su respuesta es buena o mala?

¿Cómo mide el “error”?

La respuesta es la función de pérdida (loss function).

Qué es una función de pérdida (idea central)

Una función de pérdida es una fórmula que:

• Compara lo que el modelo predice
• Con lo que debería haber predicho
• Y devuelve un número

Ese número representa el error.

Regla simple:

• Pérdida grande → el modelo se equivoca mucho
• Pérdida pequeña → el modelo lo está haciendo bien

El objetivo del entrenamiento es siempre el mismo:

Minimizar la pérdida.

El escenario típico (clasificación binaria)

En esta serie estamos construyendo una red neuronal para clasificación binaria.

Eso significa:

• Etiqueta real (y) → 0 o 1
• Predicción del modelo (ŷ) → número entre 0 y 1 (sale de la sigmoide)

Ejemplos:

• y = 1, ŷ = 0.95 → muy bien
• y = 1, ŷ = 0.10 → muy mal

La función de pérdida debe reflejar exactamente eso.

La función de pérdida más usada: Binary Cross-Entropy

Para clasificación binaria, la función estándar es la entropía cruzada binaria (Binary Cross-Entropy, BCE).

La fórmula es:$$L(y, \hat{y}) = -\left( y \log(\hat{y}) + (1 – y)\log(1 – \hat{y}) \right)$$L(y,y^​)=−(ylog(y^​)+(1−y)log(1−y^​))

No te preocupes por memorizarla. Vamos a entenderla paso a paso.

Intuición sin fórmulas

La BCE se comporta así:

• Si y = 1
  • Queremos que ŷ sea cercano a 1
  • Si ŷ es pequeño → castigo grande
• Si y = 0
  • Queremos que ŷ sea cercano a 0
  • Si ŷ es grande → castigo grande

La función penaliza predicciones seguras pero incorrectas mucho más que errores pequeños.

Visualizando la pérdida

Observa:

• La pérdida crece muy rápido cuando el modelo está “seguro y equivocado”
• Esto empuja al modelo a corregirse con fuerza

Implementar la pérdida en Python (una muestra)

import numpy as np
def binary_cross_entropy(y_true, y_pred):
    eps = 1e-9  # para evitar log(0)
    y_pred = np.clip(y_pred, eps, 1 - eps)
    return -(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred))

Ejemplos:

binary_cross_entropy(1, 0.9)   # pequeño error
binary_cross_entropy(1, 0.1)   # error grande
binary_cross_entropy(0, 0.9)   # error grande

Varias muestras a la vez (caso real)

En entrenamiento real, calculamos la pérdida para muchas muestras y sacamos el promedio.

def binary_cross_entropy_mean(y_true, y_pred):
    eps = 1e-9
    y_pred = np.clip(y_pred, eps, 1 - eps)
    losses = -(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred))
    return np.mean(losses)

Esto devuelve un solo número:

• El error medio del modelo en ese lote de datos

Dónde encaja la pérdida en la red

El flujo completo ahora es:

1. Entrada X
2. Neurona + activación → ŷ
3. Comparar ŷ con y
4. Calcular pérdida L

Z = X @ W + b
y_hat = sigmoid(Z)
loss = binary_cross_entropy_mean(y, y_hat)

La pérdida no cambia los pesos directamente.
Solo responde a una pregunta:

“¿Qué tan mal lo estoy haciendo?”

Por qué la pérdida es esencial para aprender

Sin función de pérdida:

• No hay forma de medir error
• No hay dirección de mejora
• No hay aprendizaje

La pérdida es el puente entre:

• Predicciones
• Matemáticas
• Ajuste de pesos

En el siguiente artículo usaremos la pérdida para responder:

¿Cómo se ajustan los pesos para reducir el error?

Pieza reutilizable (guárdala)

Esta función se usará tal cual en el entrenamiento:

def binary_cross_entropy_mean(y_true, y_pred):
    eps = 1e-9
    y_pred = np.clip(y_pred, eps, 1 - eps)
    return np.mean(
        -(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred))
    )

Qué viene después

En el Artículo #5 entraremos en el corazón del aprendizaje:

Gradientes y backpropagation — cómo el error se convierte en ajustes de pesos