Leaky ReLU

Leaky ReLU (unidad lineal rectificada con fuga) es una función de activación que devuelve la entrada sin cambios cuando es positiva y la multiplica por una pendiente pequeña y fija, como 0.01, cuando es negativa. Modifica la ReLU estándar, que devuelve cero para todas las entradas negativas, de modo que los valores negativos generen una salida pequeña y, lo que es más importante, un gradiente distinto de cero durante la retropropagación. Andrew Maas, Awni Hannun y Andrew Ng describieron la función en un estudio de 2013 sobre activaciones rectificadoras en modelos acústicos para reconocimiento de voz, con una pendiente de 0.01. Se utiliza en modelos de aprendizaje profundo donde importa el flujo del gradiente, desde los discriminadores de redes generativas antagónicas hasta los detectores de objetos YOLO más antiguos y las unidades de procesamiento neuronal que ejecutan modelos cuantizados con activaciones lineales a trozos.

Cómo funciona Leaky ReLU#

Leaky ReLU calcula f(x) = x para x > 0 y f(x) = αx para x ≤ 0, donde la pendiente negativa α es un hiperparámetro fijo entre 0 y 1. Su derivada es 1 para las entradas positivas y α para las negativas, por lo que cada entrada devuelve parte del gradiente a los pesos que la generaron. La pendiente habitual varía según la fuente y el framework: nn.LeakyReLU de PyTorch tiene un valor predeterminado de 0.01, tf.nn.leaky_relu de TensorFlow, de 0.2, y la capa LeakyReLU de Keras, de 0.3. Este código pasa entradas negativas por ReLU y Leaky ReLU y calcula el gradiente de cada una:

import torch
from torch import nn

# Negative pre-activations, the inputs a ReLU unit turns into zeros
x = torch.tensor([-3.0, -1.0, -0.5], requires_grad=True)

for activation in (nn.ReLU(), nn.LeakyReLU(negative_slope=0.01)):
    y = activation(x)
    y.sum().backward()  # gradient that flows back toward the weights
    print(f"{activation}: output {y.detach().numpy()}, gradient {x.grad.numpy()}")
    x.grad = None

Imprime ReLU(): output [0. 0. 0.], gradient [0. 0. 0.] y LeakyReLU(negative_slope=0.01): output [-0.03 -0.01 -0.005], gradient [0.01 0.01 0.01]. ReLU no devuelve ningún gradiente a partir de estas entradas, por lo que el descenso del gradiente no puede cambiar los pesos que las generaron, mientras que Leaky ReLU devuelve el 1 % del gradiente ascendente.

El problema de las ReLU inactivas#

Una neurona ReLU muere cuando sus pesos y su sesgo cambian tanto que su preactivación es negativa para todas las entradas de los datos de entrenamiento. Entonces, su salida siempre es cero, su gradiente también es siempre cero y sus pesos de entrada ya no vuelven a actualizarse, por lo que la red neuronal pierde esa neurona de forma permanente. Una tasa de aprendizaje elevada o una gran actualización negativa del sesgo hace que esto sea más probable. Leaky ReLU mantiene un gradiente pequeño en la zona negativa, por lo que una neurona que se desplaza hacia la región negativa aún puede recuperarse:

El problema de las ReLU inactivas es distinto del problema del gradiente desvanecido, en el que los gradientes disminuyen gradualmente al pasar por muchas capas de funciones saturadas, como sigmoid o tanh.

Leaky ReLU y activaciones relacionadas#

• ReLU: Devuelve ceros exactos para las entradas negativas, lo que genera activaciones dispersas y abarata el cálculo, pero puede hacer que las neuronas se inactiven. Leaky ReLU renuncia a la dispersión exacta para mantener un gradiente en todas partes.
• ReLU paramétrica (PReLU): Aprende la pendiente negativa durante el entrenamiento, normalmente con un valor por canal, en lugar de fijarla. Kaiming He y sus colaboradores inicializaron la pendiente en 0.25, que también es el valor predeterminado de nn.PReLU de PyTorch.
• SiLU y GELU: Curvas suaves que bajan ligeramente de cero para las entradas negativas y no tienen un ángulo agudo en cero. SiLU es la opción predeterminada en los modelos YOLO modernos, y GELU es habitual en los Transformer. Ambas requieren una exponencial por valor, mientras que Leaky ReLU solo necesita una comparación y una multiplicación.

Usos de Leaky ReLU#

• Discriminadores de DCGAN: La arquitectura DCGAN utilizaba Leaky ReLU con una pendiente de 0.2 en cada capa del discriminador, de modo que el generador recibía gradientes útiles incluso para las imágenes que el discriminador rechazaba; muchos GAN posteriores mantuvieron esta elección.
• Primeros detectores YOLO: El YOLO original utilizaba Leaky ReLU con una pendiente de 0.1 en todas las capas salvo la última, al igual que YOLOv2 y YOLOv3; YOLOv5 la utilizó hasta su versión 4.0 de enero de 2021, que la sustituyó por SiLU.
• Redes de atención en grafos: Estas redes neuronales de grafos aplican Leaky ReLU con una pendiente de 0.2 al calcular cuánto debe prestar atención cada nodo a sus vecinos.
• Aceleradores de IA en el borde: Las unidades de procesamiento neuronal de enteros que ejecutan modelos cuantizados pueden integrar una activación lineal a trozos en la convolución anterior. La DPU de Xilinx de AMD lo hace con ReLU y Leaky ReLU, pero ejecuta sigmoid y, por tanto, SiLU en la CPU anfitriona.

Los archivos YAML de los modelos Ultralytics YOLO aceptan una clave activation que sustituye SiLU, la opción predeterminada en todos los bloques de convolución estándar; así, YOLO26 se puede entrenar con activation: nn.LeakyReLU(0.1015625) para que coincida con la pendiente fija de la DPU, de 26/256.