Redes recorrentes
Processe sequências com um estado oculto realizado ao longo do tempo e veja por que LSTMs e GRUs foram inventados.
- Execute uma célula recorrente em uma sequência, carregando um estado oculto
- Explique a retropropagação ao longo do tempo e por que os gradientes desaparecem ou explodem em longas sequências
- Descreva como as portas LSTM e GRU ajudam e por que os transformadores substituíram os RNNs
Texto, fala, leituras de sensores e música são sequências, onde a ordem é importante e a duração varia. Uma rede neural recorrente (RNN) lê uma sequência, uma etapa de cada vez, e carrega um estado oculto - um resumo contínuo de tudo até agora:
Os mesmos pesos , e são usados em cada etapa - compartilhamento de peso novamente, desta vez em tempo - para que uma pequena rede lide com sequências de qualquer comprimento. Para prever, coloque uma camada densa no estado oculto final (para classificar uma sequência inteira) ou em cada estado (para rotular cada etapa ou prever a próxima).
1import numpy as np
2
3W_x = np.array([[0.5], [-1.0]]) # input (1) -> hidden (2)
4W_h = np.array([[0.8, 0.0], [0.3, 0.5]]) # hidden -> hidden
5b = np.zeros(2)
6
7h = np.zeros(2)
8for t, x in enumerate([1.0, 0.0, 0.0, 2.0]):
9 h = np.tanh(W_x @ [x] + W_h @ h + b)
10 print(f"t={t} x={x} h={np.round(h, 3)}")t=0 x=1.0 h=[ 0.462 -0.762] t=1 x=0.0 h=[ 0.354 -0.238] t=2 x=0.0 h=[ 0.276 -0.013] t=3 x=2.0 h=[ 0.84 -0.958]
Observe o desbotamento da memória: a entrada em t=0 ainda ecoa através do estado oculto em t=2, um pouco mais fraca a cada passo.
Retropropagação ao longo do tempo
Para treinar um RNN, desenrole: uma cópia da célula por intervalo de tempo, todos compartilhando pesos, depois retropropague por toda a cadeia - retropropagação ao longo do tempo (BPTT). Os gradientes dos pesos compartilhados são somados em cada etapa.
Aqui está o problema. O gradiente que atinge o passo 1 a partir do passo 50 foi multiplicado pelos pesos recorrentes e pela inclinação de tanh 49 vezes. Multiplique por 0,5 quarenta e nove vezes e você obterá cerca de - o gradiente desaparece e a rede não consegue aprender dependências de longo alcance. Multiplique por 1,5 e ele explode. (O recorte gradiente doma as explosões; o desaparecimento precisa de um novo design.)
LSTMs e GRUs
O LSTM (memória de longo e curto prazo, 1997) adiciona um estado de célula separado que percorre o tempo como uma esteira transportadora, alterado apenas por adições e multiplicações controladas. Três portas - pequenas camadas sigmóides que produzem valores entre 0 e 1 - controlam-no:
- o forget gate decide o que apagar do estado da célula,
- a porta de entrada decide quais novas informações escrever,
- a porta de saída decide o que revelar como estado oculto.
Quando a porta de esquecimento permanece próxima de 1, os gradientes fluem de volta ao longo do estado da célula quase inalterados - o mesmo truque de uma conexão residual. O GRU (2014) é uma variante mais simples de duas portas que geralmente também funciona bem.
Os LSTMs governaram a tradução e a fala até 2017. Seu ponto fraco: a etapa t não pode ser iniciada até que a etapa t-1 seja concluída, portanto, eles não são paralelizados em uma GPU. Transformers processam todas as posições de uma só vez com atenção – próxima lição.
Principais conclusões
RNNs carregam um estado oculto através de uma sequência, usando os mesmos pesos em cada etapa.
O treinamento os desenrola no tempo (BPTT); gradientes são multiplicados uma vez por etapa.
Em sequências longas, os gradientes desaparecem ou explodem; o recorte lida com explosões.
LSTMs e GRUs usam portas e um estado de célula aditivo para lembrar por mais tempo; transformadores os substituíram por paralelização com atenção.
Quiz da aula
7 perguntas · aprovação com 5 acertos · até 50 XP
Ao passar, você conclui a aula e mantém sua sequência. As perguntas erradas voltarão em sessões de revisão.
Pratique: escreva código em Python
Escreva código Python no editor e execute os testes com exemplos. O Python roda localmente no navegador usando WebAssembly.
Execute um RNN
O código inicial possui um pequeno RNN (1 entrada, 2 unidades ocultas). A entrada é uma sequência de números em uma linha. Execute o RNN sobre ele a partir de um estado oculto zero e imprima o estado oculto de cada etapa como t=0 h=0.462 -0.762 (3 casas decimais), então final: positive se a primeira unidade oculta terminar acima de 0, caso contrário, final: negative.
- Quatro etapas
- Entradas negativas
O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.
Gradientes ao longo do tempo
Em um RNN linear simples, o gradiente que atinge a etapa 1 da etapa T é escalonado pelo peso recorrente w uma vez por etapa: . Cada linha de entrada tem um peso w. Para T = 10, 50 e 100 imprima a escala em notação científica com 2 casas decimais e um veredicto para T = 100: vanishing (abaixo de 1e-3), exploding (acima de 1e3) ou stable:
w=0.9: T=10 3.87e-01 T=50 5.73e-03 T=100 2.95e-05 -> vanishing- Três pesos
O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.
Dúvidas sobre esta lição
Travou em algum ponto? Pergunte. Descobriu algo? Compartilhe. Explicar também é uma ótima forma de aprender.
Carregando publicações…