RNN, LSTM, and GRU

인화·2026년 6월 17일

Deep Learning

목록 보기

7/10

RNN, LSTM, and GRU

핵심 : 문장, 음성 신호, ECG 파형, 수요 곡선 같은 데이터는 단순히 독립적인 값들의 집합이 아니라 순서가 있는 객체이다. 따라서 순서를 고려할 수 있는 sequence model이 필요하다.

개요

기존 feed-forward layer는 입력 x 하나를 받아서 선형 변환을 하고, activation function을 적용해서 출력한다. MLP는 이런 층을 여러 개 쌓은 구조다. 이 방식은 입력이 고정 길이 벡터일 때 잘 맞는다. 예를 들어 표 데이터, flatten된 이미지 feature 같은 것들은 MLP로 처리할 수 있다. 그런데 현실의 많은 데이터는 고정 길이 벡터가 아니라 sequence, 즉 순차 데이터다.

문장 : 단어들의 sequence
음성 : 시간 순서대로 나열된 frame들의 sequence
센서 데이터 : 시간 순서대로 측정된 값들의 sequence
주가 : 시간에 따른 가격 sequence
ECG : 시간에 따른 생체 신호 sequence

이런 데이터에서는 순서가 의미의 일부다.

예를 들어, "not bad"는 단어만 보면 not, bad지만, 순서를 고려하면 “나쁘지 않다”라는 의미가 된다. 센서 데이터도 갑자기 튄 값이 의미 있으려면 이전 정상 흐름 이후에 발생했다는 맥락이 중요하다. 그래서 이전 시점 정보를 요약해서 기억하는 state가 필요하다. RNN은 이 state를 도입한 모델이다.

일반적인 feed-forward layer의 계산

z = Wx + b

h = ϕ(z)

Sequence Data란?

순차 데이터는 순서가 있는 관측값들의 모음이다. 아래의 수식에서 T 는 Sequence의 길이, x_t 는 t번째 시점에서의 입력이다. 이때 중요한 점은 x_t가 그냥 독립적인 샘플이 아니라는 것이다. 순차 데이터에서는 현재 입력을 해석할 때, 이전 시점의 정보가 중요한 역할을 한다 예를 들어, x_3가 있다고 하면 x_3의 의미는 x_1과 x_2에 의해 변화할 수 있다.

x₁:T = (x₁, x₂, ..., x_T)

예를 들어 문장 데이터에서 “나는 밥을” 다음에 오는 단어는 앞의 단어들에 의해 의미가 결정된다. 또한 주가 데이터에서도 오늘의 가격은 단순히 오늘 값 하나만으로 판단하기보다 이전 가격 흐름과 함께 분석해야 한다. 이처럼 순차 데이터는 시간적 의존성 또는 문맥적 의존성을 가지기 때문에, 이를 처리하기 위해 RNN, LSTM, GRU와 같은 순환 신경망 모델이 사용된다.

이러한 순차 데이터가 일반적인 고정 길이 벡터 데이터와 다른 이유는 여기에 있다. 일반적인 고정 길이 벡터 데이터는 보통 각 샘플을 독립적으로 본다. 예를 들어 이미지 분류나 표 형식 데이터에서는 입력 하나를 넣고 출력 하나를 예측한다. (입력 x → 모델 → 출력 y)

이와 달리, 순차 데이터는 x1, x_2, x_3, …, x_t처럼 순서가 있는 데이터이고, 각 시점의 값이 독립적이지 않다. 즉, 현재 값 x_t의 의미가 이전 값 `x{t-1}, x_{t-2}`와 연결되어 있다.

Sequence Learning의 입력-출력 유형

RNN 계열은 모델이 입력을 단계별로 처리하고 이전 정보에 대한 표현을 유지해야 할 때 특히 유용하다.

Many-to-One은 sequence를 입력받지만 출력은 하나이다. (ex) 감성 분류
Many-to-Many는 sequence를 입력받고 각 시점마다 출력한다. (ex) 품사 태깅
Sequence-to-Sequence는 sequence를 입력받아 새로운 sequence를 생성하며, 입출력 길이가 다를 수 있다. (ex)기계 번역

유형	입력	출력	예시
One-to-One	입력 하나	출력 하나	이미지 분류
One-to-Many	입력 하나	Sequence 출력	이미지 캡셔닝
Many-to-One	Sequence 입력	출력 하나	감성 분류
Many-to-Many	Sequence 입력	Sequence 출력	품사 태깅
Sequence-to-Sequence	Sequence 입력	Sequence 출력	기계 번역
Streaming	계속 들어오는 Sequence 입력	실시간 판단	실시간 음성 인식, 센서 모니터링

Vanilla RNN

Vanilla RNN은 가장 기본적인 RNN으로, 핵심은 hidden state이다. Hidden state는 이전 시점까지의 정보를 요약한 값이며, RNN은 매 시점마다 현재 입력 x_t와 이전 hidden state h_{t-1}를 함께 사용해서 현재 hidden state h_t를 만든다.

공식은 다음과 같다.

h_t = ϕ(W_{xh} x_t + W_{hh} h_{t-1} + b_h)

출력은 보통 다음처럼 계산하며, 분류 문제라면 softmax를 붙여 예측 확률을 만들고, 회귀의 경우 선형 출력 결과를 직접 사용할 수 있다.

y_t = W_{hy} h_t + b_y

ŷ_t = softmax(W_{hy} h_t + b_y)

Vanilla RNN : 현재 입력과 이전 hidden state를 이용해 현재 hidden state를 업데이트

현재 입력 + 이전 기억 → 현재 hidden state

RNN은 3개의 가중치가 존재하며, 단순히 현재 입력만 보는 것이 아니라 현재 입력과 이전 기억을 함께 보고 현재 상태를 만든다. 쉽게 말해, RNN에서는 매 시점마다 입력 xt가 들어오고, 모델은 이전 hidden state h{t-1}을 참고해 현재 hidden state h_t를 만든다.

기호	의미	예시 shape
x_t	시점 t에서의 입력값	(d_x,)
h_t	시점 t에서의 hidden state	(d_h,)
y_t	시점 t에서의 출력값
모델이 현재 hidden state를 바탕으로 내는 결과	(d_y,)
W_{xh}	현재 입력 `x_t`를 hidden state 공간으로 변환
현재 입력 → hidden state에 반영 (현재 입력을 처리하는 가중치)	(d_h, d_x)
W_{hh}	이전 hidden state `h_{t-1}`를 현재 hidden state 계산에 반영
이전 기억 → 현재 기억에 반영 (이전 기억을 가져오는 가중치)	(d_h, d_h)
W_{hy}	hidden state `h_t`를 output으로 변환

hidden state를 output으로 바꿔주는 가중치
RNN이 내부적으로 기억한 정보를 실제 예측 결과로 바꾸는 역할 | (d_y, d_h) |
| b_h | hidden bias vector | (d_h,) |
| b_y | output bias vector | (d_y,) |

Time Unrolling

RNN은 그림으로 보면 자기 자신에게 연결된 순환 구조처럼 보인다. 하지만 학습할 때는 시간 방향으로 펼쳐서 생각한다. RNN은 원래 현재 입력 x_t + 이전 기억 h_{t-1} → 현재 기억 h_t 와 같이 생긴 하나의 반복 구조인데, 이 계산을 시간 순서대로 반복한다는 것이다. 즉, 시간마다 다른 모델을 쓰는 게 아니라, 같은 RNN 셀이 시간마다 반복해서 사용된다.

예를 들어, 시퀀스의 길이가 3이면 아래와 같이 펼쳐질 수 있다. 즉, 첫 번째 입력 x_1과 초기 기억 h_0으로 h_1을 만들고, 두 번째 입력 x_2와 이전 기억 h_1으로 h_2를 만들고, 세 번째 입력 x_3와 이전 기억 h_2로 h_3을 만든다. 이 흐름을 시간 전개, 즉 Time unrolling이라고 한다.

h₁ = ϕ(W_{xh} x₁ + W_{hh} h₀ + b_h)

h₂ = ϕ(W_{xh} x₂ + W_{hh} h₁ + b_h)

h₃ = ϕ(W_{xh} x₃ + W_{hh} h₂ + b_h)

위의 그림 오른쪽에 RNN 블록이 여러 개 있는 것처럼 보여도, 서로 다른 모델이 여러 개 있는 게 아닌, 같은 RNN 셀을 시간 순서대로 반복해서 적용한 것이다. 즉, h_1, h_2, h_3를 계산할 때 각각 다른 가중치를 쓰는 게 아니라 항상 같은 가중치를 사용하므로 W_xh, W_hh, b_h는 모든 시점에서 동일하게 사용되며, 이를 parameter sharing over time이라고 한다.

Parameter sharing over time은 시간이 달라져도 모든 time step에서 동일한 파라미터를 반복해서 사용하는 것을 의미한다. 즉, 문장이 3단어든 10단어든 RNN은 매 시점마다 같은 계산 규칙을 적용한다.

RNN은 각 시점에서 현재 입력 xt와 이전 hidden state h{t-1}를 함께 사용하여 현재 hidden state h_t를 계산한다.

h_t = \phi(W_{xh}x_t + W_{hh}h_{t-1} + b_h)

이때 W{xh}, W{hh}, b_h는 모든 time step에서 동일하게 사용된다. 따라서 time unrolling으로 펼쳐진 여러 RNN 블록은 서로 다른 모델이 아니라, 같은 RNN 셀이 시간축을 따라 반복 적용된 것이다.

RNN에서 공유되는 것은 hidden state 값 자체가 아니라 계산에 사용되는 가중치와 규칙이다. W{xh}는 현재 입력을 hidden state에 반영하는 가중치이고, W{hh}는 이전 hidden state를 현재 hidden state에 반영하는 가중치이며, W_{hy}는 hidden state를 output으로 변환하는 가중치이다.

RNN의 parameter sharing은 모든 time step에서 같은 가중치를 사용하여 동일한 계산 규칙을 반복 적용하는 것이다. 계산 공식은 같지만, 공식에 들어가는 입력값 xt와 이전 기억값 h{t-1}은 매 시점마다 달라진다. RNN은 이렇게 parameter를 공유하기에 시계열 길이가 길어져도 매 시점 다른 가중치를 새로 만드는 게 아니라, 같은 가중치를 반복 사용한다. 그래서 파라미터 수가 시간에 비례해 늘어나지 않고, 파라미터를 크게 늘리지 않고도 순서가 있는 데이터를 학습할 수 있다는 장점이 있다.

BPTT (Backpropagation Through Time)

BPTT는 Backpropagation Through Time의 약자로, RNN을 시간 방향으로 펼친 다음, 그 펼쳐진 계산 그래프를 따라 역전파하는 것을 의미한다. RNN은 시간 순서로 펼치면 h0 → h1 → h2 → h3 → ... → hT → Loss 와 같은 구조를 지니고, 학습 시에는 Loss를 줄이기 위해 역전파를 수행해야 하는데, RNN은 시간 축으로 펼쳐져 있으므로 역전파도 시간 방향을 거슬러 가야 하므로 Loss → hT → hT-1 → hT-2 → ... → h0 와 같이 시간 축을 거슬러 전달하게 된다.

일반 신경망은 층 방향으로 역전파하지만, RNN은 시간 방향으로도 연결되어 있기 때문에 과거 시점까지 gradient를 보내야 한다. 그래서 RNN의 gradient는 대략 이런 형태가 된다. 즉, 초기 hidden state h0가 최종 loss에 얼마나 영향을 주는지 계산하려면, h0 → h1 → h2 → ... → hT까지 이어지는 영향들을 전부 곱해야 하는 형태라는 것이다.

\frac{∂L_T} {∂h_0} = \frac{∂L_T} {∂h_T} × ∏_{t=1}^T \frac{∂h_t}{∂h_{t-1}}

수식에서도 보듯, 핵심은 ∏, 즉 반복 곱셈이다. gradient가 과거로 전달될 때 Jacobian들이 계속 곱해지고, 시간이 길수록 곱해지는 값들이 더 많아진다. BPTT에서는 반복적인 Jacobian 곱이 central issue이며, 반복 곱이 1보다 작으면 vanishing, 1보다 크면 exploding이 발생할 수 있다. 만약 계속 곱해지는 값들이 1보다 작으면 gradient가 0에 가까워져 앞쪽 시점의 정보가 뒤쪽 loss에 영향을 거의 못 주기에 기울기 소실 문제가 발생해 오래 전 정보는 뒤로 갈수록 영향력이 희미해져서 학습이 잘 안 된다. 예를 들어 문장이 길 때, 맨 앞 단어가 뒤쪽 의미에 중요해도 Vanilla RNN은 그 정보를 끝까지 잘 전달하지 못할 수 있다.

반대로, 곱해지는 값들이 1보다 크면 gradient가 너무 커져 학습이 불안정해지고, 기울기 폭주 문제가 발생할 수 있다. 즉, gradient가 너무 커져서 weight가 과하게 업데이트되고 학습이 불안정해진다. 이는 반복 곱셈이 작은 차이를 엄청 크게 만들어 발생하는 문제이며, Vanilla RNN의 한계를 명확히 보여준다. Vanilla RNN은 먼 과거의 정보가 현재 출력에 영향을 주려면 많은 hidden state를 거쳐야 하고, 이 과정에서 gradient가 계속 곱해진다. 따라서 1보다 작으면 기울기 소실 문제가, 크면 폭주 문제가 발생해 장기 의존성을 잘 학습하지 못하는 long-term dependency 문제가 발생한다. 이를 해결하기 위해 나온 구조가 LSTM과 GRU이다. 이 두 구조는 gate를 사용해 어떤 정보를 유지하고 버릴지, 어떤 정보를 새로 반영할지를 반영하므로 Vanilla RNN보다 긴 문맥을 더 잘 다룰 수 있다는 특징이 있다.

LSTM (Long Short-Term Memory)

Vanilla RNN은 모든 과거 정보를 하나의 hidden state h_t에 저장한다. 이는 짧은 sequence에서는 괜찮을 수 있지만, 긴 sequence에서는 hidden state 하나가 병목된다. 이때 병목된다는 말의 의미는 긴 과거 정보를 hidden state 하나에 다 우겨넣어야 해서 정보가 압축되거나 지워지는 것을 의미한다. 즉, h_t는 크기가 정해진 하나의 벡터인데, 과거 정보가 계속 늘어나 오래된 정보가 희미해지거나 새 정보에 덮여서 사라지는 information bottleneck 현상이 발생한다.

그래서 LSTM은 이를 해결하기 위해 별도의 기억 경로인 cell state c_t 를 도입한다. h_t 하나로 기억과 출력을 해결하려고 했던 Vanilla RNN과는 달리 c_t에는 오래 가져갈 기억을, h_t에는 현재 시점에서 밖으로 보여주는 상태를 저장해 나눈다.

기호	의미
`c_t`	내부 장기 기억 경로
`h_t`	다음 layer나 output으로 노출되는 hidden representation

LSTM은 memory를 gate로 조절한다. 여기서 gate는 정보가 얼마나 통과할지 조절하는 장치이다. Gate에서는 sigmoid 함수를 사용하는데, sigmoid는 입력값을 0과 1 사이의 값으로 변환한다. 따라서 gate의 출력값은 정보를 얼마나 유지하거나 반영할지를 나타내는 비율처럼 해석할 수 있다.

예를 들어 gate 값이 0에 가까우면 해당 정보를 거의 차단하고, 1에 가까우면 거의 그대로 통과시킨다. 0.5에 가까우면 정보를 절반 정도만 반영하는 것으로 볼 수 있다. 즉, LSTM의 gate는 정보를 완전히 켜고 끄는 hard switch가 아니라, 정보의 통과 정도를 연속적으로 조절하는 soft switch이다.

또한 gate 값은 벡터 형태로 계산되므로, 전체 정보를 한 번에 버리거나 유지하는 것이 아니라 cell state의 각 차원별로 어떤 정보는 유지하고 어떤 정보는 줄이는 방식으로 조절한다. 이 덕분에 LSTM은 이전 기억 중 중요한 정보는 오래 유지하고, 불필요한 정보는 선택적으로 잊을 수 있다.

cell state c_t = 기억이 저장되는 공간
gate = cell state에 들어가고 나가는 정보량을 조절하는 역할
Gate에서는 sigmoid를 사용해 정보의 통과 비율을 0~1 사이로 조절하고, candidate cell state에서는 tanh를 사용해 새로 저장할 후보 기억을 -1~1 범위의 값으로 만든다.

게이트	역할
Forget gate `f_t`	이전 기억을 얼마나 잊을지/유지할지
Input gate `i_t`	새 기억을 얼마나 쓸지
Output gate `o_t`	내부 기억을 얼마나 밖으로 보여줄지

Forget Gate

이전 기억 c_{t-1} 중에서 무엇을 얼마나 유지할지 결정하는 것
이전 기억 전체를 한 번에 버리거나 유지하는 게 아니라, 기억 벡터의 각 요소마다 따로 조절함.
Forget gate는 이전 hidden state h{t-1}와 현재 입력 x_t를 이용해 f_t를 계산하며, f_t는 sigmoid를 거치기 때문에 0과 1 사이의 값을 가진다. 이 값은 이전 cell state c{t-1}에 element-wise로 곱해져 각 기억 성분을 얼마나 유지할지 결정한다. 값이 0에 가까우면 해당 기억은 거의 버려지고, 1에 가까우면 거의 유지된다.

f_t = σ(W_f[h_{t-1}, x_t] + b_f)

f_t ≈ 0 → 이전 기억을 거의 버림
f_t ≈ 1 → 이전 기억을 거의 유지

h_{t-1}와 x_t가 들어옴
        ↓
sigmoid를 통과해서 f_t 계산
        ↓
f_t가 이전 cell state c_{t-1}에 곱해짐
        ↓
이전 기억 중 유지할 부분만 남음

Input Gate

새로운 정보를 얼마나 cell state에 넣을지 결정하는 것
현재 들어온 정보 중 무엇을 새 기억으로 저장할지 결정하는 것

i_t = σ(W_i[h_{t-1}, x_t] + b_i)

1. 무엇을 새로 저장할 후보로 만들까? → candidate cell state
2. 그중 얼마나 실제로 저장할까? → input gate

i_t ≈ 0 → 새 정보를 거의 저장하지 않음
i_t ≈ 1 → 새 정보를 거의 그대로 저장함

현재 입력 x_t + 이전 hidden state h_{t-1}
        ↓
1) input gate i_t 계산
2) candidate cell state c̃_t 계산
        ↓
i_t ⊙ c̃_t
        ↓
cell state에 새로 추가할 정보

sigmoid 가지는 input gate i_t를 계산하고,
tanh 가지는 candidate memory c̃_t를 계산한다.
이 둘을 원소별로 곱한 값이 cell state에 새로 기록되는 정보가 된다.

현재 입력과 이전 hidden state를 보고,
새로 저장할 후보 기억 c̃_t를 만들고,
input gate i_t가 그 후보 기억을 얼마나 실제 memory에 쓸지 결정한다.

Candidate Cell State

새로 저장할 후보 기억을 만드는 것
cell state에 들어간 최종 기억은 아니고, 이번 시점에서 새로 기억하면 좋을 만한 정보 후보를 만드는 것으로 여기서는 sigmoid가 아닌 tanh를 활용함.
tanh는 값을 −1~ 1 사이로 만들기 때문에, 새로 저장할 정보의 내용 자체를 만들어내는 역할을 함. 다시 말해, 양수 값 → 이 방향의 정보를 추가하자 / 음수 값 → 이 방향의 정보를 줄이거나 반대로 반영하자 / 0에 가까운 값 → 별로 반영할 정보가 없다를 의미함.

c̃_t = tanh(W_c[h_{t-1}, x_t] + b_c)

구분	역할	값 범위	의미
Candidate cell state	새로 저장할 정보의 “내용” 생성	-1 ~ 1	어떤 정보를 넣을지
Input gate	그 정보를 얼마나 저장할지 조절	0 ~ 1	얼마나 넣을지

Cell State Update

새 기억 = 유지할 과거 기억 + 새로 쓸 현재 기억
첫 번째 항은 이전 memory 중 선택된 부분을 유지하는 것이고 두 번째 항은 새 candidate memory 중 선택된 부분을 쓰는 것을 의미함.
LSTM은 메모리 유지와 메모리 업데이트를 명확하게 분리하는 것을 이 업데이트 식을 통해 확인할 수 있으며, 이러한 분리가 LSTM이 일반 RNN보다 더 긴 종속성을 더 잘 처리할 수 있는 주요 이유임.

c_t = f_t ⊙ c_{t-1} + i_t ⊙ c̃_t

Output Gate

내부 기억 c_t 중에서 얼마나 밖으로 보여줄지 결정하는 것
LSTM이 기억하고 있는 내용 c_t를 모두 밖으로 내보내는 것이 아닌, output gate가 허락한 만큼만 h_t로 내보냄.

o_t = σ(W_o [h_{t-1}, x_t] + b_o)

Hidden State

cell state를 tanh로 정리한 뒤, output gate가 허락한 만큼만 hidden state로 내보내는 것
정리된 내부 기억 × output gate의 허락량 = 현재 hidden state h_t

h_t = o_t ⊙ tanh(c_t)

h_{t-1}, x_t
      ↓
sigmoid
      ↓
o_t 계산

c_t → tanh(c_t)
          ↓
      o_t와 곱함
          ↓
        h_t
        
cell state c_t는 내부 기억이고, hidden state h_t는 output gate가 허락한 만큼 밖으로 드러난 표현임.

이전 기억 c_{t-1}
      ↓ **forget gate가 조절**
유지할 기억

새 후보 기억 c̃_t
      ↓ **input gate가 조절**
추가할 기억

유지할 기억 + 추가할 기억
      ↓
현재 cell state c_t
      ↓ **output gate가 조절**
hidden state h_t

Vanilla RNN은 과거 정보를 하나의 hidden state h_t에 계속 압축하여 저장하기 때문에 sequence가 길어질수록 정보가 손실되거나 덮이는 information bottleneck 문제가 발생할 수 있다. LSTM은 이를 해결하기 위해 별도의 기억 경로인 cell state c_t를 도입한다. c_t는 장기 기억을 저장하는 내부 memory pathway이고, h_t는 출력이나 다음 layer에 전달되는 hidden representation이다. 또한 LSTM은 forget gate, input gate, output gate를 사용하여 이전 기억을 얼마나 유지할지, 새로운 정보를 얼마나 추가할지, 저장된 기억을 얼마나 출력할지를 조절한다.

LSTM은 매 시점마다 이전 hidden state (h{t-1})와 현재 입력 (x_t)를 함께 보고, cell state (c_t)와 hidden state (h_t)를 계산한다. 먼저 forget gate는 이전 cell state (c{t-1})에 저장된 기억 중 어떤 정보를 유지하고 어떤 정보를 잊을지 결정한다. 그다음 input gate는 현재 입력으로부터 들어온 새로운 정보를 얼마나 cell state에 반영할지 결정하고, candidate cell state (\tilde{c}_t)는 새로 저장될 후보 기억을 만든다.

이후 cell state update 단계에서 이전 기억 중 유지할 부분 (ft \odot c{t-1})과 새로 추가할 후보 기억 (i_t \odot \tilde{c}_t)를 더해 현재 cell state (c_t)를 만든다. 즉, (c_t)는 과거 기억 중 필요한 것은 남기고, 현재 시점에서 필요한 새 정보는 추가한 결과이다.

마지막으로 output gate는 내부 기억인 (c_t) 중에서 현재 시점의 hidden state (h_t)로 얼마나 밖에 드러낼지 결정한다. 이때 (c_t)를 (tanh)로 정리한 뒤 output gate가 허락한 만큼만 (h_t)로 내보낸다. 따라서 LSTM은 단순히 모든 정보를 계속 덮어쓰는 것이 아니라, gate를 이용해 무엇을 잊고, 무엇을 저장하고, 무엇을 출력할지 조절하는 구조이다.

forget gate → 이전 기억 중 무엇을 유지할지 결정

input gate → 새로운 정보 중 무엇을 추가할지 결정

output gate → 저장된 기억 중 무엇을 밖으로 보여줄지 결정

GRU (Gated Recurrent Unit)

LSTM은 강력한 모델이지만 상대적으로 복잡하다. LSTM은 세 개의 gate를 가지고 있으며, cell state와 hidden state를 분리해서 사용한다.

반면 GRU, 즉 Gated Recurrent Unit은 이러한 구조를 단순화한 모델이다. GRU는 LSTM처럼 별도의 cell state를 유지하지 않는다. 대신 hidden state를 주요 기억 표현으로 사용하고, 이를 update/reset gate라는 두 개의 gate로 조절한다. GRU는 LSTM과 달리 cell state도 없고, hidden state 하나를 기억으로 사용하고 gate도 두개만 사용하므로 LSTM보다 구조도 간단하고 계산량도 적은 편이다. 이 구조는 모델링 능력과 계산 효율성 사이에서 좋은 균형을 제공하는 경우가 많다.

정리하면, GRU는 LSTM의 구조를 단순화한 RNN 계열 모델이다. LSTM은 cell state와 hidden state를 분리하고 세 개의 gate를 사용하지만, GRU는 별도의 cell state 없이 hidden state를 주요 기억으로 사용하며 update gate와 reset gate 두 개만 사용한다.
따라서 GRU는 LSTM보다 구조가 단순하고 계산 효율성이 좋으면서도, 순차 데이터의 장기 의존성을 어느 정도 잘 처리할 수 있다.

모델	기억 상태	gate 개수	특징
LSTM	cell state, hidden state 분리	3개	복잡하지만 장기 의존성 처리에 강함
GRU	hidden state 하나를 기억으로 사용	2개	구조가 단순하고 계산 효율적

reset gate

후보 hidden state를 만들 때 이전 hidden state를 얼마나 참고할지 결정함.
r_t ≈ 0 → 이전 기억을 거의 무시함 / r_t ≈ 1 → 이전 기억을 많이 참고함

r_t = σ(W_r [h_{t-1}, x_t] + b_r)

Candidate Hidden State

reset gate로 조절된 과거 정보와 현재 입력을 이용해 새 후보 hidden state를 만듦.
r_t⊙h_{t−1} : 이전 hidden state를 그대로 쓰는 것이 아닌 reset gate를 곱해 이전 기억을 얼마나 반영할지 조절한 뒤 후보 기억을 만들어냄.
후보 기억은 현재 입력만 보고 만드는 게 아니라, 필요한 만큼만 과거 기억을 참고해서 만듦.
현재 입력 x_t + 조절된 이전 기억 → 새 후보 기억 h̃_t

h̃_t = tanh(W_h [r_t ⊙ h_{t-1}, x_t] + b_h)

update gate

이전 hidden state를 유지할지, 새 후보 hidden state를 반영할지 결정함.

z_t = σ(W_z [h_{t-1}, x_t] + b_z)

Final Hidden State

최종 기억 = 이전 기억 중 남길 부분 + 새 후보 기억 중 반영할 부분
새 hidden state = 이전 hidden state 일부 + 새 후보 hidden state 일부
새 hidden state가 이전 hidden state와 새 candidate hidden state의 weighted mixture
z_t = 0이면 이전 정보를 거의 유지하고, 반대의 경우엔 새 후보 정보를 많이 사용함.

h_t = (1 - z_t) ⊙ h_{t-1} + z_t ⊙ h̃_t

1. reset gate r_t 계산
   → 후보 기억을 만들 때 이전 기억을 얼마나 참고할지 결정

2. candidate hidden state h̃_t 계산
   → 현재 입력과 조절된 이전 기억으로 새 후보 기억 생성

3. update gate z_t 계산
   → 이전 기억과 새 후보 기억을 어떤 비율로 섞을지 결정

4. final hidden state h_t 계산
   → 최종 기억 완성

RNN, LSTM, GRU 비교

RNN, LSTM, GRU는 모두 시간에 따라 state를 유지하면서 sequential data를 처리한다. 차이는 memory를 어떻게 관리하느냐이다.

Vanilla RNN은 hidden state만 사용한다. 구조가 단순하지만 긴 sequence에서 long-term dependency를 학습하기 어렵다.

LSTM은 cell state와 세 개의 gate를 도입한다. 이를 통해 memory를 유지하고, 새로 쓰고, 외부로 노출하는 과정을 명시적으로 제어할 수 있다.

GRU는 별도의 cell state를 제거하고 두 개의 gate만 사용한다. 그래서 LSTM보다 단순하면서도 memory를 조절할 수 있어, 모델링 성능과 계산 효율 사이의 균형을 제공한다.

실제 문제에서는 먼저 간단한 RNN을 baseline으로 사용해보고, 같은 검증 방식으로 GRU와 LSTM을 비교하는 것이 좋다. 실험 결과는 모델의 절대 순위가 아니라, 데이터 특성에 맞게 해석해야 한다.

항목	RNN	LSTM	GRU
기억 구조	hidden state만 사용	cell state와 hidden state 사용	hidden state만 사용하되 gate로 조절
게이트	없음	forget, input, output	update, reset
장기 의존성	약함	강함	비교적 강함
파라미터 수	적음	많음	LSTM보다 적음
계산 효율	높음	낮은 편	중간~높음
학습 안정성	불안정할 수 있음	보통 안정적	보통 안정적
추천 사용	짧은 sequence, baseline	긴 문맥, 정교한 memory 제어	정확도와 효율의 균형