SolveConPython

En el artículo anterior vimos qué aprende la capa oculta y cómo transforma el espacio de los datos.
Ahora surge una pregunta inevitable:

¿Cuántas neuronas ocultas debería usar?

¿2? ¿4? ¿10? ¿100?

La respuesta corta es: depende del problema.
La respuesta útil es entender underfitting y overfitting.

Dos errores comunes al diseñar una red

Cuando elegimos el número de neuronas ocultas, podemos caer en dos extremos.

1️⃣ Underfitting (modelo demasiado simple)

• Muy pocas neuronas
• La red no tiene capacidad suficiente
• No aprende el patrón, aunque entrenes mucho

2️⃣ Overfitting (modelo demasiado complejo)

• Demasiadas neuronas
• Aprende el dataset “de memoria”
• Generaliza mal a datos nuevos

El objetivo es encontrar un equilibrio.

Intuición visual: complejidad del modelo

Piensa en la capa oculta como una caja de herramientas:

• Pocas herramientas → no puedes resolver el problema
• Demasiadas → usas herramientas innecesarias y te confundes

Experimento práctico: probando distintas capas ocultas

Vamos a usar el mismo problema XOR y cambiar solo una cosa:
el número de neuronas ocultas.

def train_network(hidden_size, epochs=5000, lr=0.1):
    rng = np.random.default_rng(42)
    W1 = rng.normal(0, 1, size=(2, hidden_size))
    b1 = np.zeros((1, hidden_size))
    W2 = rng.normal(0, 1, size=(hidden_size, 1))
    b2 = np.zeros((1, 1))
    for _ in range(epochs):
        # forward
        Z1 = X @ W1 + b1
        A1 = np.tanh(Z1)
        Z2 = A1 @ W2 + b2
        y_hat = sigmoid(Z2)
        # backward
        dZ2 = y_hat - y
        dW2 = A1.T @ dZ2
        db2 = dZ2.sum(axis=0, keepdims=True)
        dA1 = dZ2 @ W2.T
        dZ1 = dA1 * (1 - A1 ** 2)
        dW1 = X.T @ dZ1
        db1 = dZ1.sum(axis=0, keepdims=True)
        # update
        W1 -= lr * dW1
        b1 -= lr * db1
        W2 -= lr * dW2
        b2 -= lr * db2
    loss = binary_cross_entropy_mean(y, y_hat)
    return loss

Probando diferentes tamaños

for hidden_size in [1, 2, 4, 8, 16]:
    loss = train_network(hidden_size)
    print(f"Neuronas ocultas: {hidden_size} | Loss final: {loss:.4f}")

Resultados típicos:

• 1 neurona → no aprende XOR (underfitting)
• 2–4 neuronas → aprende bien
• 8+ neuronas → aprende, pero con capacidad sobrante

Qué está pasando realmente

• XOR necesita al menos dos neuronas ocultas
• Más neuronas no siempre significan mejor
• La red empieza a aprender representaciones redundantes

En problemas pequeños:

Más capacidad ≠ más inteligencia

Regla práctica (muy útil)

Para empezar:

• Problemas simples → pocas neuronas
• Aumenta solo si:
  • la pérdida no baja
  • el modelo no aprende el patrón

Nunca empieces con una red gigante “por si acaso”.

Conexión con problemas reales

En datasets grandes:

• Overfitting se vuelve crítico
• Se usan técnicas como:
  • regularización
  • validación
  • early stopping

Aquí estamos construyendo intuición, no optimización industrial.

Señales de underfitting vs overfitting

Underfitting

• Loss alta
• Predicciones pobres
• No mejora con más epochs

Overfitting

• Loss muy baja en entrenamiento
• Mal desempeño fuera del dataset
• Modelo demasiado sensible

Qué debes llevarte de este artículo

• El número de neuronas es una decisión de diseño
• La capa oculta controla la capacidad del modelo
• Entender under/overfitting es clave para ML real

Qué viene después

En el Artículo #10 daremos un paso muy práctico y estructural:

Reescribiendo la red neuronal como una clase en Python