Leaky ReLU

Leaky ReLU (unidade linear retificada com fuga) é uma função de ativação que devolve a entrada sem alterações quando é positiva e a multiplica por um declive fixo pequeno, como 0.01, quando é negativa. Modifica a ReLU padrão, que produz zero para todas as entradas negativas, para que os valores negativos continuem a produzir uma pequena saída e, mais importante, um gradiente diferente de zero durante a retropropagação. Andrew Maas, Awni Hannun e Andrew Ng descreveram a função num estudo de 2013 sobre ativações retificadoras em modelos acústicos de reconhecimento de fala, usando um declive de 0.01. É utilizada em modelos de aprendizado profundo em que o fluxo de gradientes é importante, desde discriminadores de redes adversariais generativas a detetores de objetos YOLO mais antigos e unidades de processamento neural que executam modelos quantizados com ativações lineares por partes.

Como funciona a Leaky ReLU#

A Leaky ReLU calcula f(x) = x para x > 0 e f(x) = αx para x ≤ 0, em que o declive negativo α é um hiperparâmetro fixo entre 0 e 1. A derivada é 1 para entradas positivas e α para entradas negativas, pelo que cada entrada transmite algum gradiente aos pesos que a produziram. O declive habitual varia consoante a origem e a estrutura: nn.LeakyReLU do PyTorch usa 0.01 por predefinição, tf.nn.leaky_relu do TensorFlow usa 0.2 e a camada LeakyReLU do Keras usa 0.3. Este código passa entradas negativas pela ReLU e pela Leaky ReLU e calcula o gradiente de cada uma:

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

Apresenta ReLU(): output [0. 0. 0.], gradient [0. 0. 0.] e LeakyReLU(negative_slope=0.01): output [-0.03 -0.01 -0.005], gradient [0.01 0.01 0.01]. A ReLU não transmite qualquer gradiente destas entradas, pelo que a descida do gradiente não consegue alterar os pesos que as produziram, enquanto a Leaky ReLU transmite 1% do gradiente a montante.

O problema das ReLU inativas#

Um neurónio ReLU morre quando os seus pesos e o viés se alteram tanto que a pré-ativação é negativa para todas as entradas nos dados de treino. A sua saída passa então a ser sempre zero, o seu gradiente é sempre zero e os pesos de entrada nunca mais são atualizados, pelo que o neurónio fica permanentemente inutilizado na rede neuronal. Uma taxa de aprendizagem elevada ou uma grande atualização negativa do viés tornam esta situação mais provável. A Leaky ReLU mantém um pequeno gradiente no lado negativo, pelo que um neurónio que se desloque para a região negativa ainda pode ser recuperado:

O problema das ReLU inativas é diferente do problema do gradiente evanescente, no qual os gradientes diminuem gradualmente ao atravessar muitas camadas de funções saturantes, como sigmoid ou tanh.

Leaky ReLU vs. ativações relacionadas#

• ReLU: Produz zeros exatos para entradas negativas, o que torna as ativações esparsas e os cálculos baratos, mas pode fazer com que os neurónios deixem de funcionar. A Leaky ReLU abdica da esparsidade exata para manter um gradiente em todo o domínio.
• ReLU paramétrica (PReLU): Aprende o declive negativo durante o treino, normalmente um valor por canal, em vez de o fixar. Kaiming He e os seus colegas inicializaram o declive em 0.25, que também é o valor predefinido de nn.PReLU do PyTorch.
• SiLU e GELU: Curvas suaves que descem ligeiramente abaixo de zero para entradas negativas e não têm uma ponta acentuada em zero. SiLU é a predefinição nos modelos YOLO modernos, e GELU é comum em Transformers. Ambas exigem uma exponencial por valor, enquanto a Leaky ReLU só precisa de uma comparação e uma multiplicação.

Onde se utiliza a Leaky ReLU#

• Discriminadores DCGAN: A arquitetura DCGAN usou Leaky ReLU com um declive de 0.2 em todas as camadas do discriminador, para que o gerador recebesse gradientes úteis mesmo para imagens rejeitadas pelo discriminador; muitos GANs posteriores mantiveram esta escolha.
• Detetores YOLO iniciais: O YOLO original usou Leaky ReLU com um declive de 0.1 em todas as camadas, exceto na última, tal como o YOLOv2 e o YOLOv3; o YOLOv5 também a usou até ao lançamento da versão 4.0, em janeiro de 2021, que a substituiu por SiLU.
• Redes de atenção em grafos: Estas redes neuronais de grafos aplicam Leaky ReLU com um declive de 0.2 para avaliar o grau de atenção que cada nó deve prestar aos seus vizinhos.
• Aceleradores de IA na periferia: As unidades de processamento neural inteiras que executam modelos quantizados podem incorporar uma ativação linear por partes na convolução anterior. O DPU Xilinx da AMD faz isso com ReLU e Leaky ReLU, mas executa sigmoid e, por conseguinte, SiLU na CPU anfitriã.

Os ficheiros YAML dos modelos Ultralytics YOLO aceitam uma chave activation que substitui a SiLU predefinida em cada bloco de convolução padrão, permitindo treinar YOLO26 com activation: nn.LeakyReLU(0.1015625) para corresponder ao declive fixo do DPU de 26/256.