En el Módulo 1 dejamos una caja negra: la función de activación f(·), ese paso final que convierte la suma ponderada en la salida. También quedó pendiente el drama del perceptrón, que no podía con XOR. Los dos hilos se resuelven aquí, porque son el mismo hilo: la función de activación es lo que le da a la red el poder de aprender cosas que no son una simple línea recta.

La tesis del módulo

Sin una función no-lineal en medio, apilar capas es inútil. Diez capas lineales, una tras otra, colapsan matemáticamente en una sola capa lineal — o sea, en una sola recta. La no-linealidad es lo único que convierte un montón de multiplicaciones en una red capaz de curvar la frontera y aproximar funciones complejas.

Por qué lineal sobre lineal sigue siendo lineal

Imagina dos capas sin activación. La primera transforma la entrada x así: z₁ = W₁x + b₁. La segunda toma ese resultado: z₂ = W₂z₁ + b₂. Si sustituyes la primera dentro de la segunda:

z₂ = W₂(W₁x + b₁) + b₂ = (W₂W₁)x + (W₂b₁ + b₂)

Fíjate en el resultado: es otra vez de la forma Wx + b, con una matriz de pesos combinada y un bias combinado. Da lo mismo una capa que cien: sin algo no-lineal entre medio, toda la red se reduce a una sola transformación lineal. Y una transformación lineal solo puede trazar rectas — por eso el perceptrón moría en XOR.

La solución es meter una función no-lineal f después de cada capa. Entonces f(W₂ · f(W₁x + b₁) + b₂) ya no se puede aplanar en un solo Wx + b. Ahí nace la capacidad de la red.

   Sin activación: las capas colapsan

   x ──► [ W1 ] ──► [ W2 ] ──► [ W3 ] ──► y
             igual que ──► [ W ] ──► y   (una recta)

   Con activación no-lineal: no se puede aplanar

   x ──► [ W1 ] ──► f ──► [ W2 ] ──► f ──► y
             la red puede curvar la frontera

Las tres protagonistas

Sigmoid

La sigmoid aplasta cualquier número a un valor entre 0 y 1. Fórmula: 1 / (1 + e^(-z)). Su forma es una S suave: números muy negativos tienden a 0, muy positivos a 1, y el 0 cae justo en 0.5.

Fue la activación clásica porque su salida entre 0 y 1 se lee como una probabilidad. Su problema: en los extremos la curva se aplana tanto que su pendiente casi desaparece — eso satura y frena el aprendizaje (lo veremos abajo).

Tanh

La tanh (tangente hiperbólica) es la prima de la sigmoid, pero aplasta a un rango entre -1 y 1, con el centro en 0. Ese centrado en cero suele hacer que la red entrene un poco mejor que con sigmoid. Comparte, eso sí, el mismo defecto: también satura en los extremos.

ReLU

La ReLU (Rectified Linear Unit, “unidad lineal rectificada”) es brutalmente simple: max(0, z). Si la entrada es negativa, devuelve 0; si es positiva, la deja pasar tal cual. Una línea quebrada en el origen.

Parece demasiado tonta para funcionar, pero es el default moderno por tres razones: es baratísima de calcular (un simple “¿es mayor que cero?”), y para los valores positivos su pendiente es constante (=1), así que no satura por arriba y el aprendizaje fluye incluso en redes muy profundas. Ese es su gran mérito frente a sigmoid y tanh.

   sigmoid         tanh            ReLU

   │    ╭───        │   ╭───       │    ╱
   │   ╱            │  ╱           │   ╱
   │  ╱             │ ╱            │  ╱
   │ ╱              │╱             │ ╱
   │╱               │              │╱
   └───────      ───┼───           └───────
                 ╱  │
   (0 a 1)      ╱  (-1 a 1)        (0 a +inf)

Comparación de un vistazo

	Sigmoid	Tanh	ReLU
Rango de salida	0 a 1	-1 a 1	0 a +∞
Forma	S suave	S centrada en 0	Línea quebrada
Centrada en cero	No	Sí	No
Costo de cómputo	Alto (exponencial)	Alto (exponencial)	Mínimo (un max)
Satura	Sí, ambos lados	Sí, ambos lados	No por arriba
Uso típico hoy	Salida binaria	Capas ocultas (raro)	Capas ocultas (default)
Problema clave	Vanishing gradient	Vanishing gradient	”Neuronas muertas”

Las mismas funciones en código

import numpy as np

def sigmoid(z):
    return 1 / (1 + np.exp(-z))     # aplasta a (0, 1)

def tanh(z):
    return np.tanh(z)               # aplasta a (-1, 1)

def relu(z):
    return np.maximum(0, z)         # 0 si es negativo, z si es positivo

z = np.array([-2.0, -0.5, 0.0, 0.5, 2.0])
print("sigmoid:", sigmoid(z))       # todos entre 0 y 1
print("tanh:   ", tanh(z))          # todos entre -1 y 1
print("relu:   ", relu(z))          # los negativos quedan en 0

En PyTorch ya vienen listas, tanto como funciones (torch.relu) como capas (nn.ReLU()):

import torch
import torch.nn as nn

z = torch.tensor([-2.0, -0.5, 0.0, 0.5, 2.0])

print(torch.sigmoid(z))
print(torch.tanh(z))
print(torch.relu(z))

# Como capa, para enchufar dentro de una red (módulo 3):
capa_activacion = nn.ReLU()
print(capa_activacion(z))

El problema de saturar: vanishing gradient

Cuando en el módulo 5 la red aprenda, lo hará mirando la pendiente de cada función (su gradiente): cuánto cambia la salida si muevo un poco la entrada. Esa pendiente es la señal que le dice a cada peso hacia dónde moverse.

El drama de la sigmoid: en sus extremos, la curva es casi plana, así que la pendiente es casi cero. Cuando apilas muchas capas con sigmoid, esas pendientes minúsculas se multiplican entre sí capa tras capa y la señal se desvanece antes de llegar a las primeras capas — es el vanishing gradient (“gradiente que se desvanece”). Resultado: las capas del fondo casi no aprenden. ReLU esquiva esto porque su pendiente en la zona positiva es 1, constante, y no se apaga.

Ojo: este es un teaser del Módulo 9, donde el vanishing gradient explica por qué durante años fue tan difícil entrenar redes profundas — y por qué ReLU fue parte de la solución que lo destrabó.

Errores comunes

Poner una activación lineal (o ninguna) en las capas ocultas. Colapsa toda la red en una recta. La no-linealidad no es opcional.
Usar sigmoid o tanh en las capas ocultas por costumbre. Hoy el default de las ocultas es ReLU; sigmoid casi solo se justifica en la salida de una clasificación binaria.
Confundir la activación de las ocultas con la de la salida. La salida elige su activación según la tarea (sigmoid/softmax para clasificar, ninguna para regresión); las ocultas casi siempre van con ReLU.
Ignorar las “neuronas muertas” de ReLU. Si una neurona queda siempre en negativo, su salida es siempre 0 y deja de aprender. Variantes como Leaky ReLU lo mitigan dejando pasar un poquito de lo negativo.

La frase para llevarse

“La no-linealidad es lo que separa una red neuronal de una simple recta. Sin ella, mil capas valen lo mismo que una.”

Qué viene

Módulo 3: la red feed-forward. Ya tenemos la neurona (módulo 1) y su función no-lineal (este). Ahora las apilamos en capas para formar una red de verdad — el MLP — y veremos cómo, con suficientes neuronas, puede aproximar casi cualquier función.

Redes Neuronales — Módulo 2: funciones de activación — por qué hace falta la no-linealidad