왜 LSTM이 필요했을까?#

문장을 왼쪽에서 오른쪽으로 읽는 RNN을 생각해 봅시다. 현재 단어를 해석할 때 이전 단어의 정보가 필요하므로, RNN은 이전 시점의 Hidden State를 다음 시점으로 전달합니다.

문장이 길어질수록, RNN은 아주 앞부분의 정보를 마지막까지 얼마나 잘 기억할 수 있을까?

예를 들어 다음처럼 앞부분의 정보가 뒤에서 다시 필요할 수 있습니다.

“나는 프랑스에서 태어났고 여러 나라에서 오래 살았다. … 그래서 내가 처음 배운 언어는 프랑스어였다.”

마지막의 “프랑스어”를 예측하려면 꽤 앞에서 나온 “프랑스”라는 정보가 여전히 의미 있게 남아 있어야 합니다.

기존 방법: 일반 RNN은 어떻게 기억하는가?#

일반 RNN은 현재 입력 $x_t$와 이전 Hidden State $h_{t-1}$를 이용해 새로운 Hidden State $h_t$를 계산합니다.

이 방식의 장점은 분명합니다.

• 입력의 순서를 반영할 수 있습니다.
• 같은 파라미터를 모든 시점에 재사용하므로 길이가 다른 시퀀스도 처리할 수 있습니다.
• 이전 상태가 다음 상태에 전달되므로 과거 문맥을 사용할 수 있습니다.

하지만 중요한 문제가 하나 있습니다. 과거의 정보가 매 시점마다 같은 변환을 반복해서 통과해야 한다는 점입니다.

긴 시퀀스에서 무엇이 문제일까?#

RNN을 학습할 때는 BPTT(Backpropagation Through Time)를 사용합니다. 마지막 시점의 Loss가 이전 시점들로 역전파되면서, 여러 Jacobian과 가중치가 반복해서 곱해집니다.

이때 곱해지는 값들의 크기가 계속 1보다 작으면 Gradient가 매우 작아지는 Vanishing Gradient가 발생할 수 있습니다. 반대로 반복 곱의 크기가 커지면 Exploding Gradient가 발생할 수 있습니다.

WARNING

중요한 포인트

Vanishing Gradient는 단순히 “RNN이 오래된 값을 저장할 공간이 부족하다”는 문제가 아닙니다. 학습 과정에서 아주 오래전 입력이 현재 Loss에 어떤 영향을 주었는지 알려 주는 Gradient가 약해지기 쉬운 것이 핵심입니다.

결과적으로 일반 RNN은 가까운 과거의 패턴은 잘 활용해도, 수십·수백 시점 떨어진 장기 의존성을 학습하기 어려울 수 있습니다.

그래서 필요한 것은 중요한 정보가 여러 시점을 지나도 비교적 안정적으로 흐를 수 있는 별도의 경로였습니다.

핵심 아이디어: 기억을 매번 새로 만들지 말고 관리하자#

TIP

LSTM의 핵심은 중요한 정보는 오래 유지하고, 필요 없는 정보는 선택적으로 버리는 것입니다.

일반 RNN의 Hidden State 하나에 모든 역할을 맡기지 않고, LSTM은 상태를 두 종류로 나눕니다.

• Cell State $c_t$: 장기적으로 전달할 기억
• Hidden State $h_t$: 현재 시점에서 외부로 드러나는 상태이자 다음 계산에 사용하는 단기 표현

그리고 세 개의 Gate가 정보 흐름을 조절합니다.

1. Forget Gate: 이전 Cell State에서 무엇을 유지할까?
2. Input Gate: 새 정보 중 무엇을 Cell State에 기록할까?
3. Output Gate: 현재 Cell State 중 무엇을 Hidden State로 보여 줄까?

Gate는 보통 Sigmoid를 사용해 각 원소에 대해 0~1 사이 값을 만듭니다. 0에 가까우면 거의 막고, 1에 가까우면 거의 통과시키는 연속적인 밸브처럼 생각할 수 있습니다.

전체 구조 먼저 보기#

1
┌──────────────────────────────────────────────┐
2
                │                Cell State                    │
3
cₜ₋₁ ──────────┼── × Forget ────────┐                       │
4
                │                    ├── + ───────────────→ cₜ│
5
                │      Candidate ─ × Input                     │
6
                └──────────────────────────────────────────────┘
7
                                     │
8
                                     tanh
9
                                      │
10
xₜ ───────┐                           × Output ─────────────→ hₜ
11
          ├──→ [Forget, Input, Candidate, Output Gates]
12
hₜ₋₁ ─────┘

한 시점 $t$에서 LSTM이 받는 핵심 입력은 세 가지입니다.

• 현재 입력 $x_t$
• 이전 Hidden State $h_{t-1}$
• 이전 Cell State $c_{t-1}$

그리고 다음 시점으로 $h_t$와 $c_t$를 전달합니다.

핵심 구성 요소와 수식#

데이터는 실제로 어떻게 흐를까?#

배치 크기 32, 입력 특징 수 16, Hidden Size 64인 LSTM 한 층을 생각해 봅시다.

현재 한 시점에서 텐서 크기는 다음과 같습니다.

• $x_t$: [32, 16]
• $h_{t-1}$: [32, 64]
• $c_{t-1}$: [32, 64]
• Gate 출력 $f_t, i_t, g_t, o_t$: 각각 [32, 64]
• 새 상태 $h_t, c_t$: 각각 [32, 64]

전체 Forward 과정을 다시 연결하기#

1. 현재 입력 $x_t$와 이전 Hidden State $h_{t-1}$를 본다.
2. Forget Gate로 이전 Cell State에서 유지할 정보를 정한다.
3. Input Gate로 새 후보 정보 중 저장할 부분을 정한다.
4. 두 정보를 합쳐 새로운 Cell State $c_t$를 만든다.
5. Output Gate로 Cell State 중 현재 노출할 부분을 정한다.
6. 새로운 Hidden State $h_t$를 만든다.
7. $h_t$와 $c_t$를 다음 시점으로 넘긴다.

1
for each timestep t:
2
    decide what to keep from previous memory
3
    decide what new information to write
4
    update the cell state
5
    decide what part of the cell state to expose
6
    pass hidden state and cell state to the next timestep

PyTorch로 내부 계산 직접 구현하기#

LSTM의 원리를 이해하려면 nn.LSTM을 바로 쓰기 전에 Gate 계산을 직접 구현해 보는 것이 좋습니다.

1
import torch
2
import torch.nn as nn
3

4

5
class MyLSTMCell(nn.Module):
6
    def __init__(self, input_size: int, hidden_size: int):
7
        super().__init__()
8
        self.hidden_size = hidden_size
9

10
        # [x_t, h_{t-1}]를 한 번에 받아
11
        # input, forget, candidate, output 네 벡터를 동시에 계산한다.
12
        self.linear = nn.Linear(
13
            input_size + hidden_size,
14
            4 * hidden_size,
15
        )
16

17
    def forward(self, x_t, state):
18
        h_prev, c_prev = state
19

20
        combined = torch.cat([x_t, h_prev], dim=-1)
21
        gates = self.linear(combined)
22

23
        i_raw, f_raw, g_raw, o_raw = gates.chunk(4, dim=-1)
24

25
        i_t = torch.sigmoid(i_raw)   # input gate
26
        f_t = torch.sigmoid(f_raw)   # forget gate
27
        g_t = torch.tanh(g_raw)      # candidate
28
        o_t = torch.sigmoid(o_raw)   # output gate
29

30
        c_t = f_t * c_prev + i_t * g_t
31
        h_t = o_t * torch.tanh(c_t)
32

33
        return h_t, c_t

핵심은 linear의 출력 차원을 4 * hidden_size로 만들고, 한 번의 선형 변환 결과를 네 Gate로 나누는 부분입니다. 수식에서는 Gate별로 $W_i, W_f, W_g, W_o$를 따로 썼지만, 구현에서는 효율을 위해 하나의 큰 행렬 연산으로 합치는 경우가 많습니다.

1
batch_size = 32
2
seq_len = 20
3
input_size = 16
4
hidden_size = 64
5

6
x = torch.randn(batch_size, seq_len, input_size)
7
cell = MyLSTMCell(input_size, hidden_size)
8

9
h_t = torch.zeros(batch_size, hidden_size)
10
c_t = torch.zeros(batch_size, hidden_size)
11

12
outputs = []
13

14
for t in range(seq_len):
15
    x_t = x[:, t, :]
16
    h_t, c_t = cell(x_t, (h_t, c_t))
17
    outputs.append(h_t)
18

19
outputs = torch.stack(outputs, dim=1)
20
print(outputs.shape)  # [32, 20, 64]

실무에서는 nn.LSTM 사용하기#

1
import torch
2
import torch.nn as nn
3

4
batch_size = 32
5
seq_len = 20
6
input_size = 16
7
hidden_size = 64
8
num_layers = 2
9

10
x = torch.randn(batch_size, seq_len, input_size)
11

12
lstm = nn.LSTM(
13
    input_size=input_size,
14
    hidden_size=hidden_size,
15
    num_layers=num_layers,
16
    batch_first=True,
17
)
18

19
output, (h_n, c_n) = lstm(x)
20

21
print(output.shape)  # [32, 20, 64]
22
print(h_n.shape)     # [2, 32, 64]
23
print(c_n.shape)     # [2, 32, 64]

• output: 마지막 레이어의 모든 시점 Hidden State
• h_n: 각 레이어의 마지막 Hidden State
• c_n: 각 레이어의 마지막 Cell State

WARNING

batch_first=True는 입력과 output을 [batch, sequence, feature] 형태로 바꾸지만, h_n과 c_n의 차원 순서는 [layers × directions, batch, hidden] 형태를 유지합니다.

학습할 때는 무엇이 업데이트될까?#

LSTM에서 직접 학습되는 것은 Gate의 결과값 자체가 아니라 Gate를 계산하는 가중치와 Bias입니다.

예를 들어 다음 파라미터들이 Gradient Descent로 업데이트됩니다.

• Forget Gate의 $W_f, b_f$
• Input Gate의 $W_i, b_i$
• Candidate의 $W_g, b_g$
• Output Gate의 $W_o, b_o$

학습 흐름은 일반적인 신경망과 같습니다.

1. 시퀀스를 Forward 한다.
2. 모델 출력으로 Loss를 계산한다.
3. BPTT를 통해 여러 시점으로 Gradient를 전달한다.
4. Optimizer가 LSTM 파라미터를 업데이트한다.

1
model = nn.LSTM(
2
    input_size=16,
3
    hidden_size=64,
4
    batch_first=True,
5
)
6

7
head = nn.Linear(64, 3)
8
criterion = nn.CrossEntropyLoss()
9
optimizer = torch.optim.Adam(
10
    list(model.parameters()) + list(head.parameters()),
11
    lr=1e-3,
12
)
13

14
x = torch.randn(32, 20, 16)
15
y = torch.randint(0, 3, (32,))
16

17
output, _ = model(x)
18
last_hidden = output[:, -1, :]
19
logits = head(last_hidden)
20
loss = criterion(logits, y)
21

22
optimizer.zero_grad()
23
loss.backward()
24
optimizer.step()

학습과 추론에서 LSTM Cell의 기본 Forward 계산 자체는 같습니다. 다만 학습에서는 Gradient를 저장하고 역전파하며, 추론에서는 보통 Gradient 계산을 끕니다.

계산 특성#

LSTM은 일반 RNN보다 장기 의존성을 다루기 쉬워졌지만 계산 비용은 더 큽니다. 한 시점마다 여러 Gate를 계산해야 하기 때문입니다.

특히 중요한 특성은 시간축 병렬화가 어렵다는 점입니다.

$h_t$와 $c_t$를 계산해야 $h_{t+1}$와 $c_{t+1}$를 계산할 수 있으므로, 한 시퀀스 내부의 시점들을 완전히 독립적으로 계산할 수 없습니다.

이 특성은 긴 시퀀스를 대규모로 처리할 때 Transformer 계열과 비교되는 대표적인 한계입니다.

장점과 한계#

WARNING

자주 오해하는 부분

• Cell State와 Hidden State는 같은 값이 아닙니다.
• Forget Gate는 정보를 완전히 삭제하는 스위치가 아니라, 보통 0~1의 연속값으로 기억의 통과량을 조절합니다.
• LSTM이 Vanishing Gradient를 완전히 없애는 것은 아닙니다. 일반 RNN보다 장기 정보가 흐르기 좋은 경로를 제공하는 것입니다.
• Hidden State의 마지막 값 하나가 항상 시퀀스 전체를 완벽히 요약한다고 볼 수는 없습니다.

실무에서 체크할 조건#

언제 LSTM을 사용하면 좋은가?#

순서가 중요하고, 현재 예측에 이전 정보가 영향을 주는 시퀀스 데이터에 잘 맞습니다.

• 중간 규모 시계열 데이터 → 과거 관측의 흐름이 현재 값에 영향을 주는 경우
• 텍스트 분류 → 단어 순서와 문맥을 순차적으로 읽어야 하는 경우
• 이벤트 로그 / 사용자 행동 시퀀스 → 이전 행동의 순서가 이후 행동 예측에 중요한 경우
• 스트리밍 입력 → 입력이 시간 순서대로 하나씩 도착하며 상태를 계속 이어갈 수 있는 경우

특히 Transformer의 큰 병렬 처리 장점이 꼭 필요하지 않거나, 데이터·모델 규모가 비교적 작고 순환 상태라는 inductive bias가 유용한 상황에서는 여전히 실용적인 선택이 될 수 있습니다.

언제 다른 모델을 고려할까?#

RNN, LSTM, GRU, Transformer 비교#

어떻게 발전했는가?#

1
Vanilla RNN
2
   │
3
   │ 장기 의존성 / Gradient 문제
4
   ▼
5
LSTM
6
   │
7
   │ Gate 구조를 더 단순하게
8
   ▼
9
GRU
10
   │
11
   │ 멀리 떨어진 위치를 직접 참조하고 싶음
12
   ▼
13
Attention
14
   │
15
   │ 순환 계산 자체를 제거하고 병렬화
16
   ▼
17
Transformer

이 흐름을 단순히 “새 모델이 이전 모델보다 항상 좋다”라고 이해하면 안 됩니다. 각 구조는 계산 자원, 데이터 크기, 입력 길이, 지연 시간, 온라인 처리 여부 등에 따라 다른 Trade-off를 가집니다.

실제 활용#

LSTM은 다음과 같은 시퀀스 문제에서 오랫동안 널리 사용되어 왔고, 현재도 데이터 규모나 시스템 제약에 따라 유효한 선택입니다.

• 시계열 예측: 센서, 수요, 트래픽처럼 과거 흐름이 미래 값에 영향을 주는 데이터
• 텍스트 처리: 문장 분류, sequence labeling 등 순서 기반 표현이 필요한 문제
• 음성·신호 처리: 시간 순서가 중요한 연속 신호
• 이상 탐지: 정상 시퀀스의 동역학을 학습해 비정상 패턴을 찾는 문제
• 행동 예측: 클릭, 구매, 이벤트 로그처럼 이전 행동이 다음 행동과 관련된 경우

실제 시스템에서는 LSTM 하나만 사용하는 것이 아니라 Embedding, CNN, Attention, MLP, CRF 등 다른 모듈과 조합하는 경우도 많습니다.

이해도 확인#

1. 일반 RNN보다 LSTM의 Cell State가 장기 정보를 전달하기 쉬운 이유는 무엇일까요?
2. Forget Gate가 항상 0 또는 1만 출력한다면 어떤 문제가 생길까요?
3. Cell State와 Hidden State를 별도로 유지하면 어떤 장점이 있을까요?
4. LSTM이 Transformer보다 시간축 병렬화가 어려운 이유는 무엇일까요?
5. 가변 길이 문장을 Padding해서 학습할 때 마지막 Hidden State를 그대로 사용하는 것이 위험할 수 있는 이유는 무엇일까요?

핵심 정리#

TIP

• LSTM은 일반 RNN의 장기 의존성 학습 문제를 완화하기 위해 등장했습니다.
• 핵심은 Cell State라는 장기 기억 경로와 정보 흐름을 조절하는 Forget/Input/Output Gate입니다.
• Cell State는 $c_t = f_t \odot c_{t-1} + i_t \odot g_t$처럼 이전 기억을 선택적으로 유지하고 새 정보를 더하는 방식으로 갱신됩니다.
• 일반 RNN보다 긴 문맥을 다루기 쉽지만, 순차 계산 때문에 긴 시퀀스의 병렬화가 어렵고 계산량이 더 큽니다.
• 문제 규모와 시스템 요구에 따라 GRU, Attention, Transformer 같은 대안과 비교해서 선택해야 합니다.

다음에 공부하면 좋은 것#

1. GRU → LSTM의 Gate 구조를 더 단순하게 만든 순환 모델입니다. LSTM의 각 Gate가 정말 모두 필요한지 생각해 보기 좋습니다.
2. Bidirectional RNN/LSTM → 한 방향 상태 전달의 한계를 보완해 양쪽 문맥을 사용하는 방법입니다.
3. Attention Mechanism → 모든 정보를 하나의 순환 상태에 압축하지 않고, 필요한 시점의 표현을 직접 참조하는 아이디어입니다.
4. Transformer → Attention을 중심으로 순환 구조를 제거해 시퀀스 내부 병렬화를 가능하게 만든 구조입니다.

참고 자료#

• Hochreiter, S. & Schmidhuber, J. (1997), Long Short-Term Memory, Neural Computation. https://doi.org/10.1162/neco.1997.9.8.1735
• PyTorch Documentation, torch.nn.LSTM: https://docs.pytorch.org/docs/stable/generated/torch.nn.LSTM.html