Gated Recurrent Unit (GRU)

Uma unidade recorrente com gates (GRU) é uma célula de rede neural recorrente (RNN) que processa uma sequência passo a passo e usa dois gates aprendidos, um gate de atualização e um gate de reinicialização, para decidir quanto de sua memória manter e quanto substituir em cada etapa. Kyunghyun Cho e colegas a apresentaram em 2014 em um codificador-decodificador RNN para tradução automática. Os gates permitem que os gradientes fluam por muitas etapas temporais, então uma GRU aprende dependências de longo alcance melhor que uma RNN simples, que sofre do problema do gradiente evanescente. A GRU é uma versão simplificada da rede de memória de longo e curto prazo (LSTM): tem um estado oculto em vez de dois e três blocos de pesos em vez de quatro, e é usada em análise de séries temporais, fala e outros dados sequenciais.

Como funciona uma GRU#

Em cada passo temporal t, uma GRU combina a entrada atual xₜ com o estado oculto anterior hₜ₋₁. Dois gates usam a função sigmoide para gerar valores entre 0 e 1 para cada elemento do estado:

• Gate de reinicialização: rₜ = σ(Wᵣxₜ + Uᵣhₜ₋₁ + bᵣ) decide quanto do estado anterior usar ao propor novo conteúdo. Valores próximos de 0 permitem que a célula ignore seu histórico, o que ajuda em limites como o início de uma nova frase.
• Gate de atualização: zₜ = σ(W_z xₜ + U_z hₜ₋₁ + b_z) decide quanto do estado anterior manter. Valores próximos de 1 copiam o estado antigo quase sem alteração, permitindo que as informações persistam por intervalos longos.
• Estado candidato: h̃ₜ = tanh(Wxₜ + U(rₜ ⊙ hₜ₋₁) + b) propõe novo conteúdo com base na entrada e no histórico escalado pela reinicialização, usando tanh para manter os valores entre −1 e 1.
• Novo estado: hₜ = (1 − zₜ) ⊙ h̃ₜ + zₜ ⊙ hₜ₋₁ combina o candidato com o estado antigo, elemento a elemento.

Quando o gate de atualização permanece próximo de 1, o novo estado é quase uma cópia do antigo, e o gradiente retropropaga por essa cópia com pouca atenuação. Esse caminho aditivo desempenha o mesmo papel que o estado da célula em uma LSTM. As equações acima seguem o artigo original, no qual zₜ pondera o estado antigo; alguns textos invertem as funções de zₜ e 1 − zₜ, descrevendo a mesma célula. A nn.GRU do PyTorch usa a mesma combinação, mas aplica o gate de reinicialização após a multiplicação matricial, como rₜ ⊙ (Uhₜ₋₁ + b), uma variante bastante usada do estado candidato.

GRU no PyTorch#

O trecho abaixo executa uma GRU sobre uma sequência de vetores de características, como características por quadro de um vídeo, e compara seu tamanho com o de uma LSTM da mesma largura:

import torch
from torch import nn

# A sequence of 64-dim features from 5 video frames: (batch, time, features)
frames = torch.randn(1, 5, 64)

# A GRU with a 128-dim hidden state, and an LSTM of the same size for comparison
gru = nn.GRU(input_size=64, hidden_size=128, batch_first=True)
lstm = nn.LSTM(input_size=64, hidden_size=128, batch_first=True)

# outputs holds the hidden state at every step; h_n is the final state
outputs, h_n = gru(frames)
print(f"Outputs: {tuple(outputs.shape)}, final state: {tuple(h_n.shape)}")

# GRU weights cover 3 blocks (reset, update, candidate); LSTM weights cover 4
gru_params = sum(p.numel() for p in gru.parameters())
lstm_params = sum(p.numel() for p in lstm.parameters())
print(f"GRU: {gru_params:,} parameters, LSTM: {lstm_params:,} parameters")

Ele exibe Outputs: (1, 5, 128), final state: (1, 1, 128) e GRU: 74,496 parameters, LSTM: 99,328 parameters. A GRU retorna um estado de 128 dimensões por quadro, além do estado final, que resume toda a sequência para um classificador subsequente, e precisa exatamente de três quartos dos parâmetros da LSTM.

GRU, LSTM e Transformers#

• LSTM: Mantém um estado de célula separado junto ao estado oculto e usa três gates (entrada, esquecimento e saída). A GRU combina os dois estados e elimina o gate de saída, por isso treina mais rápido por etapa e tem menos parâmetros. Em uma comparação empírica de Junyoung Chung e colegas, em 2014, GRUs e LSTMs tiveram desempenho semelhante na modelagem de música polifônica e sinais de fala; na prática, nenhuma delas vence consistentemente em todas as tarefas.
• RNN simples: Substitui todo o estado a cada etapa, sem gates, então seus gradientes desaparecem ou explodem em sequências longas e ela tem dificuldade para conectar eventos separados por intervalos longos.
• Transformer: Processa todas as posições de uma sequência em paralelo com atenção, treina muito mais rápido em GPUs e lida melhor com contextos de longo alcance; por isso, Transformers substituíram redes recorrentes na maioria das tarefas de linguagem. Uma GRU mantém um estado de tamanho constante e um custo constante por etapa, independentemente do comprimento da sequência, o que ainda é adequado para áudio em streaming, dados de sensores e dispositivos pequenos.

Aplicações#

• Fluxo óptico: O RAFT, vencedor do prêmio de melhor artigo da ECCV 2020, refina sua estimativa de fluxo ao longo de muitas iterações com uma GRU convolucional, uma GRU em que as multiplicações matriciais são substituídas por convoluções e o estado é um mapa de características.
• Manutenção preditiva e previsão: GRUs leem fluxos de dados de vibração, temperatura ou demanda e preveem falhas ou valores futuros, muitas vezes em hardware embarcado, onde um modelo pequeno é importante.
• Fala e áudio: Modelos de áudio executados no dispositivo usam GRUs porque processam o áudio quadro a quadro com pouca memória fixa. O supressor de ruído RNNoise executa suas camadas GRU em tempo real em uma CPU comum.
• Reconhecimento de ações: Uma GRU lê uma sequência de características por quadro ou pontos-chave e gera um rótulo de ação para o clipe. O YOLO26 no modo de rastreamento atribui a cada pessoa um ID persistente entre quadros, gerando sequências por pessoa de caixas ou pontos-chave de pose que uma GRU desse tipo classifica.