.. _sec_gru:
Gated Recurrent Units (GRU)
===========================
Em :numref:`sec_bptt`, discutimos como os gradientes são calculados em
RNNs. Em particular, descobrimos que produtos longos de matrizes podem
levar para gradientes desaparecendo ou explodindo. Vamos pensar
brevemente sobre como anomalias de gradiente significam na prática:
- Podemos encontrar uma situação em que uma observação precoce é
altamente significativo para prever todas as observações futuras.
Considere o caso inventado em que a primeira observação contém uma
soma de verificação e o objetivo é para discernir se a soma de
verificação está correta no final da sequência. Nesse caso, a
influência do primeiro token é vital. Gostaríamos de ter algum
mecanismos para armazenar informações precoces vitais em uma *célula
de memória*. Sem tal um mecanismo, teremos que atribuir um gradiente
muito grande a esta observação, uma vez que afeta todas as
observações subsequentes.
- Podemos encontrar situações em que alguns tokens não carreguem
observação. Por exemplo, ao analisar uma página da web, pode haver
Código HTML que é irrelevante para o propósito de avaliar o
sentimento transmitido na página. Gostaríamos de ter algum mecanismo
para *pular* tais tokens na representação do estado latente.
- Podemos encontrar situações em que haja uma quebra lógica entre as
partes de uma sequência. Por exemplo, pode haver uma transição entre
capítulos em um livro, ou uma transição entre um mercado de valores
em baixa e em alta. Neste caso seria bom ter um meio de *redefinir*
nosso estado interno representação.
Vários métodos foram propostos para resolver isso. Uma das mais antigas
é a memória de curto prazo longa :cite:`Hochreiter.Schmidhuber.1997`
que nós iremos discutir em :numref:`sec_lstm`. A unidade recorrente
fechada (GRU) :cite:`Cho.Van-Merrienboer.Bahdanau.ea.2014` é uma
variante um pouco mais simplificada que muitas vezes oferece desempenho
comparável e é significativamente mais rápido para computar
:cite:`Chung.Gulcehre.Cho.ea.2014`. Por sua simplicidade, comecemos
com o GRU.
Estado Oculto Fechado
---------------------
A principal distinção entre RNNs vanilla e GRUs é que o último suporta o
bloqueio do estado oculto. Isso significa que temos mecanismos dedicados
para quando um estado oculto deve ser *atualizado* e também quando deve
ser *redefinido*. Esses mecanismos são aprendidos e atendem às questões
listadas acima. Por exemplo, se o primeiro token é de grande importância
aprenderemos a não atualizar o estado oculto após a primeira observação.
Da mesma forma, aprenderemos a pular observações temporárias
irrelevantes. Por último, aprenderemos a redefinir o estado latente
sempre que necessário. Discutimos isso em detalhes abaixo.
Porta de Reinicialização e a Porta de Atualização
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
A primeira coisa que precisamos apresentar é a *porta de
reinicialização* e a *porta de atualização*. Nós os projetamos para
serem vetores com entradas em :math:`(0, 1)` para que possamos realizar
combinações convexas. Por exemplo, uma porta de reinicialização nos
permitiria controlar quanto do estado anterior ainda podemos querer
lembrar. Da mesma forma, uma porta de atualização nos permitiria
controlar quanto do novo estado é apenas uma cópia do antigo estado.
Começamos projetando esses portões. :numref:`fig_gru_1` ilustra as
entradas para ambos as portas de reset e atualização em uma GRU, dada a
entrada da etapa de tempo atual e o estado oculto da etapa de tempo
anterior. As saídas de duas portas são fornecidos por duas camadas
totalmente conectadas com uma função de ativação sigmóide.
.. _fig_gru_1:
.. figure:: ../img/gru-1.svg
Calculando a porta de reinicialização e a porta de atualização em um
modelo GRU.
Matematicamente, para um determinado intervalo de tempo $ t $, suponha
que a entrada seja um minibatch
:math:`\mathbf{X}_t \in \mathbb{R}^{n \times d}` (número de exemplos: $
n $, número de entradas: $ d $) e o estado oculto da etapa de tempo
anterior é :math:`\mathbf{H}_{t-1} \in \mathbb{R}^{n \times h}` (número
de unidades ocultas: $ h $). Então, reinicie o portão
:math:`\mathbf{R}_t \in \mathbb{R}^{n \times h}` e atualize o portão
:math:`\mathbf{Z}_t \in \mathbb{R}^{n \times h}` são calculados da
seguinte forma:
.. math::
\begin{aligned}
\mathbf{R}_t = \sigma(\mathbf{X}_t \mathbf{W}_{xr} + \mathbf{H}_{t-1} \mathbf{W}_{hr} + \mathbf{b}_r),\\
\mathbf{Z}_t = \sigma(\mathbf{X}_t \mathbf{W}_{xz} + \mathbf{H}_{t-1} \mathbf{W}_{hz} + \mathbf{b}_z),
\end{aligned}
onde
:math:`\mathbf{W}_{xr}, \mathbf{W}_{xz} \in \mathbb{R}^{d \times h}` e
:math:`\mathbf{W}_{hr}, \mathbf{W}_{hz} \in \mathbb{R}^{h \times h}` são
pesos de parâmetros e
:math:`\mathbf{b}_r, \mathbf{b}_z \in \mathbb{R}^{1 \times h}` são
viéses. Observe que a transmissão (consulte
:numref:`subsec_broadcasting`) é acionada durante a soma. Usamos
funções sigmóides (como introduzidas em :numref:`sec_mlp`) para
transformar os valores de entrada no intervalo :math:`(0, 1)`.
Estado Oculto do Candidato
~~~~~~~~~~~~~~~~~~~~~~~~~~
Em seguida, vamos integrar a porta de reset :math:`\mathbf {R} _t` com o
mecanismo regular de atualização de estado latente in
:eq:`rnn_h_with_state`. Isso leva ao seguinte *estado oculto
candidato* :math:`\tilde{\mathbf{H}}_t \in \mathbb{R}^{n \times h}` no
passo de tempo :math:`t`:
.. math:: \tilde{\mathbf{H}}_t = \tanh(\mathbf{X}_t \mathbf{W}_{xh} + \left(\mathbf{R}_t \odot \mathbf{H}_{t-1}\right) \mathbf{W}_{hh} + \mathbf{b}_h),
:label: gru_tilde_H
onde :math:`\mathbf{W}_{xh} \in \mathbb{R}^{d \times h}` and
:math:`\mathbf{W}_{hh} \in \mathbb{R}^{h \times h}` são parâmetros de
pesos, :math:`\mathbf{b}_h \in \mathbb{R}^{1 \times h}` é o viés, e o
símbolo :math:`\odot` é o operador de produto Hadamard (elemento a
elemento). Aqui, usamos uma não linearidade na forma de tanh para
garantir que os valores no estado oculto candidato permaneçam no
intervalo :math:`(-1, 1)`.
O resultado é um *candidato*, pois ainda precisamos incorporar a ação da
porta de atualização. Comparando com :eq:`rnn_h_with_state`, agora
a influência dos estados anteriores pode ser reduzido com o
multiplicação elementar de :math:`\mathbf{R}_t`
e\ :math:`\mathbf{H}_{t-1}` em :eq:`gru_tilde_H`. Sempre que as
entradas na porta de reset :math:`\mathbf{R}_t` estão perto de 1,
recuperamos um RNN vanilla como em :eq:`rnn_h_with_state`. Para
todas as entradas da porta de reset :math:`\mathbf{R}_t` que estão
próximas de 0, o estado oculto candidato é o resultado de um MLP com
:math:`\mathbf{X}_t` como a entrada. Qualquer estado oculto
pré-existente é, portanto, *redefinido* para os padrões.
:numref:`fig_gru_2` ilustra o fluxo computacional após aplicar a porta
de reset.
.. _fig_gru_2:
.. figure:: ../img/gru-2.svg
Calculando o estado oculto candidato em um modelo GRU.
Estados Escondidos
~~~~~~~~~~~~~~~~~~
Finalmente, precisamos incorporar o efeito da porta de atualização
:math:`\mathbf{Z}_t`. Isso determina até que ponto o novo estado oculto
:math:`\mathbf{H}_t \in \mathbb{R}^{n \times h}` é apenas o antigo
estado :math:`\mathbf{H}_{t-1}` e em quanto o novo estado candidato
:math:`\tilde{\mathbf{H}}_t` é usado. A porta de atualização
:math:`\mathbf{Z}_t` pode ser usada para este propósito, simplesmente
tomando combinações convexas elemento a elemento entre
:math:`\mathbf{H}_{t-1}` e :math:`\tilde{\mathbf{H}}_t`. Isso leva à
equação de atualização final para a GRU:
.. math:: \mathbf{H}_t = \mathbf{Z}_t \odot \mathbf{H}_{t-1} + (1 - \mathbf{Z}_t) \odot \tilde{\mathbf{H}}_t.
Sempre que a porta de atualização :math:`\mathbf{Z}_t` está próxima de
1, simplesmente mantemos o estado antigo. Neste caso, a informação de
:math:`\mathbf{X}_t` é essencialmente ignorada, pulando efetivamente o
passo de tempo :math:`t` na cadeia de dependências. Em contraste, sempre
que :math:`\mathbf{Z}_t` está próximo de 0, o novo estado latente
:math:`\mathbf{H}_t` se aproxima do estado latente candidato
:math:`\tilde{\mathbf{H}}_t`. Esses projetos podem nos ajudar a lidar
com o problema do gradiente de desaparecimento em RNNs e melhor capturar
dependências para sequências com grandes distâncias de intervalo de
tempo. Por exemplo, se a porta de atualização estiver perto de 1 para
todas as etapas de tempo de uma subsequência inteira, o antigo estado
oculto na etapa do tempo de seu início será facilmente retido e aprovado
até o fim, independentemente do comprimento da subsequência.
:numref:`fig_gru_3` ilustra o fluxo computacional depois que a porta
de atualização está em ação.
.. _fig_gru_3:
.. figure:: ../img/gru-3.svg
Computing the hidden state in a GRU model. Calculando o estado oculto
em um modelo GRU.
Em resumo, GRUs têm as duas características distintas a seguir:
- As portas de redefinição ajudam a capturar dependências de curto
prazo em sequências.
- Portas de atualização ajudam a capturar dependências de longo prazo
em sequências.
Implementação do zero
---------------------
Para entender melhor o modelo GRU, vamos implementá-lo do zero.
Começamos lendo o conjunto de dados da máquina do tempo que usamos em
:numref:`sec_rnn_scratch`. O código para ler o conjunto de dados é
fornecido abaixo.
.. raw:: html
.. raw:: html
.. code:: python
from mxnet import np, npx
from mxnet.gluon import rnn
from d2l import mxnet as d2l
npx.set_np()
batch_size, num_steps = 32, 35
train_iter, vocab = d2l.load_data_time_machine(batch_size, num_steps)
.. raw:: html
.. raw:: html
.. code:: python
import torch
from torch import nn
from d2l import torch as d2l
batch_size, num_steps = 32, 35
train_iter, vocab = d2l.load_data_time_machine(batch_size, num_steps)
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
def get_params(vocab_size, num_hiddens, device):
num_inputs = num_outputs = vocab_size
def normal(shape):
return np.random.normal(scale=0.01, size=shape, ctx=device)
def three():
return (normal((num_inputs, num_hiddens)),
normal((num_hiddens, num_hiddens)),
np.zeros(num_hiddens, ctx=device))
W_xz, W_hz, b_z = three() # Update gate parameters
W_xr, W_hr, b_r = three() # Reset gate parameters
W_xh, W_hh, b_h = three() # Candidate hidden state parameters
# Output layer parameters
W_hq = normal((num_hiddens, num_outputs))
b_q = np.zeros(num_outputs, ctx=device)
# Attach gradients
params = [W_xz, W_hz, b_z, W_xr, W_hr, b_r, W_xh, W_hh, b_h, W_hq, b_q]
for param in params:
param.attach_grad()
return params
.. raw:: html
.. raw:: html
.. code:: python
def get_params(vocab_size, num_hiddens, device):
num_inputs = num_outputs = vocab_size
def normal(shape):
return torch.randn(size=shape, device=device)*0.01
def three():
return (normal((num_inputs, num_hiddens)),
normal((num_hiddens, num_hiddens)),
torch.zeros(num_hiddens, device=device))
W_xz, W_hz, b_z = three() # Update gate parameters
W_xr, W_hr, b_r = three() # Reset gate parameters
W_xh, W_hh, b_h = three() # Candidate hidden state parameters
# Output layer parameters
W_hq = normal((num_hiddens, num_outputs))
b_q = torch.zeros(num_outputs, device=device)
# Attach gradients
params = [W_xz, W_hz, b_z, W_xr, W_hr, b_r, W_xh, W_hh, b_h, W_hq, b_q]
for param in params:
param.requires_grad_(True)
return params
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
def init_gru_state(batch_size, num_hiddens, device):
return (np.zeros(shape=(batch_size, num_hiddens), ctx=device), )
.. raw:: html
.. raw:: html
.. code:: python
def init_gru_state(batch_size, num_hiddens, device):
return (torch.zeros((batch_size, num_hiddens), device=device), )
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
def gru(inputs, state, params):
W_xz, W_hz, b_z, W_xr, W_hr, b_r, W_xh, W_hh, b_h, W_hq, b_q = params
H, = state
outputs = []
for X in inputs:
Z = npx.sigmoid(np.dot(X, W_xz) + np.dot(H, W_hz) + b_z)
R = npx.sigmoid(np.dot(X, W_xr) + np.dot(H, W_hr) + b_r)
H_tilda = np.tanh(np.dot(X, W_xh) + np.dot(R * H, W_hh) + b_h)
H = Z * H + (1 - Z) * H_tilda
Y = np.dot(H, W_hq) + b_q
outputs.append(Y)
return np.concatenate(outputs, axis=0), (H,)
.. raw:: html
.. raw:: html
.. code:: python
def gru(inputs, state, params):
W_xz, W_hz, b_z, W_xr, W_hr, b_r, W_xh, W_hh, b_h, W_hq, b_q = params
H, = state
outputs = []
for X in inputs:
Z = torch.sigmoid((X @ W_xz) + (H @ W_hz) + b_z)
R = torch.sigmoid((X @ W_xr) + (H @ W_hr) + b_r)
H_tilda = torch.tanh((X @ W_xh) + ((R * H) @ W_hh) + b_h)
H = Z * H + (1 - Z) * H_tilda
Y = H @ W_hq + b_q
outputs.append(Y)
return torch.cat(outputs, dim=0), (H,)
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
vocab_size, num_hiddens, device = len(vocab), 256, d2l.try_gpu()
num_epochs, lr = 500, 1
model = d2l.RNNModelScratch(len(vocab), num_hiddens, device, get_params,
init_gru_state, gru)
d2l.train_ch8(model, train_iter, vocab, lr, num_epochs, device)
.. parsed-literal::
:class: output
perplexity 1.1, 10376.2 tokens/sec on gpu(0)
time traveller with a slight accession ofcheerfulness really thi
traveller fomest dow shall that that as then as we sat and
.. figure:: output_gru_b77a34_39_1.svg
.. raw:: html
.. raw:: html
.. code:: python
vocab_size, num_hiddens, device = len(vocab), 256, d2l.try_gpu()
num_epochs, lr = 500, 1
model = d2l.RNNModelScratch(len(vocab), num_hiddens, device, get_params,
init_gru_state, gru)
d2l.train_ch8(model, train_iter, vocab, lr, num_epochs, device)
.. parsed-literal::
:class: output
perplexity 1.1, 23915.5 tokens/sec on cuda:0
time travelleryou can show black is white by argument said filby
travelleryou can show black is white by argument said filby
.. figure:: output_gru_b77a34_42_1.svg
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
gru_layer = rnn.GRU(num_hiddens)
model = d2l.RNNModel(gru_layer, len(vocab))
d2l.train_ch8(model, train_iter, vocab, lr, num_epochs, device)
.. parsed-literal::
:class: output
perplexity 1.1, 85024.4 tokens/sec on gpu(0)
time travelleryou can show black is white by argument said filby
travelleryou can show black is white by argument said filby
.. figure:: output_gru_b77a34_48_1.svg
.. raw:: html
.. raw:: html
.. code:: python
num_inputs = vocab_size
gru_layer = nn.GRU(num_inputs, num_hiddens)
model = d2l.RNNModel(gru_layer, len(vocab))
model = model.to(device)
d2l.train_ch8(model, train_iter, vocab, lr, num_epochs, device)
.. parsed-literal::
:class: output
perplexity 1.0, 302984.3 tokens/sec on cuda:0
time travelleryou can show black is white by argument said filby
travelleryou can show black is white by argument said filby
.. figure:: output_gru_b77a34_51_1.svg
.. raw:: html
.. raw:: html
.. raw:: html
`Discussão `__
.. raw:: html
.. raw:: html
`Discussão `__
.. raw:: html
.. raw:: html