ReLU (Rectified Linear Unit)

A unidade linear retificada (ReLU) é a função de ativação f(x) = max(0, x): deixa as entradas positivas passarem sem alteração e produz zero para todas as demais. Essa simples comparação dá a uma rede neural (NN) a não linearidade necessária para aprender padrões curvos, com custo computacional quase nulo. A ReLU tornou-se a ativação padrão das camadas ocultas no aprendizado profundo depois que Vinod Nair e Geoffrey Hinton a usaram em 2010 e que AlexNet, uma rede neural convolucional (CNN) baseada em ReLUs, venceu o desafio ImageNet de 2012. Ela continua sendo a referência para comparar ativações mais recentes, como SiLU e GELU.

Como funciona a ReLU#

A derivada da ReLU é 1 para entradas positivas e 0 para entradas negativas. Em zero, a derivada não está definida, e frameworks como PyTorch usam 0. Esses dois valores explicam as principais propriedades da ReLU:

• Baixo custo computacional: A passagem direta consiste em comparar com zero e a passagem inversa, em aplicar uma máscara, sem exponenciais como as da sigmoide ou da tanh.
• Sem saturação para entradas positivas: Um gradiente exatamente igual a 1 atravessa cada unidade ativa sem alterações, então os sinais de erro não diminuem ao retropropagar por muitas camadas, o que combate o problema do desvanecimento do gradiente causado por funções saturantes.
• Ativações esparsas: Toda entrada negativa se torna exatamente zero, então apenas parte de uma camada fica ativa a cada instante. Com pesos inicializados aleatoriamente, cerca de metade das unidades de uma camada produz zero para determinada entrada.
• Linear por partes: Uma rede construída com ReLUs calcula uma função linear por partes de sua entrada, com muitas regiões lineares unidas nos pontos em que as unidades são ativadas ou desativadas.

O exemplo PyTorch abaixo aplica nn.ReLU e usa autograd para calcular seu gradiente nos mesmos pontos:

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()}")

Ele imprime as saídas [0.0, 0.0, 0.0, 0.5, 2.0] e os gradientes [0.0, 0.0, 0.0, 1.0, 1.0]. As entradas positivas passam sem alterar seus gradientes, enquanto as entradas negativas e o zero não recebem gradiente algum; isso explica tanto a esparsidade da ReLU quanto seu principal modo de falha.

O problema das ReLU inativas#

Uma unidade ReLU cuja entrada é negativa para todos os exemplos dos dados de treinamento produz zero e recebe gradiente zero, então seus pesos nunca mais mudam e a unidade fica efetivamente inativa. As unidades geralmente morrem quando uma grande atualização de pesos, muitas vezes causada por uma taxa de aprendizado alta, empurra o viés muito para o negativo. Algumas unidades inativas têm pouco impacto, mas uma execução mal ajustada pode desativar grande parte de uma camada. A inicialização He, que escala os pesos iniciais para camadas ReLU, junto com taxas de aprendizado moderadas e a normalização em lotes, mantém a maioria das unidades ativa; as variantes leaky eliminam o problema porque nunca deixam o gradiente chegar a zero.

Variantes da ReLU#

• Leaky ReLU: Multiplica as entradas negativas por uma pequena inclinação fixa, normalmente 0,01, para que as unidades inativas continuem recebendo gradiente.
• PReLU: Aprende a inclinação negativa durante o treinamento. Kaiming He e colegas a apresentaram em 2015, no mesmo artigo que propôs a inicialização He.
• ReLU6: Limita a saída a 6, min(max(0, x), 6), mantendo as ativações em um intervalo bem representado pela aritmética de baixa precisão. MobileNetV1 e MobileNetV2 a utilizam.
• ELU: Substitui o lado negativo por uma curva exponencial suave que satura em −1, aproximando de zero a média das ativações.
• SiLU e GELU: Curvas suaves, x · σ(x) e x · Φ(x), que se comportam como a ReLU para entradas grandes, mas deixam passar pequenos valores negativos e não têm uma quina em zero. Custam mais por elemento, e o artigo sobre GELU relatou ganhos em relação à ReLU em todas as tarefas de visão, linguagem e fala avaliadas.

ReLU versus sigmoide e tanh#

Antes da ReLU, as camadas ocultas usavam sigmoide ou tanh. Ambas saturam: para entradas muito positivas ou negativas, suas curvas se achatam e as derivadas se aproximam de zero; além disso, a derivada da sigmoide nunca ultrapassa 0,25, nem mesmo no ponto mais inclinado. Multiplicar essas derivadas ao longo de muitas camadas priva as camadas iniciais do gradiente. No artigo da AlexNet, uma CNN de quatro camadas com ReLUs atingiu 25% de erro de treinamento no CIFAR-10 seis vezes mais rápido que a mesma rede com unidades tanh. A sigmoide e a tanh continuam em uso quando seus intervalos limitados são desejáveis: a sigmoide nas camadas de saída para probabilidades e nas portas de células recorrentes, e a tanh nos estados ocultos recorrentes.

ReLU em modelos modernos#

ResNet e a maioria das CNNs de sua época usam ReLU em todas as camadas, e o transformer original de 2017 a usava nas camadas feedforward. Muitos modelos mais recentes adotaram funções mais suaves: GELU no BERT e nos transformers de visão, e SwiGLU em muitos modelos de linguagem grandes atuais; a ReLU continua comum onde a velocidade e o suporte de hardware são prioritários. YOLO26 usa SiLU por padrão em seus blocos Conv, e uma linha activation: nn.ReLU() no YAML do modelo substitui a SiLU pela ReLU em todos os blocos Conv antes do treinamento, o que é adequado para aceleradores como o AMD Zynq UltraScale+ DPU, que executa ReLU nativamente, mas não SiLU. No PyTorch, nn.ReLU(inplace=True) sobrescreve seu tensor de entrada com o resultado, economizando a memória de um tensor de saída separado.