El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Función de activación

Siguiente ►
►

En la lección anterior el perceptrón decidía con una función escalón: todo o nada, 0 o 1. Ese interruptor brusco tiene dos problemas serios: no expresa matices ("¿cómo de sospechoso es este pedido?") y, sobre todo, no se puede derivar, lo que —como veremos en la próxima lección— hace imposible entrenar capas ocultas. En esta lección entenderás primero por qué una red necesita funciones de activación no lineales (sin ellas, apilar cien capas equivale a tener una sola), y después recorreremos el catálogo de activaciones que usarás durante todo el curso: sigmoide, tanh, ReLU y sus variantes, y softmax. Cerraremos con una guía práctica de cuál usar en cada situación, con los proyectos de TecnoMarket como ejemplos, y las implementaremos y visualizaremos con numpy y matplotlib.

Contenido

  1. Por qué la no linealidad es imprescindible
  2. Catálogo de funciones de activación
  3. Tabla comparativa
  4. Qué activación usar en cada capa según el problema
  5. Implementación en numpy y visualización con matplotlib

Por qué la no linealidad es imprescindible

Imagina que quitamos la activación (o usamos la "activación identidad" $f(z) = z$, que es lineal) en la red 2-2-1 que resolvió XOR. Cada capa haría solo una operación lineal: multiplicar por una matriz y sumar un sesgo. Veamos qué pasa al encadenar dos:

$$h = W_1^T x + b_1 \qquad \hat{y} = W_2^T h + b_2$$

Sustituyendo la primera en la segunda:

$$\hat{y} = W_2^T (W_1^T x + b_1) + b_2 = \underbrace{(W_2^T W_1^T)}{W'} x + \underbrace{(W_2^T b_1 + b_2)}{b'} = W' x + b'$$

El resultado es otra operación lineal, con una matriz $W'$ y un sesgo $b'$ combinados. Da igual cuántas capas apiles: la composición de funciones lineales es lineal. Una red de 100 capas sin activaciones no lineales es matemáticamente idéntica a un perceptrón sin escalón, es decir, a una simple regresión lineal — y por tanto vuelve a estrellarse contra XOR y contra cualquier problema del mundo real.

Puedes comprobarlo empíricamente en numpy:

import numpy as np

rng = np.random.default_rng(42)
W1, b1 = rng.normal(size=(3, 4)), rng.normal(size=4)
W2, b2 = rng.normal(size=(4, 2)), rng.normal(size=2)

x = rng.normal(size=3)

# Red de 2 capas SIN activación
y_red = (x @ W1 + b1) @ W2 + b2

# Una sola capa equivalente, "colapsada"
W_eq = W1 @ W2
b_eq = b1 @ W2 + b2
y_eq = x @ W_eq + b_eq

print(np.allclose(y_red, y_eq))   # -> True: eran la misma función

La función de activación es la pieza que rompe esta trampa: al aplicar una función no lineal $f$ tras cada capa ($h = f(W^T x + b)$), la composición deja de colapsar y cada capa nueva añade capacidad real. Es lo que permite la jerarquía de representaciones que vimos en la primera lección del curso: bordes → formas → objetos.

Catálogo de funciones de activación

Para cada función indicamos fórmula, forma de la gráfica, rango de salida y uso típico. Todas reciben la suma ponderada $z = w \cdot x + b$ de la lección anterior.

Escalón (step)

$$f(z) = \begin{cases} 1 & z \geq 0 \ 0 & z < 0 \end{cases}$$

  • Gráfica: una línea horizontal en 0 que salta bruscamente a 1 al cruzar el origen.
  • Rango: {0, 1} (solo dos valores).
  • Uso hoy: ninguno en la práctica; interés histórico (perceptrón). Su derivada es 0 en todas partes (e infinita en el salto), así que no transmite información de "cuánto corregir".

Sigmoide (logística)

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

  • Gráfica: una "S" suave: cerca de 0 para $z$ muy negativos, cerca de 1 para $z$ muy positivos, y vale exactamente 0.5 en $z=0$. Es la versión "suavizada" del escalón.
  • Rango: (0, 1).
  • Interpretación: su salida se puede leer como probabilidad. Para el filtro antifraude de TecnoMarket, en lugar de un seco "fraude sí/no", la sigmoide devuelve "probabilidad de fraude 0.87", lo que permite políticas graduales (bloquear si > 0.9, revisar manualmente si 0.5–0.9).
  • Problema: en los extremos la curva es casi plana (se satura): la pendiente es prácticamente cero, y eso dificulta el aprendizaje en redes profundas. Es el origen del vanishing gradient que mencionaremos al final y desarrollaremos en la próxima lección.
  • Uso actual: capa de salida en clasificación binaria. Ya casi nunca en capas ocultas.

Tangente hiperbólica (tanh)

$$\tanh(z) = \frac{e^z - e^{-z}}{e^z + e^{-z}}$$

  • Gráfica: la misma "S" que la sigmoide, pero estirada verticalmente: pasa por el origen (tanh(0) = 0).
  • Rango: (−1, 1).
  • Ventaja sobre la sigmoide: su salida está centrada en cero, lo que suele facilitar el entrenamiento de la capa siguiente (las entradas no son todas positivas).
  • Problema: se satura igual que la sigmoide en los extremos.
  • Uso actual: capas ocultas en algunas arquitecturas recurrentes (la reencontrarás dentro de las LSTM en el módulo 4).

ReLU (Rectified Linear Unit)

$$\text{ReLU}(z) = \max(0, z)$$

  • Gráfica: plana en 0 para $z$ negativo, y una recta de pendiente 1 para $z$ positivo. Un "codo" en el origen.
  • Rango: [0, +∞).
  • Por qué domina: es baratísima de calcular (una comparación), no se satura para valores positivos (la pendiente sigue siendo 1 por grande que sea $z$) y en la práctica hace que las redes profundas entrenen mucho más rápido. Es la activación por defecto en capas ocultas desde la era AlexNet (2012, lección de historia).
  • Aunque parezca "casi lineal", no lo es: el codo en 0 basta para romper el colapso lineal del apartado 1.
  • Problema: las neuronas muertas (dying ReLU): si una neurona acaba con $z$ siempre negativo para todos los datos, su salida es siempre 0, su pendiente es siempre 0, y ya nunca vuelve a aprender.

Variantes de ReLU: Leaky ReLU y ELU

Leaky ReLU — arregla las neuronas muertas dejando pasar una pequeña pendiente en la zona negativa:

$$f(z) = \begin{cases} z & z \geq 0 \ \alpha z & z < 0 \end{cases} \qquad (\alpha \approx 0.01)$$

Gráfica: como ReLU, pero la parte izquierda no es plana sino una recta casi horizontal con pendiente $\alpha$. Rango: (−∞, +∞).

ELU (Exponential Linear Unit) — suaviza la zona negativa con una exponencial:

$$f(z) = \begin{cases} z & z \geq 0 \ \alpha(e^z - 1) & z < 0 \end{cases} \qquad (\alpha \approx 1)$$

Gráfica: idéntica a ReLU a la derecha; a la izquierda desciende suavemente y se aplana en $-\alpha$. Rango: (−α, +∞). Salida media más cercana a cero que ReLU y sin codo brusco, a costa de calcular una exponencial.

Softmax (para salida multiclase)

A diferencia de las anteriores, softmax no actúa neurona a neurona sino sobre todo el vector de salidas $z = (z_1, \dots, z_K)$ de la última capa:

$$\text{softmax}(z)i = \frac{e^{z_i}}{\sum{j=1}^{K} e^{z_j}}$$

  • Rango: cada componente en (0, 1) y todas suman exactamente 1: una distribución de probabilidad sobre las $K$ clases.
  • Intuición: exponenciar amplifica las diferencias (el mayor $z_i$ se lleva casi toda la probabilidad) y dividir por la suma normaliza.
  • Uso: capa de salida en clasificación multiclase. Cuando el clasificador de fotos de TecnoMarket mire una imagen y deba elegir entre {portátil, cafetera, aspiradora, monitor}, softmax devolverá algo como (0.85, 0.02, 0.03, 0.10): un 85 % de confianza en "portátil".

Tabla comparativa

Función Fórmula Rango ¿Se satura? Coste Uso principal hoy
Escalón $z \geq 0 \Rightarrow 1$ {0, 1} — (no derivable) Mínimo Histórico (perceptrón)
Sigmoide $1/(1+e^{-z})$ (0, 1) Sí, ambos extremos Medio (exp) Salida binaria
Tanh $\frac{e^z - e^{-z}}{e^z + e^{-z}}$ (−1, 1) Sí, ambos extremos Medio (exp) Ocultas en RNN/LSTM
ReLU $\max(0, z)$ [0, +∞) No (lado positivo) Mínimo Ocultas, por defecto
Leaky ReLU $\max(\alpha z, z)$ (−∞, +∞) No Mínimo Ocultas si hay neuronas muertas
ELU $z$ ó $\alpha(e^z-1)$ (−α, +∞) Solo lado negativo Medio (exp) Ocultas, alternativa a ReLU
Softmax $e^{z_i}/\sum e^{z_j}$ (0,1), suma 1 — Medio Salida multiclase

Qué activación usar en cada capa según el problema

La elección sigue dos reglas distintas según la capa:

Capas ocultas: empieza siempre por ReLU. Si detectas muchas neuronas muertas, prueba Leaky ReLU o ELU. Reserva tanh para arquitecturas recurrentes (módulo 4). Evita la sigmoide en capas ocultas.

Capa de salida: la decide el tipo de problema, porque la salida debe tener la forma de la respuesta que buscas:

Tipo de problema Ejemplo TecnoMarket Neuronas de salida Activación de salida
Regresión (número real) Predecir unidades vendidas de una cafetera la próxima semana 1 Ninguna (lineal/identidad)
Clasificación binaria ¿Es fraudulento este pedido? / ¿Es positiva esta reseña? 1 Sigmoide
Clasificación multiclase (una sola clase correcta) ¿Esta foto es un portátil, una cafetera, una aspiradora o un monitor? K (una por clase) Softmax
Multietiqueta (varias clases a la vez) Etiquetar una reseña con varios temas: "envío", "precio", "calidad" K Sigmoide en cada neurona

Fíjate en la diferencia entre las dos últimas filas: softmax obliga a que las probabilidades compitan (suman 1: una foto es una sola cosa); las sigmoides independientes permiten que varias etiquetas sean ciertas a la vez. En la lección de optimización y función de pérdida verás que cada una de estas salidas se empareja con una función de pérdida concreta.

Implementación en numpy y visualización con matplotlib

Todas caben en unas pocas líneas. Guarda este código en tu carpeta tecnomarket-dl/ (por ejemplo como activaciones.py), porque lo reutilizaremos en la próxima lección:

import numpy as np
import matplotlib.pyplot as plt

def escalon(z):    return (z >= 0).astype(float)
def sigmoide(z):   return 1 / (1 + np.exp(-z))
def tanh(z):       return np.tanh(z)          # numpy ya la trae
def relu(z):       return np.maximum(0, z)
def leaky_relu(z, alpha=0.01):
    return np.where(z >= 0, z, alpha * z)
def elu(z, alpha=1.0):
    return np.where(z >= 0, z, alpha * (np.exp(z) - 1))

def softmax(z):
    z = z - np.max(z)                  # truco de estabilidad numérica
    e = np.exp(z)
    return e / e.sum()

Dos detalles importantes:

  • np.where(condicion, a, b) elige elemento a elemento: donde la condición es cierta toma a, donde no, b. Es la forma vectorizada del "si z ≥ 0 entonces... si no...".
  • En softmax restamos el máximo antes de exponenciar. No cambia el resultado matemático (numerador y denominador quedan divididos por la misma constante $e^{z_{max}}$), pero evita que np.exp(1000) desborde a infinito. Sin este truco, softmax falla con entradas grandes.

Ahora dibujamos todas las curvas para fijar la intuición visual:

z = np.linspace(-5, 5, 200)   # 200 puntos entre -5 y 5

funciones = [
    ("Escalon", escalon), ("Sigmoide", sigmoide), ("Tanh", tanh),
    ("ReLU", relu), ("Leaky ReLU", leaky_relu), ("ELU", elu),
]

fig, ejes = plt.subplots(2, 3, figsize=(12, 6))
for eje, (nombre, f) in zip(ejes.flat, funciones):
    eje.plot(z, f(z), linewidth=2)
    eje.set_title(nombre)
    eje.axhline(0, color="gray", linewidth=0.5)   # eje horizontal de referencia
    eje.axvline(0, color="gray", linewidth=0.5)   # eje vertical de referencia
    eje.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

Al ejecutar verás en una sola figura las seis formas descritas en el catálogo: el salto del escalón, las dos "S" (una entre 0 y 1, otra entre −1 y 1), el codo de ReLU y sus dos variantes con la zona negativa "rescatada". Y una prueba rápida de softmax con las puntuaciones del clasificador de fotos:

puntuaciones = np.array([3.1, -0.5, 0.2, 1.4])   # portátil, cafetera, aspiradora, monitor
probs = softmax(puntuaciones)
print(np.round(probs, 3))    # -> [0.792 0.022 0.044 0.143]
print(probs.sum())           # -> 1.0

La clase con mayor puntuación (portátil) concentra la probabilidad, pero las demás no quedan a cero: el modelo expresa su incertidumbre.

Un apunte final que conecta con la próxima lección: hemos dicho varias veces que sigmoide y tanh "se saturan" y que eso dificulta el aprendizaje. La razón exacta es que en las zonas planas su pendiente (derivada) es casi cero, y el algoritmo de entrenamiento —backpropagation— multiplica pendientes en cadena: muchos números casi-cero multiplicados dan un cero práctico, y las primeras capas dejan de aprender. Es el famoso vanishing gradient; lo veremos surgir de forma natural en la próxima lección y las técnicas para combatirlo en profundidad en el módulo 5.

Errores Comunes y Consejos

  • Poner activación en la salida de una regresión. Si predices unidades vendidas y pones sigmoide en la salida, tu red solo podrá predecir entre 0 y 1. Para regresión, la última capa va sin activación (o activation="linear" en Keras, que es lo mismo).
  • Usar softmax con una sola neurona de salida. Softmax sobre un vector de un elemento devuelve siempre 1.0, sea cual sea la entrada. Para binaria: 1 neurona + sigmoide, o 2 neuronas + softmax, pero no mezcles.
  • Calcular softmax sin restar el máximo. Funciona con números pequeños y explota con grandes (np.exp(1000) = inf, y inf/inf = nan). Usa siempre la versión estable.
  • Sigmoide en muchas capas ocultas. Es la receta clásica del vanishing gradient. En ocultas, ReLU por defecto.
  • Ignorar las neuronas muertas. Si tras entrenar observas que muchas unidades ReLU sacan 0 para todos los ejemplos, baja la tasa de aprendizaje o cambia a Leaky ReLU/ELU.
  • Elegir la activación de salida sin pensar en la pérdida. Van en pareja (sigmoide ↔ entropía cruzada binaria, softmax ↔ entropía cruzada categórica). El emparejamiento exacto lo cubrimos en la lección de optimización.

Ejercicios

  1. Derivadas visuales. La derivada de la sigmoide es $\sigma'(z) = \sigma(z)(1 - \sigma(z))$. Impleméntala y dibújala junto a la sigmoide en la misma gráfica para $z \in [-6, 6]$. ¿Cuál es su valor máximo y dónde se alcanza? ¿Qué vale aproximadamente en $z = 5$? Relaciona lo que ves con el vanishing gradient.
  2. Clasificador de salida correcto. Para cada proyecto de TecnoMarket, indica cuántas neuronas de salida usarías y con qué activación: (a) decidir si una reseña es positiva o negativa; (b) clasificar una foto entre 12 categorías de producto; (c) predecir el importe medio de compra de un cliente el próximo mes; (d) marcar una reseña con las etiquetas que apliquen de {envío, precio, calidad, atención}.
  3. XOR con sigmoide. Reescribe el MLP 2-2-1 que resolvió XOR en la lección anterior sustituyendo el escalón por la sigmoide (mantén los mismos pesos: W1=[[1,1],[1,1]], b1=[-0.5,-1.5], W2=[[1],[-2]], b2=[-0.5]). Multiplica antes todos los pesos y sesgos por 10. Calcula la salida para las cuatro entradas y comprueba que, redondeando, sigue siendo XOR. ¿Por qué hace falta multiplicar por 10?

Soluciones

Ejercicio 1.

def sigmoide_derivada(z):
    s = sigmoide(z)
    return s * (1 - s)

z = np.linspace(-6, 6, 200)
plt.plot(z, sigmoide(z), label="sigmoide")
plt.plot(z, sigmoide_derivada(z), label="derivada")
plt.legend(); plt.grid(True); plt.show()

El máximo de la derivada es 0.25 y se alcanza en $z = 0$. En $z = 5$ vale aproximadamente 0.0066: casi cero. Como la derivada nunca supera 0.25, al encadenar varias capas sigmoides las pendientes se multiplican (0.25 × 0.25 × ... → 0 rápidamente): esa es la semilla del vanishing gradient.

Ejercicio 2. (a) 1 neurona con sigmoide (binaria). (b) 12 neuronas con softmax (multiclase excluyente). (c) 1 neurona sin activación (regresión; el importe no está acotado a (0,1)). (d) 4 neuronas, cada una con su propia sigmoide (multietiqueta: una reseña puede hablar del envío y del precio a la vez, así que las probabilidades no deben competir).

Ejercicio 3. Con los pesos ×10 (b1=[-5,-15], etc.), las sumas ponderadas quedan lejos de cero y la sigmoide se comporta casi como el escalón: para (0,0) la salida es ≈0.007 → 0; para (0,1) y (1,0), ≈0.98 → 1; para (1,1), ≈0.01 → 0. Redondeando, XOR. Hace falta multiplicar por 10 porque con los pesos originales las sumas caen en la zona central y suave de la sigmoide (donde la salida ronda 0.3–0.6 en vez de acercarse a 0 o 1) y el redondeo ya no reproduce el comportamiento del escalón. Moraleja: la sigmoide es un escalón "ablandado", y la magnitud de los pesos controla cuánto se parece a él.

Conclusión

Ya sabes por qué las funciones de activación no son un adorno sino la condición para que la profundidad sirva de algo: sin no linealidad, cualquier pila de capas colapsa en una sola transformación lineal. Tienes el catálogo completo —escalón (historia), sigmoide y tanh (las "S" que se saturan), ReLU y variantes (el estándar en ocultas), softmax (la salida multiclase)— y las dos reglas prácticas: ReLU por defecto en capas ocultas, y en la salida lo que dicte el problema (nada para regresión, sigmoide para binaria, softmax para multiclase).

Además, todas las activaciones modernas comparten una propiedad de la que el escalón carecía: tienen derivada útil, una pendiente que dice hacia dónde y cuánto corregir. Esa pendiente es justo lo que necesita el algoritmo que llevamos dos lecciones aplazando: en la próxima lección abriremos por fin la caja de backpropagation y veremos cómo una red completa —nuestra vieja conocida 3-4-2-1 incluida— aprende sus pesos capa a capa.

◄ Anterior
◄
Siguiente ►
►

Curso de Deep Learning

Módulo 1: Introducción a Deep Learning

Módulo 2: Fundamentos de Redes Neuronales

Módulo 3: Redes Neuronales Convolucionales (CNN)

Módulo 4: Redes Neuronales Recurrentes (RNN)

Módulo 5: Técnicas Avanzadas en Deep Learning

Módulo 6: Herramientas y Frameworks

Módulo 7: Proyectos Prácticos

Módulo 8: Consideraciones Éticas y Futuro del Deep Learning

El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2026. Todos los derechos reservados