RNN에서 어텐션까지: 순서를 다루는 신경망

앞의 기억을 다음 칸으로 넘기며 읽는 RNN을 손으로 계산해 보고, 60칸 전의 기울기가 10의 -17승으로 사라지는 장면을 숫자로 확인해요. 맨 앞 숫자 기억하기 실험으로 RNN이 실패하는 곳에서 LSTM과 어텐션이 성공하는 것을 보고, 질문·열쇠·값으로 이뤄진 어텐션을 직접 계산한 뒤, 트랜스포머와 언어 모델의 인과 마스크까지 연결해요.

고급강의 6 / 6약 12분

"개가 사람을 물었다"와 "사람이 개를 물었다"는 같은 단어로 이뤄져 있지만 뜻이 완전히 달라요. 글, 말소리, 주가, 센서 기록처럼 순서가 의미를 만드는 데이터를 다루려면 신경망이 순서를 알아야 해요. 이번 강의에서는 순서를 기억하며 읽는 RNN에서 출발해, 그 한계를 넘어선 어텐션까지 따라가요. 어텐션은 ChatGPT와 Claude 같은 대형 언어 모델의 심장이에요.

RNN: 기억을 넘기며 읽기

RNN은 순서를 한 칸씩 읽으면서, 지금까지 읽은 내용을 은닉 상태 h\mathbf{h}라는 벡터에 담아 다음 칸으로 넘겨요.

ht=tanh⁡(Wxxt+Whht−1+b)\mathbf{h}_t = \tanh(W_x \mathbf{x}_t + W_h \mathbf{h}_{t-1} + \mathbf{b})

새 기억 = 지금 읽은 것 + 지난 기억이에요. 같은 가중치 WxW_x, WhW_h를 모든 칸에서 써요. CNN이 같은 필터를 사진의 모든 위치에 썼던 것처럼, RNN은 같은 규칙을 모든 시점에 써요.

import math
import numpy as np
import torch
from torch import nn
import torch.nn.functional as F

torch.manual_seed(0)
cell = nn.RNNCell(input_size=3, hidden_size=4)
xs = torch.randn(5, 3)                   # 길이 5짜리 순서, 한 칸에 숫자 3개
h = torch.zeros(4)                       # 처음 기억은 비어 있어요
for t in range(5):
    h = torch.tanh(xs[t] @ cell.weight_ih.T + cell.bias_ih + h @ cell.weight_hh.T + cell.bias_hh)
print(h.detach().numpy().round(3))      # [-0.654 -0.093 -0.847  0.104]

h2 = torch.zeros(1, 4)
for t in range(5):
    h2 = cell(xs[t:t + 1], h2)
print(torch.allclose(h, h2[0]))          # True

식을 그대로 계산한 결과가 PyTorch의 RNNCell과 같아요. 5칸짜리 순서 전체가 숫자 4개짜리 벡터 하나로 요약됐어요.

길어지면 기억이 사라진다

RNN을 학습시키려면 시간을 거슬러 역전파해야 해요. 60칸짜리 순서에서, 마지막 칸의 출력이 각 칸의 입력에 얼마나 민감한지(기울기의 크기) 재 볼게요.

torch.manual_seed(0)
rnn = nn.RNN(8, 32, batch_first=True)
x = torch.randn(1, 60, 8, requires_grad=True)
out, _ = rnn(x)
out[0, -1].sum().backward()
g = x.grad[0].norm(dim=1)
print(f"{g[-1]:.2e} {g[49]:.2e} {g[29]:.2e} {g[0]:.2e}")   # 1.93e+00 3.95e-03 1.36e-08 5.86e-17
입력 위치마지막 출력으로부터의 거리기울기 크기
60번째 칸01.93
50번째 칸10칸 전0.004
30번째 칸30칸 전0.00000001
1번째 칸59칸 전10−1710^{-17}

한 칸 거슬러 갈 때마다 WhW_h와 tanh의 기울기를 곱하는데, 이게 1보다 작으면 거리에 따라 기하급수적으로 줄어요. 역전파 강의의 깊은 시그모이드 신경망과 똑같은 기울기 소실이에요. RNN에서는 층의 깊이 대신 시간의 길이가 깊이예요. 그래서 RNN은 멀리 떨어진 앞부분을 배우기 어려워요. 반대로 1보다 크면 폭발하는데, 학습 기술 강의에서 말한 기울기 자르기로 막아요.

LSTM: 기억의 고속도로

LSTM은 1997년에 이 문제를 풀려고 나왔어요. 은닉 상태와 별도로 셀 상태라는 기억 통로를 두고, 세 개의 게이트가 무엇을 지우고(망각 게이트), 무엇을 새로 적고(입력 게이트), 무엇을 꺼내 쓸지(출력 게이트) 정해요. 셀 상태는 곱하기가 아니라 더하기로 갱신돼서, 기울기가 줄어들지 않고 먼 과거까지 흘러가요. CNN 강의의 잔차 연결과 같은 원리예요. GRU는 LSTM을 단순하게 줄인 형제예요.

실험: 맨 앞 숫자 기억하기

0에서 9 사이 숫자가 늘어선 순서를 끝까지 읽은 뒤, 맨 앞 숫자가 무엇이었는지 맞히는 문제예요. 단순하지만 먼 과거를 기억해야 해서 순서 모델의 기억력을 시험하기 좋아요. 보통 RNN, LSTM, 그리고 아래에서 배울 어텐션 모델을 비교해요.

def make_data(n, T, seed):
    g = torch.Generator().manual_seed(seed)
    seq = torch.randint(0, 10, (n, T), generator=g)
    return seq, seq[:, 0].clone()                 # 정답은 맨 앞 숫자

class RecurrentModel(nn.Module):
    def __init__(self, kind):
        super().__init__()
        self.emb = nn.Embedding(10, 16)           # 숫자를 벡터로
        self.rnn = (nn.RNN if kind == "rnn" else nn.LSTM)(16, 64, batch_first=True)
        if kind == "lstm":                        # 망각 게이트 편향을 1로: 처음엔 '잊지 않기'에서 시작
            for name, p in self.rnn.named_parameters():
                if "bias" in name:
                    with torch.no_grad():
                        p[64:128] = 1.0
        self.out = nn.Linear(64, 10)
    def forward(self, x):
        h, _ = self.rnn(self.emb(x))
        return self.out(h[:, -1])                 # 마지막 칸의 기억으로 답해요

class AttnModel(nn.Module):
    def __init__(self, T):
        super().__init__()
        self.emb = nn.Embedding(10, 32)
        self.pos = nn.Embedding(T, 32)            # 몇 번째 칸인지 알려 주는 위치 정보
        self.attn = nn.MultiheadAttention(32, num_heads=2, batch_first=True)
        self.query = nn.Parameter(torch.randn(1, 1, 32))   # 학습되는 질문 하나
        self.out = nn.Linear(32, 10)
    def forward(self, x):
        z = self.emb(x) + self.pos(torch.arange(x.shape[1]))
        a, _ = self.attn(self.query.expand(x.shape[0], 1, 32), z, z)   # 모든 칸을 한 번에 훑어요
        return self.out(a[:, 0])

def fit(model, T, epochs=30):
    Xtr, ytr = make_data(4000, T, 0)
    Xte, yte = make_data(1000, T, 1)
    opt = torch.optim.Adam(model.parameters(), lr=3e-3)
    g = torch.Generator().manual_seed(0)
    for ep in range(epochs):
        model.train()
        perm = torch.randperm(len(Xtr), generator=g)
        for s in range(0, len(Xtr), 100):
            bi = perm[s:s + 100]
            opt.zero_grad()
            F.cross_entropy(model(Xtr[bi]), ytr[bi]).backward()
            nn.utils.clip_grad_norm_(model.parameters(), 1.0)   # 기울기 자르기
            opt.step()
    model.eval()
    with torch.no_grad():
        return round((model(Xte).argmax(1) == yte).float().mean().item(), 3)

for T in [20, 60]:
    res = []
    for name in ["rnn", "lstm", "attn"]:
        torch.manual_seed(0)
        model = AttnModel(T) if name == "attn" else RecurrentModel(name)
        res.append((name, fit(model, T)))
    print(T, res)
순서 길이RNNLSTM어텐션
201.0001.0001.000
600.0951.0001.000

20칸까지는 셋 다 완벽해요. 60칸이 되면 보통 RNN은 9.5%, 숫자 10개 중 찍는 수준으로 무너져요. 위에서 본 기울기 소실 때문에 맨 앞 칸의 정보를 배울 수 없어요. LSTM은 셀 상태 덕분에 60칸 전도 기억해요. 다만 LSTM도 망각 게이트 편향을 1로 두는 요령(처음에는 "잊지 않기"에서 시작)을 써야 이렇게 잘 됐어요. 이 요령 없이 같은 조건으로 학습하면 실패하기도 했어요. 학습 기술 강의에서 본 것처럼, 초기화 하나가 성패를 가를 수 있어요.

어텐션 모델은 아예 다른 방식으로 풀어요. 기억을 넘기지 않고, 모든 칸을 한 번에 훑어서 필요한 칸을 직접 골라 읽어요. 60칸이든 600칸이든 맨 앞 칸까지 거리가 한 걸음이에요.

어텐션: 필요한 곳을 골라 보기

RNN의 근본적인 한계는 두 가지예요.

  1. 병목: 아무리 긴 글도 벡터 하나에 눌러 담아야 해요. 번역할 때 긴 문장의 앞부분이 흐려지는 문제가 컸어요.
  2. 순차 계산: 앞 칸이 끝나야 다음 칸을 계산할 수 있어서, GPU의 병렬 계산을 제대로 쓰지 못해요.

어텐션은 출력을 만들 때마다 입력의 모든 위치를 다시 보면서, 지금 필요한 위치에 가중치를 더 줘요. 도서관에 비유하면 이래요.

  • 질문(query): 내가 찾는 것 ("앞쪽에 나온 숫자")
  • 열쇠(key): 각 책의 제목표 (각 위치가 무엇을 담고 있는지)
  • 값(value): 책의 실제 내용 (각 위치의 정보)

질문과 열쇠가 얼마나 잘 맞는지(내적) 점수를 매기고, 소프트맥스로 비율을 만든 뒤, 그 비율대로 값을 섞어요.

Attention(Q,K,V)=softmax ⁣(QKTd)V\text{Attention}(Q, K, V) = \text{softmax}\!\left(\frac{QK^T}{\sqrt{d}}\right) V

손으로 계산해 볼게요. 질문 하나, 열쇠와 값이 셋이에요.

Q = torch.tensor([[1.0, 0.0]])                              # 질문 하나
K = torch.tensor([[1.0, 0.0], [0.0, 1.0], [1.0, 1.0]])      # 열쇠 셋
V = torch.tensor([[10.0, 0.0], [0.0, 10.0], [5.0, 5.0]])    # 값 셋
scores = Q @ K.T / math.sqrt(2)                             # 내적 점수를 √d로 나눠요
w = torch.softmax(scores, dim=-1)                           # 비율로
print(scores.numpy().round(3), w.numpy().round(3), (w @ V).numpy().round(3))
# [[0.707 0.    0.707]] [[0.401 0.198 0.401]] [[6.017 3.983]]
print(torch.allclose(F.scaled_dot_product_attention(Q[None], K[None], V[None])[0], w @ V))   # True

질문 (1,0)(1, 0)은 첫째 열쇠 (1,0)(1, 0), 셋째 열쇠 (1,1)(1, 1)과 내적이 1이고, 둘째 열쇠 (0,1)(0, 1)과는 0이에요. 그래서 첫째와 셋째 값에 40%씩, 둘째 값에 20%의 비중을 둬서 섞은 결과 (6.0,4.0)(6.0, 4.0)이 나와요. PyTorch의 어텐션 함수와 결과가 같아요.

d\sqrt{d}로 나누는 이유는 차원 dd가 클수록 내적 값이 커져서, 소프트맥스가 한 곳에만 쏠려 기울기가 사라지는 걸 막기 위해서예요. 정보 이론 강의의 온도와 같은 역할이에요.

셀프 어텐션과 위치 정보

문장 안의 단어들이 서로에게 어텐션하는 것을 셀프 어텐션이라고 해요. "그는 은행에 가서 돈을 찾았다"에서 "은행"은 "돈"을 보고 강가가 아니라 금융 기관이라는 뜻을 정해요. 모든 단어가 모든 단어를 동시에 보니, 순서대로 기다릴 필요가 없어 병렬 계산이 돼요.

그런데 어텐션은 그 자체로는 순서를 몰라요. 단어를 섞어 넣어도 같은 결과가 나와요. 그래서 각 위치에 "몇 번째인지" 알려 주는 위치 정보를 더해 줘요. 실험의 self.pos가 바로 그거예요. 그리고 질문, 열쇠, 값을 여러 벌 만들어 서로 다른 관계(문법, 의미, 지칭 등)를 동시에 보는 것을 멀티헤드 어텐션이라고 해요.

트랜스포머

2017년 논문 "Attention Is All You Need"는 RNN을 완전히 빼고 어텐션만으로 번역 모델을 만들었어요. 이 구조가 트랜스포머예요. 블록 하나는 이렇게 생겼어요.

  1. 셀프 어텐션 (단어들이 서로 정보를 주고받기)
  2. 잔차 연결과 층 정규화
  3. 위치마다 따로 적용하는 작은 신경망 (각 단어가 받은 정보를 소화하기)
  4. 잔차 연결과 층 정규화

이 블록을 수십 층 쌓은 게 GPT, Claude 같은 대형 언어 모델이에요. 지금까지 배운 부품이 다 들어 있어요. 행렬 곱(선형대수), 소프트맥스와 교차 엔트로피(정보 이론), 잔차 연결(CNN), 층 정규화(학습 기술), AdamW와 워밍업(학습 기술)이요.

언어 모델의 인과 마스크

다음 단어를 맞히는 언어 모델은 학습할 때 미래 단어를 미리 보면 안 돼요. 그래서 어텐션 점수에서 자기보다 뒤에 있는 위치를 −∞-\infty로 가려요. 소프트맥스를 거치면 그 비율이 0이 돼요.

T = 4
mask = torch.triu(torch.ones(T, T, dtype=torch.bool), diagonal=1)   # 대각선 위쪽(미래)을 가려요
s = torch.zeros(T, T).masked_fill(mask, float("-inf"))
print(torch.softmax(s, dim=-1).numpy().round(3))
[[1.    0.    0.    0.   ]
 [0.5   0.5   0.    0.   ]
 [0.333 0.333 0.333 0.   ]
 [0.25  0.25  0.25  0.25 ]]

첫 단어는 자기 자신만, 둘째 단어는 앞의 두 단어만, 넷째 단어는 네 단어 모두를 봐요. 이 인과 마스크 덕분에 문장 하나로 "다음 단어 맞히기" 문제를 길이만큼 한꺼번에 학습할 수 있어요. 학습 방식 강의의 자기 지도 학습이 이렇게 구현돼요.

어텐션의 비용

모든 위치가 모든 위치를 보니, 계산량과 메모리가 길이의 제곱으로 늘어요. 글이 10배 길어지면 어텐션 계산은 100배가 돼요. 긴 문서를 다루는 모델들이 어텐션 계산을 효율화하는 기법(플래시 어텐션 등)과 구조 개선에 공을 들이는 이유예요.

딥러닝 트랙을 마치며

강의가져갈 한 가지
신경망이 배우는 법층과 비선형 활성화가 데이터를 풀기 쉬운 모양으로 바꿔 줘요
역전파국소 기울기의 곱으로 모든 가중치의 기울기를 한 번에 구해요
PyTorch기울기 지우기, 순전파, 역전파, 갱신의 다섯 줄 의식
학습 기술초기화, 정규화, 학습률이 성패를 가르고, 점검 순서가 시간을 아껴 줘요
CNN구조를 데이터에 맞추면 적은 가중치로 더 잘 배워요
RNN과 어텐션순서는 기억을 넘기거나, 필요한 곳을 골라 보며 다뤄요

실습

  1. 기억 실험에서 순서 길이를 30, 40, 100으로 바꿔 세 모델을 비교해 보세요. 보통 RNN은 어디서부터 무너지나요?
  2. LSTM의 망각 게이트 편향 요령을 빼고 60칸 실험을 다시 해 보세요. 에포크를 늘리면 결국 성공하나요?
  3. 어텐션 모델에서 위치 정보(self.pos)를 빼면 맨 앞 숫자를 맞힐 수 있을까요? 결과를 예상한 뒤 확인하세요.
  4. 손 계산 예제의 질문을 (0,1)(0, 1)로 바꾸면 비율과 결과가 어떻게 바뀌나요?

자주 하는 실수

  • 긴 순서에 보통 RNN 쓰기. 기울기 소실로 앞부분을 못 배워요. LSTM이나 트랜스포머를 쓰세요.
  • RNN 학습에서 기울기 자르기 빼먹기. 기울기 폭발로 손실이 NaN이 될 수 있어요.
  • 어텐션 모델에 위치 정보를 안 넣기. 어텐션은 그 자체로는 순서를 몰라요.
  • 언어 모델 학습에서 인과 마스크 빼먹기. 정답을 보고 맞히는 셈이라 학습 성적만 좋고 생성은 엉망이 돼요.

점검 문제

  1. RNN에서 은닉 상태는 무엇을 담나요?
  2. RNN에서 먼 과거의 기울기가 사라지는 이유는?
  3. LSTM의 셀 상태가 기울기 소실을 줄이는 원리는?
  4. 어텐션 점수를 d\sqrt{d}로 나누는 이유는?
  5. 다음 단어를 예측하는 언어 모델에 인과 마스크가 필요한 이유는?

정답

  1. 지금까지 읽은 순서의 요약(기억)이에요.
  2. 시간을 거슬러 한 칸 갈 때마다 1보다 작은 값을 곱하게 되어, 거리에 따라 기하급수적으로 작아지기 때문이에요.
  3. 셀 상태를 곱하기가 아니라 더하기로 갱신해서, 기울기가 줄어들지 않는 지름길이 생기기 때문이에요.
  4. 차원이 크면 내적이 커져 소프트맥스가 한 곳에 쏠리고 기울기가 사라지는 것을 막기 위해서예요.
  5. 학습할 때 뒤의 단어(정답)를 미리 보지 못하게 해서, 생성할 때와 같은 조건으로 배우게 하기 위해서예요.

다음 강의

딥러닝의 기초를 다 갖췄어요. 다음은 LLM과 생성형 AI 트랙이에요. 첫 강의에서는 글이 토큰으로 잘리는 방식부터 시작해, 언어 모델이 다음 토큰을 하나씩 만들어 내는 과정을 직접 따라가요.