ReLU (Rectified Linear Unit)

La unidad lineal rectificada (ReLU) es la función de activación f(x) = max(0, x): transmite sin cambios las entradas positivas y devuelve cero para todo lo demás. Esa única comparación proporciona a una red neuronal (NN) la no linealidad que necesita para aprender patrones curvos, con un coste computacional casi nulo. ReLU se convirtió en la activación predeterminada de las capas ocultas del aprendizaje profundo después de que Vinod Nair y Geoffrey Hinton la usaran en 2010 y AlexNet, una red neuronal convolucional (CNN) basada en ReLU, ganara el desafío ImageNet de 2012. Sigue siendo la referencia con la que se comparan activaciones más recientes, como SiLU y GELU.

Cómo funciona ReLU#

La derivada de ReLU es 1 para las entradas positivas y 0 para las negativas. Exactamente en cero, la derivada no está definida, y marcos de trabajo como PyTorch usan 0. Esos dos valores explican las principales propiedades de ReLU:

• Barata de calcular: La pasada hacia delante consiste en una comparación con cero y la pasada hacia atrás, en una máscara, sin exponenciales como las de sigmoid o tanh.
• Sin saturación para entradas positivas: Un gradiente exactamente igual a 1 atraviesa sin cambios todas las unidades activas, así que las señales de error no se reducen al propagarse hacia atrás por muchas capas, lo que contrarresta el problema del desvanecimiento del gradiente que causan las funciones saturantes.
• Activaciones dispersas: Todas las entradas negativas se convierten en cero exacto, así que en cada momento solo está activa una parte de la capa. Con pesos inicializados al azar, aproximadamente la mitad de las unidades de una capa devuelve cero para una entrada determinada.
• Lineal a trozos: Una red construida con ReLU calcula una función lineal a trozos de su entrada, con muchas regiones lineales unidas en los puntos donde las unidades se activan o se desactivan.

El siguiente ejemplo de PyTorch aplica nn.ReLU y usa autograd para calcular su gradiente en los mismos puntos:

import torch
from torch import nn

relu = nn.ReLU()

# Inputs on both sides of zero, tracked so PyTorch can compute gradients
x = torch.tensor([-2.0, -0.5, 0.0, 0.5, 2.0], requires_grad=True)
y = relu(x)

# Backpropagate a gradient of 1 from each output to its input
y.sum().backward()

print(f"Output:   {y.tolist()}")
print(f"Gradient: {x.grad.tolist()}")

Imprime las salidas [0.0, 0.0, 0.0, 0.5, 2.0] y los gradientes [0.0, 0.0, 0.0, 1.0, 1.0]. Las entradas positivas se transmiten con su gradiente intacto, mientras que las entradas negativas y el cero no reciben ningún gradiente, origen tanto de la dispersión de ReLU como de su principal modo de fallo.

El problema de las ReLU inactivas#

Una unidad ReLU cuya entrada es negativa para todos los ejemplos de los datos de entrenamiento devuelve cero y recibe un gradiente cero, por lo que sus pesos no vuelven a cambiar y la unidad queda prácticamente muerta. Las unidades suelen morir cuando una gran actualización de pesos, a menudo causada por una tasa de aprendizaje alta, empuja su sesgo muy por debajo de cero. Unas pocas unidades muertas apenas afectan, pero un entrenamiento mal ajustado puede matar gran parte de una capa. La inicialización de He, que escala los pesos iniciales de las capas ReLU, junto con tasas de aprendizaje moderadas y la normalización por lotes, mantiene activas a la mayoría de las unidades; las variantes con fuga eliminan el problema al no dejar nunca que el gradiente llegue a cero.

Variantes de ReLU#

• Leaky ReLU: Multiplica las entradas negativas por una pequeña pendiente fija, normalmente 0,01, para que las unidades inactivas sigan recibiendo un gradiente.
• PReLU: Aprende la pendiente negativa durante el entrenamiento. Kaiming He y sus colegas la presentaron en 2015, en el mismo artículo en el que propusieron la inicialización de He.
• ReLU6: Limita la salida a 6, min(max(0, x), 6), lo que mantiene las activaciones en un intervalo que se representa bien con aritmética de baja precisión. MobileNetV1 y MobileNetV2 la usan.
• ELU: Sustituye el lado negativo por una curva exponencial suave que se satura en −1 y acerca a cero las activaciones medias.
• SiLU y GELU: Curvas suaves, x · σ(x) y x · Φ(x), que se comportan como ReLU para entradas grandes, pero transmiten valores negativos pequeños y no presentan un ángulo en cero. Cuestan más por elemento, y el artículo sobre GELU comunicó mejoras sobre ReLU en todas las tareas de visión, lenguaje y voz que evaluó.

ReLU frente a sigmoid y tanh#

Antes de ReLU, las capas ocultas usaban sigmoid o tanh. Ambas se saturan: para entradas positivas o negativas grandes, sus curvas se aplanan y sus derivadas se aproximan a cero; la derivada de sigmoid ni siquiera supera 0,25 en su punto más pronunciado. Al multiplicar esas derivadas a través de muchas capas, las capas iniciales se quedan sin gradiente. En el artículo de AlexNet, una CNN de cuatro capas con ReLU alcanzó un error de entrenamiento del 25 % en CIFAR-10 seis veces más rápido que la misma red con unidades tanh. Sigmoid y tanh siguen usándose cuando sus intervalos acotados son precisamente lo que se necesita: sigmoid en las capas de salida para obtener probabilidades y en las compuertas de las celdas recurrentes, y tanh en los estados ocultos recurrentes.

ReLU en los modelos modernos#

ResNet y la mayoría de las CNN de su época usan ReLU en todas las capas, y el transformer original de 2017 la usaba en sus capas feedforward. Muchos modelos más recientes han pasado a funciones más suaves: GELU en BERT y los transformers de visión, y SwiGLU en muchos modelos de lenguaje grandes actuales; ReLU sigue siendo habitual cuando la velocidad y la compatibilidad con el hardware son prioritarias. YOLO26 usa SiLU de forma predeterminada en sus bloques Conv, y una línea activation: nn.ReLU() en el YAML del modelo sustituye ReLU en todos los bloques Conv antes del entrenamiento, una opción adecuada para aceleradores como la DPU AMD Zynq UltraScale+, que ejecutan ReLU de forma nativa, pero no SiLU. En PyTorch, nn.ReLU(inplace=True) sobrescribe su tensor de entrada con el resultado, lo que ahorra la memoria de un tensor de salida independiente.