RNN 과 LSTM: 한 칸씩 읽으며 기억을 넘기기
문장, 소리, 센서 값처럼 순서가 있는 자료인 시퀀스(sequence)는 앞에서 본 것을 기억하며 읽어야 뜻이 통합니다. 첫 칸(타임스텝, time step)에 넣은 신호가 스무 칸 뒤에 얼마나 남는지, 단순 RNN 과 LSTM 을 나란히 놓고 막대를 움직여 보세요.
한 줄 답. RNN(순환 신경망)은 순서가 있는 자료를 한 칸씩 읽으며, 지금까지 읽은 것의 요약(은닉 상태, hidden state)을 다음 칸에 넘기는 신경망입니다: hₜ = tanh(W·hₜ₋₁ + U·xₜ + b). 칸마다 같은 값을 되풀이해 곱하므로 먼 과거의 신호가 금방 사라집니다. LSTM 은 따로 둔 기억인 셀 상태(cell state)를 세 게이트(gate: 망각·입력·출력)로 다뤄 이 문제를 크게 줄입니다: cₜ = fₜ·cₜ₋₁ + iₜ·gₜ.
왼쪽은 상태가 숫자 하나인 단순 RNN 입니다. 첫 칸에만 1 을 넣고 나머지 칸에는 0 을 넣었습니다. 막대 높이는 「첫 칸의 상태를 조금 흔들면 t 번째 칸의 상태가 그 몇 배만큼 흔들리나」입니다. 학습에서 오차를 거꾸로 보낼 때도 같은 곱을 지납니다. 오른쪽은 LSTM 의 셀 상태 길로만 본 같은 값이고, 망각 게이트가 모든 칸에서 같은 값 f 라고 두었습니다. 작게 줄인 본보기입니다. 진짜 RNN 의 상태는 숫자 수백 개짜리 벡터이고 w 자리에 행렬 W 가 곱해집니다. 진짜 LSTM 의 망각 게이트는 칸마다 입력을 보고 새로 계산되고, 셀 상태 말고 다른 길로도 신호가 흐릅니다.
1. RNN 이란: 한 칸씩 읽고 상태를 넘긴다
문장은 낱말의 시퀀스이고, 소리는 짧은 시각마다 잰 값의 시퀀스이고, 주가는 날마다 적은 숫자의 시퀀스입니다. 이런 자료는 순서에 뜻이 있습니다. 「개가 사람을 물었다」와 「사람이 개를 물었다」는 같은 낱말로 다른 말을 합니다. 그래서 칸을 하나씩 따로 보지 않고, 앞에서 본 것을 기억하며 읽어야 합니다.
RNN 은 이 일을 가장 단순하게 합니다. 시퀀스를 한 칸씩 읽고, 칸마다 은닉 상태 h 라는 숫자 묶음을 고칩니다. 상태는 「지금까지 읽은 것의 요약」입니다. 새 칸을 읽으면 지난 상태와 새 입력을 섞어 새 상태를 만들고, 그것을 다음 칸에 넘깁니다.
hₜ = tanh(W·hₜ₋₁ + U·xₜ + b)
xₜ: t 번째 칸의 입력(낱말 하나를 숫자 묶음으로 바꾼 것 등).hₜ₋₁: 바로 앞 칸이 넘겨준 상태. 맨 처음h₀은 보통 0 입니다.W: 지난 상태에 곱하는 순환 가중치(recurrent weight, 이 쪽에서는 w).U: 입력에 곱하는 가중치.b: 편향(bias).tanh: 어떤 수든 −1 ~ 1 사이로 눌러 주는 함수. 상태가 끝없이 커지지 않게 합니다.
중요한 점은 모든 칸이 같은 W, U, b 를 쓴다는 것입니다. 그래서 시퀀스의 길이가 달라도 같은 신경망으로 읽을 수 있고, 학습할 숫자의 수가 길이에 따라 늘지 않습니다. 시퀀스를 다 읽은 뒤의 상태로 시퀀스 전체를 판정하거나(스팸인가), 칸마다의 상태로 다음 칸을 맞힙니다(다음 낱말). 학습은 시퀀스를 칸별로 펼쳐 놓고 역전파를 하는 것과 같고, 이것을 시간 역전파(BPTT)라고 부릅니다.
왼쪽 고리는 칸 하나와 자기에게 돌아오는 화살표이고, 오른쪽은 그것을 칸 넷으로 펼친 것입니다. 초록 화살표 W 와 파랑 화살표 U 는 모든 칸에서 같은 가중치이고, 고리 칸에는 지금 칸의 값이 나옵니다. 「다음」을 누르면 한 칸씩 계산합니다. 주황 바탕이 이번에 계산한 칸, 점선 칸은 아직 계산하지 않은 칸이고, 맨 아래에 그 셈이 있습니다. 숫자는 2절과 같습니다(W = 1, U = 1, b = 0, 입력은 첫 칸만 1, h₀ = 0). h₄ = 0.51 은 2절의 표를 한 칸 더 이은 값입니다. 셈 안의 앞 칸 값은 셋째 자리까지 적어, 그 숫자로 손계산해도 결과가 맞습니다. 2절의 표는 둘째 자리까지 줄여 적은 값이고, 계산은 줄이지 않은 값으로 합니다. 위 단추로 입출력 꼴을 고르면 입력(아래)과 출력(위) 화살표가 붙는 칸이 바뀝니다.
2. 손으로 따라가기: 세 칸
위 실험의 왼쪽과 같은 숫자로 해 봅니다. 상태가 숫자 하나이고 W = w = 1, U = 1, b = 0 입니다. 입력은 첫 칸만 1 이고 나머지는 0, 처음 상태 h₀ = 0 입니다.
- 첫 칸.
h₁ = tanh(1·0 + 1·1) = tanh(1) = 0.76. - 둘째 칸. 입력이 0 이라 지난 상태만 들어갑니다.
h₂ = tanh(1·0.76) = 0.64. - 셋째 칸.
h₃ = tanh(0.64) = 0.57. - 첫 칸의 신호가 둘째 칸에 얼마나 가나. h₁ 을 조금 흔들면 h₂ 는
w × (tanh 의 기울기) = w × (1 − h₂²) = 1 × (1 − 0.64²) = 0.59배만큼 흔들립니다. - 셋째 칸까지. 한 번 더 곱합니다.
1 × (1 − 0.57²) = 0.68,0.59 × 0.68 = 0.40.
| 칸 t | 1 | 2 | 3 |
|---|---|---|---|
| 상태 hₜ | 0.76 | 0.64 | 0.57 |
| 이번 칸에 곱한 비 w × (1 − hₜ²) | − | 0.59 | 0.68 |
| 첫 칸의 신호가 남은 몫 | 1 | 0.59 | 0.40 |
칸을 하나 지날 때마다 1 보다 작은 수가 곱해집니다. 이것이 스무 칸 쌓이면 실험의 0.04 가 됩니다.
3. 먼 과거를 잊는 까닭: 같은 값을 되풀이해 곱한다
첫 칸의 신호가 t 번째 칸까지 가려면 칸마다 w × (1 − hₖ²) 를 한 번씩, 모두 t − 1 번 곱합니다. 거꾸로, 학습에서 t 번째 칸의 오차를 첫 칸까지 돌려보낼 때도 같은 곱을 지납니다. 같은 크기의 수를 여러 번 곱하면 이렇게 됩니다.
- 1 보다 작으면 0 으로 빠르게 줄어듭니다. 0.5 를 열아홉 번 곱하면 0.000002 쯤입니다. 먼 과거가 학습에 거의 영향을 주지 못합니다. 이것이 기울기 소실입니다.
- 1 보다 크면 걷잡을 수 없이 커집니다. 이것이 기울기 폭발입니다. 학습이 한 번에 크게 튀어 망가집니다. 기울기의 크기에 상한을 두고 잘라 내는 방법(기울기 클리핑)으로 흔히 막습니다.
- 꼭 1 에 맞추기도 어렵습니다. tanh 의 기울기
1 − h²는 1 이하이고, 상태가 ±1 에 가까울수록 0 에 가까워집니다. 이 실험에서는 w 를 키우면 상태가 1 쪽으로 몰려 오히려 덜 남습니다. 상태가 0 근처에 머무는 동안 w 가 1 보다 크면 곱이 커질 수 있습니다.
자세한 이야기와 다른 해결책은 기울기 소실 쪽에 있습니다.
해 볼 것. ① 처음(w = 1)에는 20번째 칸에 0.04 가 남습니다. ② w 를 0.5 로 내리면 1.6e−6, 곧 0.0000016 입니다. ③ w 를 2 로 올리면 더 남을 것 같지만 4.1e−15 로 더 작아집니다. 상태가 h₂ = 0.91, h₃ = 0.95 로 1 쪽에 몰려 tanh 의 기울기가 작아졌기 때문입니다. w 를 0.1 씩 바꿔 보면 w = 1 일 때 가장 많이 남는데, 그래도 0.04 입니다. ④ 오른쪽 LSTM 은 f = 0.9 에서 0.14, 0.95 에서 0.38, 0.99 에서 0.83 이 남고, f = 1 이면 1 이 그대로 남습니다. w 나 f 가 0 이면 둘 다 둘째 칸부터 0 입니다.
4. LSTM: 셀 상태 식이 만들어지는 과정
LSTM(장단기 메모리)은 상태를 둘로 나눕니다. 밖으로 내보내는 hₜ 와, 안에 두고 다음 칸으로 넘기는 셀 상태 cₜ 입니다. 셀 상태는 기억을 실어 나르는 띠라고 생각하면 됩니다. 이 띠에서 무엇을 지우고 무엇을 더할지를 게이트 셋이 정합니다. 게이트는 0 ~ 1 사이의 수이고, 곱해서 「얼마나 통과시킬지」를 정합니다. 0 이면 막고, 1 이면 다 통과시킵니다.
게이트는 모두 같은 모양으로 계산합니다: 게이트 = σ(w·hₜ₋₁ + u·xₜ + b). σ(시그모이드)는 어떤 수든 0 ~ 1 사이로 바꾸는 함수이고, 게이트마다 자기 w, u, b 를 따로 학습합니다. 아래는 작은 고정 예입니다. 지난 상태 hₜ₋₁ = 0.5, 입력 xₜ = 1, 지난 셀 상태 cₜ₋₁ = 2 입니다.
| 무엇 | w, u, b | 괄호 안의 합 | 값 |
|---|---|---|---|
| 망각 게이트 fₜ | 1, 0.5, 0 | 1·0.5 + 0.5·1 + 0 = 1 | σ(1) = 0.73 |
| 입력 게이트 iₜ | 0, 1, −1 | 0·0.5 + 1·1 − 1 = 0 | σ(0) = 0.5 |
| 후보 값 gₜ | 2, 1, 0 | 2·0.5 + 1·1 + 0 = 2 | tanh(2) = 0.96 |
| 출력 게이트 oₜ | 0, −1, 0 | 0·0.5 − 1·1 + 0 = −1 | σ(−1) = 0.27 |
후보 값 gₜ 는 게이트가 아니라 「새로 넣을 내용」이라, σ 대신 tanh 로 −1 ~ 1 사이의 값을 냅니다.
「다음」을 누르면 한 단계씩 넘어갑니다. 위 식에 한 조각씩 붙고(주황 바탕이 이번에 붙은 조각), 화살표가 값이 가는 길과 그 셈을 보이고, 막대가 그만큼 바뀌고, 아래에 까닭이 나옵니다. 흐린 회색은 지난 칸, 초록은 남긴 것, 주황 점선은 덜어낸 것, 파랑은 더한 것(아래 파랑 점선은 새 정보가 떠난 자리), 보라는 밖으로 내보내는 hₜ 입니다.
- 그대로 넘기기:
cₜ = cₜ₋₁. 2 를 손대지 않고 넘깁니다. 곱하는 것이 없으니 몇 칸을 가도 줄지 않습니다. 단순 RNN 이 잊는 까닭이 「칸마다 곱하기」였으니 좋은 출발점입니다. 하지만 이대로는 지울 수도 넣을 수도 없습니다. - 망각 게이트로 덜어내기:
cₜ = fₜ·cₜ₋₁.0.73 × 2 = 1.46이 남고 0.54 가 지워집니다. 까닭: 더 쓸모없어진 기억을 지워야 새것이 들어갈 자리가 생깁니다. 얼마나 지울지는 fₜ 가 칸마다 입력을 보고 정합니다. - 입력 게이트만큼 더하기:
cₜ = fₜ·cₜ₋₁ + iₜ·gₜ.0.5 × 0.96 = 0.48을 더해1.46 + 0.48 = 1.94. 까닭: 새 내용 gₜ 를 다 넣지 않고 입력 게이트 iₜ 만큼만 넣습니다. 그리고 새 내용은 더해지므로, 지난 기억에 곱해지는 것은 fₜ 하나뿐입니다. 단순 RNN 은 칸마다 W 를 곱하고 tanh 를 지나야 했지만, 셀 상태 길에서는 fₜ 만 곱해집니다. fₜ 가 1 에 가까우면 기억이 여러 칸을 지나도 거의 줄지 않습니다. 이것이 실험 오른쪽의 막대입니다. - 출력 게이트로 꺼내기:
hₜ = oₜ·tanh(cₜ).tanh(1.94) = 0.96,0.27 × 0.96 = 0.26. 까닭: 기억하는 것을 지금 다 드러낼 필요는 없습니다. 셀 상태는 1.94 를 그대로 다음 칸에 넘기고, 밖(다음 층과 다음 칸의 게이트들)에는 0.26 만 보여 줍니다.
진짜 LSTM 에서는 h, c, x 가 벡터이고 w, u 가 행렬이며, 게이트와의 곱 · 은 같은 자리끼리 곱하기입니다. 식의 모양은 PyTorch 의 nn.LSTM 문서(출처)와 같습니다.
해 볼 것. ① 「다음」을 한 번 누르면 가운데 막대가 초록 1.46 과 주황 점선 0.54 로 갈립니다. ② 한 번 더 누르면 파랑 0.48 이 붙어 1.94 가 됩니다. 덜어낸 0.54 가 더한 0.48 보다 커서 지난 값 2 보다 조금 줄었습니다. ③ 마지막 단계에서 셀 상태는 1.94 인데 밖으로는 0.26 만 나갑니다. 출력 게이트가 0.27 로 작기 때문입니다.
5. 세 게이트와 GRU 한눈에
| 이름 | 식 | 하는 일 |
|---|---|---|
| 망각 게이트 | fₜ = σ(W_f·hₜ₋₁ + U_f·xₜ + b_f) | 지난 셀 상태를 얼마나 남길지 |
| 입력 게이트 | iₜ = σ(W_i·hₜ₋₁ + U_i·xₜ + b_i) | 새 내용을 얼마나 넣을지 |
| 후보 값 | gₜ = tanh(W_g·hₜ₋₁ + U_g·xₜ + b_g) | 넣을 새 내용 |
| 출력 게이트 | oₜ = σ(W_o·hₜ₋₁ + U_o·xₜ + b_o) | 셀 상태를 밖으로 얼마나 보일지 |
| 셀 상태 | cₜ = fₜ·cₜ₋₁ + iₜ·gₜ | 다음 칸으로 넘기는 기억 |
| 은닉 상태 | hₜ = oₜ·tanh(cₜ) | 다음 층과 다음 칸이 보는 값 |
GRU(게이트 순환 유닛)는 게이트를 둘(업데이트 게이트 zₜ, 리셋 게이트 rₜ)로 줄이고 셀 상태를 따로 두지 않는 변형입니다. 새 후보 nₜ 와 지난 상태를 업데이트 게이트로 섞습니다: hₜ = (1 − zₜ)·nₜ + zₜ·hₜ₋₁(PyTorch 의 nn.GRU 표기).
hₜ = (1 − zₜ)·nₜ + zₜ·hₜ₋₁. 리셋 게이트 rₜ 는 후보 nₜ 를 만드는 tanh 로 들어갑니다(PyTorch 의 nn.GRU 식). 쪽에 GRU 의 숫자 예가 없어 숫자는 적지 않았습니다.6. 꼭 알아야 할 성질
| 성질 | 쉬운 말 | 실험에서 |
|---|---|---|
| 모든 칸이 같은 가중치 | 길이가 달라도 같은 신경망으로 읽는다. 학습할 숫자가 길이에 따라 늘지 않는다 | 20칸 모두 같은 w |
| 상태의 크기가 정해져 있다 | 아무리 긴 시퀀스도 같은 크기의 상태 하나에 요약한다. 메모리는 일정하지만 담을 수 있는 양에 한계가 있다 | 상태가 숫자 하나 |
| 차례로만 계산한다 | t 번째 칸은 t − 1 번째 상태가 나와야 계산할 수 있다. 한 시퀀스 안의 칸들을 동시에 계산하지 못한다 | 막대를 왼쪽부터 하나씩 계산 |
| 되풀이해 곱한다 | 먼 칸의 신호와 기울기가 곱으로 줄거나 커진다 | 왼쪽 막대가 줄어드는 모양 |
| LSTM 의 셀 상태 길은 fₜ 만 곱한다 | 망각 게이트가 1 에 가까우면 기억이 오래 간다. 게이트의 값은 학습으로 정해진다 | 오른쪽 막대 |
7. 시퀀스를 다른 시퀀스로 바꾸기: 인코더와 디코더
번역은 입력 시퀀스와 출력 시퀀스의 길이가 다르고 낱말의 순서도 다릅니다. 칸마다 답을 하나씩 내는 방식으로는 풀 수 없습니다. 그래서 RNN 둘을 이어 붙입니다.
- 인코더(encoder). 입력 시퀀스를 끝까지 읽기만 합니다. 다 읽은 뒤의 상태가 「문장 전체의 요약」이고, 크기가 정해진 숫자 묶음 하나입니다.
- 디코더(decoder). 그 요약을 처음 상태로 받아 출력 시퀀스를 한 칸씩 써 냅니다. 방금 쓴 낱말을 다음 칸의 입력으로 다시 넣고, 「끝」 표시를 쓰면 멈춥니다.
이 짜임을 seq2seq(시퀀스에서 시퀀스로)라고 부릅니다. 2014년에 LSTM 둘로 만든 논문과 GRU 둘로 만든 논문이 나왔습니다(출처). 학습할 때는 디코더가 틀린 낱말을 써도 다음 칸에는 정답 낱말을 넣어 줍니다(교사 강요, teacher forcing). 앞에서 한 번 틀렸다고 뒤가 모두 어긋나지 않게 하려는 것입니다.
약한 곳은 문맥 벡터(context vector) 하나입니다. 문장이 다섯 낱말이든 쉰 낱말이든 같은 크기의 숫자 묶음 하나에 담아야 하고, 디코더는 그것만 보고 씁니다. 2014년의 다른 논문(출처)은 이 고정된 크기의 벡터를 병목으로 보고, 디코더가 낱말을 하나 쓸 때마다 인코더가 칸마다 남긴 상태 전부에서 지금 필요한 곳을 찾아보게 했습니다. 이것이 어텐션의 시작이고, 다음 절에서 자세히 봅니다. 그다음 걸음이 RNN 을 아예 빼고 어텐션만 남긴 트랜스포머입니다(9절).
「인코더」와 「디코더」는 RNN 에만 쓰는 말이 아닙니다. 입력을 숫자 묶음으로 바꾸는 쪽이 인코더, 숫자 묶음에서 출력을 만들어 내는 쪽이 디코더입니다. 같은 낱말이 여러 모델에 나옵니다.
| 어디 | 인코더가 하는 일 | 디코더가 하는 일 |
|---|---|---|
| seq2seq(이 절) | 입력 문장을 읽어 상태에 담는다 | 그 상태에서 출력 문장을 써 낸다 |
| 오토인코더와 VAE | 자료를 숫자 몇 개로 줄인다 | 그 숫자에서 자료를 다시 만든다 |
| 트랜스포머 | 입력의 모든 칸이 서로를 보며 칸마다 표현을 만든다 | 앞에 쓴 것과 인코더의 출력을 보며 다음 낱말을 낸다 |
| 언어 모델 | 인코더만 쓰는 모델(BERT 형): 글을 읽고 판정한다 | 디코더만 쓰는 모델(GPT 형): 글을 이어 쓴다 |
| 영상 분할(U-Net) | 그림을 줄여 가며 무엇이 있는지 모은다 | 다시 키워 가며 어디에 있는지 칸마다 답한다 |
8. 인코더·디코더에 어텐션을 붙이기
7절의 디코더는 원문이 얼마나 길든 인코더의 마지막 상태 하나만 보고 씁니다. 원문 전체를 벡터 하나에 눌러 담는 이 자리가 병목입니다(Bahdanau 외, 출처). 어텐션은 디코더가 낱말을 하나 낼 때마다 인코더가 칸마다 남긴 상태 전부를 다시 보게 합니다. 아래는 Luong 외(출처)의 전역 어텐션입니다. 「전역」은 늘 원문의 모든 낱말을 본다는 뜻이고, 한 번에 원문의 일부만 보는 「지역」 어텐션과 비교하는 이름입니다.
디코더가 t 번째 낱말을 낼 때마다 네 가지를 합니다.
- 점수. 지금 디코더 상태 hₜ 와 모든 인코더 상태 h̄ₛ 를 하나씩 맞춰 점수를 냅니다. 가장 단순한 것은 내적입니다.
- 비율. 점수들을 softmax 로 합이 1 인 정렬 가중치(alignment weight) aₜ 로 바꿉니다.
- 문맥 벡터. 그 비율로 인코더 상태를 섞어(가중 평균) 문맥 벡터 cₜ 를 만듭니다.
- 낱말. cₜ 와 hₜ 를 이어 붙여 h̃ₜ 를 만들고, h̃ₜ 에서 낱말 yₜ 의 확률을 냅니다.
다음 낱말에서는 디코더 상태가 바뀌었으니 ① 부터 다시 합니다. 비율은 낱말마다 새로 정해집니다.
score(hₜ, h̄ₛ) = hₜᵀ h̄ₛ
aₜ(s) = exp(score(hₜ, h̄ₛ)) ÷ Σₛ′ exp(score(hₜ, h̄ₛ′))
cₜ = Σₛ aₜ(s)·h̄ₛ
h̃ₜ = tanh(W_c [cₜ ; hₜ])
p(yₜ | y<t, x) = softmax(W_s h̃ₜ)
hₜ: 디코더가 t 번째 낱말을 낼 때의 상태.h̄ₛ: 인코더가 원문의 s 번째 칸을 읽고 남긴 상태. 머리 위의 줄은 디코더의 상태와 가르는 표시입니다.score: 둘이 얼마나 맞는지의 점수. 여기서는 내적(dot)hₜᵀ h̄ₛ. 논문은 학습하는 행렬 W_a 를 가운데 끼운 generalhₜᵀ W_a h̄ₛ와, 둘을 이어 붙여 작은 층에 넣는 concatv_aᵀ tanh(W_a [hₜ ; h̄ₛ])도 적었습니다.aₜ(s): t 번째 낱말을 낼 때 원문 s 번째 칸에 주는 정렬 가중치. 0 ~ 1 이고, s 에 대해 모두 더하면 1.Σₛ′: 원문의 모든 칸 s′ 에 대해 더하기. softmax 의 분모입니다.cₜ: 문맥 벡터. 비율대로 섞은 인코더 상태이고, 낱말마다 새로 만듭니다.[cₜ ; hₜ]: 두 벡터를 이어 붙인 것. 두 칸짜리 둘이면 네 칸짜리 하나가 됩니다.W_c,W_s: 학습하는 행렬. W_c 는 이어 붙인 것을 h̃ₜ 로, W_s 는 h̃ₜ 를 낱말마다의 점수로 바꿉니다.tanh는 −1 ~ 1 로 누르는 함수(1절).h̃ₜ: 문맥 벡터와 디코더 상태를 합친 상태. 낱말을 고르는 데 씁니다.p(yₜ | y<t, x): 원문 x 와 앞서 낸 낱말들 y<t 를 알 때 t 번째 낱말이 yₜ 일 확률.
어텐션 쪽의 낱말로 옮기면 아래와 같습니다. 계산 순서(내적 → softmax → 섞기)도 그 쪽의 3절과 같습니다.
| 이 절 | 어텐션 쪽 | 하는 일 |
|---|---|---|
| 디코더 상태 hₜ | 쿼리(query) q | 지금 무엇을 찾는지 |
| 인코더 상태 h̄ₛ | 키(key) k 이자 값 v | 맞춰 볼 이름표이자 섞을 내용. 여기서는 같은 벡터를 둘 다로 쓴다 |
| 정렬 가중치 aₜ | 비율(③ 소프트맥스) | 원문 칸마다 얼마나 참고할지 |
| 문맥 벡터 cₜ | 섞은 결과(④ 새 벡터) | 비율대로 섞은 정보 |
어텐션 쪽은 q, k, v 를 서로 다른 행렬로 따로 만들고 내적을 √d 로 나눈다는 점이 다릅니다. 이 어텐션에서 RNN 을 빼고 어텐션만 남긴 것이 트랜스포머입니다(9절).
아래 실험은 지어낸 짧은 번역입니다: 「나는 어제 사과를 먹었다」 → 「I ate apples yesterday」. 한국어는 동사가 끝에 오고 영어는 주어 바로 뒤에 와서, 낱말마다 맞는 원문 칸이 차례대로 가지 않습니다. 인코더와 디코더의 상태는 숫자 두 칸짜리 지어낸 값입니다. 진짜 상태는 학습으로 만들어지고 숫자 수백 개입니다. W_c 와 W_s 는 학습하지 않으므로 ④ 의 낱말은 미리 정해 둔 번역입니다. 점수, 비율, 문맥 벡터는 이 값들로 실제로 계산했습니다.
「다음」을 누르면 번역 낱말마다 ① 점수 ② 비율 ③ 문맥 벡터 ④ 낱말 네 단계로 넘어갑니다. 파랑 칸은 원문 낱말과 인코더 상태, 빨강 칸은 디코더 상태(점선 테두리는 아직 오지 않은 칸)입니다. 빨강 화살표는 지금 디코더 칸에서 원문 칸들로 갑니다(① 숫자 = 점수, ② 굵기와 숫자 = 비율). 파랑 화살표는 원문 칸들이 비율만큼 초록 상자의 문맥 벡터로 모이는 길이고(③), 검은 화살표는 cₜ 가 hₜ 와 합쳐 낱말로 가는 길입니다(④). 아래 맞춤 표는 칸이 진할수록 비율이 크고, 빨강 테두리가 지금 낱말의 줄입니다.
해 볼 것. ① 「다음」을 한 번 누르면 I 의 비율이 나옵니다: 나는 0.76, 어제 0.17, 사과를 0.01, 먹었다 0.06. ② 네 번 더 누르면 ate 의 점수에서 먹었다 가 2 로 가장 크고, 한 번 더 누르면 비율이 먹었다 0.7, 사과를 0.26 입니다. 원문의 넷째 칸으로 건너뜁니다. ③ 문맥 벡터는 가장 큰 비율을 받은 상태 쪽으로 기웁니다: c₁ = (1.48, 0.21) 은 나는 의 (2, 0) 쪽, c₂ = (−0.44, −1.37) 은 먹었다 의 (0, −2) 쪽입니다. ④ 16단계 끝까지 가면 맞춤 표의 가장 진한 칸이 I–나는, ate–먹었다, apples–사과를, yesterday–어제 로, 대각선이 아니라 엇갈려 있습니다.
9. 트랜스포머에 밀린 까닭과 아직 쓰이는 곳
트랜스포머 논문(출처)은 4절에서 RNN 과 비교해 두 가지를 짚었습니다.
- 차례로만 계산합니다. RNN 은 칸 t 를 계산하려면 칸 t − 1 이 끝나야 합니다. 길이가 n 이면 n 번을 차례로 기다립니다. 트랜스포머의 어텐션은 한 층 안의 모든 칸을 한꺼번에 계산하므로 GPU 에서 학습이 훨씬 빠릅니다.
- 먼 칸을 한 번에 잇지 못합니다. 첫 칸의 정보가 100번째 칸에 닿으려면 상태를 99 번 거쳐야 하고, 그동안 곱이 쌓입니다. 어텐션은 어느 두 칸이든 바로 이어 봅니다.
대신 트랜스포머는 모든 칸의 짝을 보므로 계산과 메모리가 길이의 제곱으로 늘고, 순서를 알려면 위치 정보를 따로 넣어야 합니다(트랜스포머).
RNN 과 LSTM 이 아직 쓰이는 곳은 한 칸씩 들어오는 자료를 바로바로 처리해야 할 때입니다. 상태 하나만 들고 다음 칸을 기다리면 되므로, 시퀀스가 아무리 길어져도 칸마다 드는 계산과 메모리가 같습니다. 실시간 센서 값, 기기 안의 작은 소리·신호 처리, 작은 모델로 충분한 시계열 예측이 이런 경우입니다.
10. 언제 무엇을 쓰나
| 선택지 | 좋은 점 | 나쁜 점 | 쓰는 경우 |
|---|---|---|---|
| 단순 RNN | 가장 단순하고 작다. 칸마다 계산과 메모리가 일정하다 | 먼 과거를 금방 잊는다(기울기 소실·폭발). 차례로만 계산한다 | 바로 앞 몇 칸만 보면 되는 짧은 시퀀스, 원리 익히기 |
| LSTM · GRU | 게이트 덕분에 단순 RNN 보다 훨씬 먼 과거를 붙잡는다. 칸마다 계산과 메모리가 일정해 끝없이 들어오는 자료도 처리한다 | 차례로만 계산해 긴 시퀀스의 학습이 느리다. 아주 먼 거리는 여전히 어렵다 | 실시간으로 들어오는 신호·센서 값, 작은 기기, 모델이 작아도 되는 시계열 |
| 트랜스포머 | 모든 칸을 한꺼번에 계산해 학습이 빠르다. 어느 두 칸이든 바로 잇는다 | 계산과 메모리가 길이의 제곱으로 는다. 위치 정보를 따로 넣어야 한다 | 긴 글, 번역, 언어 모델처럼 먼 문맥이 중요하고 자료가 많을 때 |
| 1차원 합성곱 | 가까운 몇 칸의 무늬를 찾는 필터를 모든 자리에 한꺼번에 댄다. 빠르다 | 한 층이 보는 범위가 필터 폭만큼이라, 먼 거리를 보려면 층을 쌓거나 칸을 건너뛰며 봐야 한다 | 소리 파형, 센서 신호, 글자 시퀀스에서 짧은 무늬 찾기(합성곱) |
어디에 쓰나
- 다음 값 맞히기. 센서 값이나 수요 같은 시계열의 다음 칸을 칸마다의 상태로 맞힙니다.
- 시퀀스 전체 판정. 문장을 끝까지 읽은 뒤의 상태로 스팸인지, 긍정인지 가립니다.
- 칸마다 판정. 낱말마다 사람 이름인지, 장소인지 표시합니다.
- 시퀀스를 다른 시퀀스로. 번역처럼 입력 시퀀스를 읽어 상태에 담고, 그 상태에서 다른 시퀀스를 한 칸씩 써 냅니다(인코더와 디코더).
- 실시간 처리. 기기 안에서 한 칸씩 들어오는 소리·신호를 일정한 메모리로 처리합니다.
자주 묻는 것
LSTM 은 기울기 소실을 완전히 없애나요?
아닙니다. 셀 상태 길에서 곱해지는 것이 망각 게이트 하나라서, 망각 게이트가 1 에 가까우면 오래 남습니다. 하지만 망각 게이트가 0.9 여도 스무 칸 뒤에는 0.14 만 남고, 게이트를 거치는 다른 길에서는 여전히 줄어듭니다. 단순 RNN 보다 훨씬 먼 과거를 붙잡는다는 뜻이지, 얼마나 멀든 기억한다는 뜻은 아닙니다.
LSTM 과 GRU 가운데 무엇을 쓰나요?
GRU 는 게이트가 둘이라 같은 크기에서 학습할 숫자가 LSTM 의 4 분의 3 이고 계산이 조금 가볍습니다. 어느 쪽이 더 잘 되는지는 과제와 자료에 따라 다릅니다. 둘 다 돌려 보고 검증 자료의 점수로 고르는 것이 안전합니다.
트랜스포머가 있는데 RNN 을 알아야 하나요?
네. 상태를 넘기며 읽는다, 같은 가중치를 되풀이해 쓴다, 곱이 쌓이면 기울기가 사라진다는 생각이 순서 자료를 다루는 바탕이고, 트랜스포머가 무엇을 풀었는지도 이것을 알아야 보입니다. 또 한 칸씩 들어오는 자료를 일정한 메모리로 처리해야 하는 곳에서는 지금도 씁니다.
RNN 의 어텐션과 트랜스포머의 어텐션은 무엇이 다른가요?
계산의 뼈대는 같습니다. 점수를 내고, softmax 로 합이 1 인 비율로 바꾸고, 그 비율로 섞습니다. 다른 점은 셋입니다. 첫째, 여기서는 디코더 RNN 의 상태가 쿼리이고 인코더 상태가 키이자 값이지만, 트랜스포머는 낱말 벡터에 서로 다른 행렬 셋을 곱해 쿼리·키·값을 따로 만듭니다. 둘째, 여기서 쓴 dot 점수는 내적을 그대로 쓰고, 트랜스포머는 내적을 √d 로 나눕니다. 셋째, 여기서는 RNN 이 칸을 차례로 읽어 상태를 만들고 어텐션은 그 위에 붙지만, 트랜스포머는 RNN 을 빼고 어텐션만으로 칸들을 잇습니다.
낱말
| 여기서 쓴 말 | 책에서 부르는 말 |
|---|---|
| 순서가 있는 자료 | 시퀀스(sequence), 시계열(time series) |
| 칸 | 타임스텝(time step) t |
| 상태 hₜ | 은닉 상태(hidden state) |
| 한 칸씩 읽으며 상태를 넘기는 신경망 | 순환 신경망(recurrent neural network, RNN) |
| 시간으로 펼치기 | unrolling(unfolding in time) |
| 입출력 꼴(여럿 → 하나, 하나 → 여럿, 여럿 → 여럿) | many-to-one, one-to-many, many-to-many |
| 지난 상태에 곱하는 가중치 W, w | 순환 가중치(recurrent weight) |
| 칸을 거슬러 가는 역전파 | 시간 역전파(backpropagation through time, BPTT) |
| 기울기가 사라짐 · 터짐 | 기울기 소실(vanishing gradient) · 기울기 폭발(exploding gradient) |
| 기울기 크기에 상한 두기 | 기울기 클리핑(gradient clipping) |
| 장단기 메모리 | long short-term memory(LSTM) |
| 곱해서 통과시킬 몫을 정하는 0 ~ 1 의 수 | 게이트(gate) |
| 지울 몫 · 넣을 몫 · 내보낼 몫을 정하는 게이트 | 망각 게이트(forget gate) · 입력 게이트(input gate) · 출력 게이트(output gate) |
| 기억을 실어 나르는 띠 cₜ | 셀 상태(cell state) |
| 후보 값 gₜ | 후보 셀 상태(candidate). PyTorch 문서는 cell gate 라고 부른다 |
| σ | 시그모이드(sigmoid) |
| 게이트가 둘인 변형 | 게이트 순환 유닛(gated recurrent unit, GRU). 업데이트 게이트(update gate), 리셋 게이트(reset gate) |
| 시퀀스를 읽고 다른 시퀀스를 써 내는 짜임 | 인코더-디코더(encoder-decoder), seq2seq(sequence to sequence) |
| 문장 전체의 요약, 8절의 cₜ | 문맥 벡터(context vector). 7절은 하나를 끝까지 쓰고, 어텐션을 쓰면 낱말마다 새로 만든다 |
| 원문 칸마다 참고할 몫 aₜ | 정렬 가중치(alignment weights) |
| 늘 원문 전체를 보는 어텐션 | 전역 어텐션(global attention). 한 번에 일부만 보는 것은 지역 어텐션(local attention) |
| 학습 때 디코더에 정답 낱말을 넣어 주기 | 교사 강요(teacher forcing) |
| 1차원 합성곱 | 1D convolution, 시간 합성곱(temporal convolution) |
출처
- Sepp Hochreiter, Jürgen Schmidhuber, Long Short-Term Memory, Neural Computation. 세포 상태와 문을 처음 제안한 논문.
- PyTorch 문서: nn.LSTM, nn.GRU. 이 쪽의 식 표기(iₜ, fₜ, gₜ, oₜ, cₜ, hₜ, GRU 의 zₜ, rₜ, nₜ)와 가중치 묶음의 수.
- Kyunghyun Cho 외, Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation, arXiv:1406.1078. GRU 와 인코더-디코더.
- Ilya Sutskever, Oriol Vinyals, Quoc V. Le, Sequence to Sequence Learning with Neural Networks, arXiv:1409.3215. LSTM 하나가 입력 줄을 크기가 정해진 벡터로 바꾸고 다른 LSTM 이 그 벡터에서 출력 줄을 풀어내는 짜임.
- Dzmitry Bahdanau, Kyunghyun Cho, Yoshua Bengio, Neural Machine Translation by Jointly Learning to Align and Translate, arXiv:1409.0473. 고정 길이 벡터를 병목으로 보고, 낱말을 낼 때마다 입력 문장에서 관련 있는 곳을 찾아보게 함.
- Luong, Pham, Manning, Effective Approaches to Attention-based Neural Machine Translation, arXiv:1508.04025. 늘 원문의 모든 낱말을 보는 전역 어텐션과 한 번에 일부만 보는 지역 어텐션, 점수 dot·general·concat, h̃ₜ = tanh(W_c[cₜ ; hₜ]), 문맥 벡터는 aₜ 에 따른 원문 상태의 가중 평균. 8절의 식과 그림의 구도.
- Ashish Vaswani 외, Attention Is All You Need, arXiv:1706.03762. 4절: 차례로 해야 하는 계산의 수와 먼 칸 사이의 길이를 RNN 과 견줌.