Lexicon Redes Neuronales

¿Cómo evitar neuronas muertas sin perder simplicidad?

La comparación entre ReLU y Leaky ReLU aborda un problema clave en redes neuronales: el Dying ReLU, donde algunas neuronas dejan de aprender.

👉 Leaky ReLU surge como una mejora directa de ReLU para mantener el flujo de gradiente.

Definición corta

• ReLU: anula valores negativos
• Leaky ReLU: permite un pequeño flujo negativo

Definición matemática

🔹 ReLU

$$f(x) = \max(0, x)$$

🔹 Leaky ReLU

$$f(x) = \begin{cases} \alpha x & x < 0 \\ x & x \ge 0 \end{cases}$$

👉 donde $\alpha$ suele ser 0.01

Intuición

• ReLU: “ignoro lo negativo”
• Leaky ReLU: “lo negativo aún tiene un pequeño valor”

ReLU → corta completamente  
Leaky ReLU → deja pasar un poco

Comparación visual conceptual

ReLU:
     /
----/
    Leaky ReLU:
    /
---/
  /

🔄 Diferencia clave

Problema: Dying ReLU

En ReLU:$$x < 0 \Rightarrow f'(x) = 0$$

la neurona deja de aprender.

Ejemplo conceptual

Entrada negativa constante  
↓  
Salida = 0  
↓  
Gradiente = 0  
↓  
Neurona muerta

Solución: Leaky ReLU

$$f'(x) = \alpha \quad (x < 0)$$

👉 mantiene flujo de gradiente.

Ejemplo conceptual

Entrada negativa  
↓  
Salida pequeña  
↓  
Gradiente ≠ 0  
↓  
Sigue aprendiendo

Impacto en entrenamiento

🔹 ReLU

• rápido
• eficiente
• puede fallar en ciertas neuronas

🔹 Leaky ReLU

• más estable
• mejor flujo de gradiente
• ligeramente más complejo

Cuándo usar cada uno

Usa ReLU cuando:

• quieres máxima eficiencia
• modelo estándar
• no hay problemas de gradiente

Usa Leaky ReLU cuando:

• observas neuronas muertas
• redes profundas
• problemas de aprendizaje lento

Ejemplo en Python

import numpy as np
def relu(x):
    return np.maximum(0, x)
def leaky_relu(x, alpha=0.01):
    return np.where(x > 0, x, alpha * x)
x = np.array([-2, -1, 0, 1, 2])
print("ReLU:", relu(x))
print("Leaky ReLU:", leaky_relu(x))

Ejemplo en PyTorch

import torch
import torch.nn as nn
relu = nn.ReLU()
leaky = nn.LeakyReLU(0.01)
x = torch.tensor([-2.0, -1.0, 0.0, 1.0, 2.0])
print("ReLU:", relu(x))
print("Leaky:", leaky(x))

Ejemplo en red neuronal

model_relu = nn.Sequential(
    nn.Linear(10, 20),
    nn.ReLU()
)
model_leaky = nn.Sequential(
    nn.Linear(10, 20),
    nn.LeakyReLU(0.01)
)

Qué muestra este ejemplo

• diferencia en activación
• impacto en valores negativos
• uso en modelos reales

Errores comunes

Pensar que ReLU siempre es suficiente

Puede fallar en redes profundas.

Usar α demasiado grande

Reduce no linealidad.

Ignorar diagnóstico

No detectar neuronas muertas.

Ejemplo conceptual en ML

Modelo  
↓  
Activación  
↓  
Flujo de gradiente  
↓  
Capacidad de aprendizaje

Interpretación profunda

Esta comparación refleja un principio clave:

👉 El flujo de gradiente es más importante que la simplicidad absoluta.

Leaky ReLU introduce una pequeña modificación que:

• mejora estabilidad
• mantiene aprendizaje activo
• evita bloqueos

Conclusión

• ReLU es simple, rápida y efectiva
• Leaky ReLU es más robusta y evita neuronas muertas

👉 Si tu modelo deja de aprender, Leaky ReLU suele ser la primera mejora.

Related Concepts

• ReLU
• Función de activación
• Desvanecimiento del gradiente
• Explosión del gradiente
• Optimización