Attention과 Transformer

인화·2026년 6월 17일

Deep Learning

목록 보기

8/10

Attention과 Transformer 내부 동작

Attention 등장 배경 (→ 왜 Attention이 필요했는가?)

기존 RNN 기반 Sequence-to-Sequence 모델은 입력 문장을 순서대로 읽고, 마지막 hidden state 또는 하나의 context vector c에 입력 전체의 정보를 압축한 뒤 decoder로 전달하는 구조이다. 예를 들어 영어 문장 we see the sky를 이탈리아어 vediamo il cielo로 번역할 때, encoder는 입력 단어들을 순서대로 처리하여 hidden state를 만들고, decoder는 그 정보를 바탕으로 출력 단어를 하나씩 생성한다.

그러나 입력 문장의 길이가 길어질수록 모든 정보를 고정 크기의 vector 하나에 담기 어려워지는 bottleneck 문제가 발생한다. 즉, 긴 sequence의 중요한 정보가 마지막 hidden state나 context vector에 충분히 보존되지 못할 수 있다.

이를 해결하기 위해 등장한 것이 Attention이다. Attention은 decoder가 매 출력 시점마다 입력 sequence 전체를 다시 참고하면서, 현재 생성하려는 단어와 관련 있는 입력 부분에 더 큰 가중치를 부여하는 방식이다. 예를 들어 vediamo를 생성할 때는 we see 부분을 더 많이 참고하고, il을 생성할 때는 the, cielo를 생성할 때는 sky를 더 많이 참고한다. 따라서 Attention을 사용하면 하나의 고정된 context vector에만 의존하지 않고, 출력 시점마다 필요한 입력 정보를 선택적으로 활용할 수 있다.

초기 Attention 방식

Bahdanau Attention

RNN Encoder-Decoder에 붙은 대표적인 초기 Attention 방식으로, Decoder의 현재 상황과 Encoder의 각 hidden state를 비교해서 어느 입력 단어를 볼지 점수로 정한다.

아래의 수식에서 f_att는 작은 신경망 또는 linear layer를 의미한다. 아래의 수식을 통해 alignment score를 계산하고, softmax로 attention weight를 만든 뒤 context vector를 만든다. 여기서 e_{t,i}는 decoder의 현재 시점 t가 입력 위치 i를 얼마나 참고해야 하는지 나타내는 점수이고, a_{t,i}는 softmax를 거친 attention weight이다. c_t는 attention weight를 이용해 encoder hidden state들을 가중합한 context vector이다. 이렇게 alignment score를 계산하고, 이를 softmax로 attention weight로 바꾼 뒤, hidden state들의 weighted sum으로 context vector를 만든다.

score 계산 → softmax로 비율화 → weighted sum으로 정보 결합

e_{t,i} = f_{att}(s_{t-1}, h_i)

a_{t,i} = softmax(e_{t,i})

c_t = Σ_i a_{t,i} h_i

즉, 아래와 같은 흐름으로 정리할 수 있다.

decoder 상태 $s_{t-1}$ 와 encoder hidden state h_i를 비교한다.
alignment score $e_{t,i}$ 를 만든다.
softmax로 attention weight $a_{t,i}$ 를 만든다.
encoder hidden state들을 attention weight로 가중합한다.
context vector $c_t$ 를 만든다.
decoder가 $c_t$ 를 이용해 다음 단어를 생성한다.

Attention Layer를 일반화하면?

일반 Attention Layer는 다음과 같다.

입력:
- Query vector q
- Data vectors X

계산:
1. q와 각 X_i의 유사도 e_i 계산
2. e_i를 softmax해서 attention weight a_i 계산
3. X_i들을 a_i로 가중합해서 output y 생성

즉, Query가 data vector들 중에서 필요한 정보를 찾고,
그 비율대로 정보를 섞어 output vector를 만드는 연산을 하는 것이 Attention Layer이다.

Luong Attention

Decoder가 현재 출력에 필요한 encoder hidden state를 고르는 것이라는 목적은 같으나, 점수 계산 방식에서 Bahdanau는 decoder 상태와 encoder hidden state를 작은 신경망에 넣어서 점수를 계산하는데 반해, Luong Attention은 좀 더 단순하게 dot product 계열로 계산한다. (두 벡터를 바로 내적해서 비슷하면 점수 높게 주는 것)

score(s_t, h_i) = s_t^T h_i

구분	Bahdanau Attention	Luong Attention
별명	Additive Attention	Multiplicative / Dot Attention
점수 계산	작은 신경망으로 계산	내적 또는 행렬 곱으로 계산
느낌	“둘을 합쳐서 신경망이 판단”	“두 벡터가 얼마나 비슷한지 바로 계산”
장점	표현력이 좋음	계산이 단순하고 빠름
공통점	둘 다 attention score → softmax → weighted sum

두 방식 모두 현재 decoder가 입력 중 어디를 봐야 하는지 점수화하려는 목적을 지니고 있다.

Self-Attention과 Q/K/V

Q/K/V Attention 계산 (Scaled Dot-Product Attention)

입력 token embedding을 X라고 할 때, Transformer에서는 X에 서로 다른 가중치 행렬을 곱해서 Q, K, V를 만들고, Query와 Key를 비교해 점수를 구한다.

                                                     $Q = XW_Q$ / $K = XW_K$ / $V = XW_V$

score = QK^T

이 점수에 softmax를 적용해서 attention weight를 만들고, 그 weight와 Value를 섞는 것이 Transformer에서의 Attention의 핵심이다.

이를 정리하면 다음과 같다.

입력 X에서 Q, K, V를 만든다.
$QK^T$ 를 계산해서 query와 key의 유사도를 구한다.
$\sqrt{d_k}$ 로 나누어 scale을 조정한다.
softmax를 적용해서 attention weight를 만든다.
attention weight와 V를 곱해서 output을 만든다.

기호	의
`Q` Query	지금 내가 찾고 싶은 정보
`K` Key	각 token이 가진 검색용 특징
`V` Value	실제로 가져올 정보

√d_k scaling

QK^T는 Query와 Key의 dot product이다. 그런데 d_k, 즉 Key/Query 벡터의 차원이 커질수록 dot product 값이 커질 수 있다. 이 값이 너무 커지면 softmax가 한쪽으로 심하게 쏠린다.

예를 들어, softmax([1, 2, 3])은 비교적 여러 값에 분산될 수 있지만, softmax([10, 20, 30])은 큰 값 하나에 거의 몰리는 경향성을 지닌다. 이렇게 되면 attention이 한두 token에만 지나치게 집중되고, gradient가 작아져 학습이 불안정해질 수 있다. 그래서 √d_k로 나누어 score의 크기를 줄인다.

Scaled Dot-Product Attention에서 √d_k로 나누는 이유는 Query와 Key의 dot product 값이 차원이 커질수록 커져 softmax가 한쪽으로 과도하게 쏠리는 것을 방지하기 위해서이다. 이를 통해 attention weight가 지나치게 뾰족해지는 것을 완화하고, gradient가 작아져 학습이 불안정해지는 문제를 줄일 수 있다.

Self-Attention

Self-Attention은 같은 sequence 안의 token들끼리 서로를 참고하는 Attention이다. 일반 RNN Attention에서는 decoder가 encoder의 hidden state를 참고했던 것과는 달리, Self-Attention에서는 같은 문장 안의 token들이 서로를 참고한다. 예를 들어, I love deep learning이라는 문장이 있을 때 각 token이 문장 안의 다른 token들을 보면서 자신의 표현을 새롭게 만든다. 아래의 예시를 보면 learning은 deep을 많이 참고할 수 있고, love는 I를 많이 참고할 수 있다. 이렇게 token들이 서로의 관계를 계산해 더 문맥적인 표현으로 바뀌는 것이 Self-Attention이다.

I       → I, love, deep, learning 중 어디를 볼까?
love    → I, love, deep, learning 중 어디를 볼까?
deep    → I, love, deep, learning 중 어디를 볼까?
learning→ I, love, deep, learning 중 어디를 볼까?

Self-Attention에서는 입력 X 하나에서 Q, K, V가 모두 나온다. 그래서 모든 token이 Query가 될 수도 있고, Key/Value가 될 수도 있다. 즉, Self-Attention은 같은 입력 sequence 내부에서 token들끼리 Q, K, V 관계를 통해 서로 얼마나 참고할지 계산하는 방식이다.

요소	의미
Query `Q`	현재 token이 찾는 정보
Key `K`	다른 token들이 가진 검색 기준
Value `V`	실제로 가져와서 섞을 정보

추가 중요 포인트 - Score와 Attention Weight 비교

Score는 softmax 전의 유사도이고, attention weight는 softmax 후의 참고 비율이다.
Attention weight의 각 행은 확률 분포처럼 합이 1이 된다.

RNN과 Self-Attention의 차이

RNN은 입력을 순서대로 처리한다. 따라서 x3를 처리하려면 x2가 끝나야 하고, x2를 처리하려면 x1이 끝나야 한다. 이 때문에 병렬화가 어렵고, 긴 문장에서 멀리 떨어진 정보가 잘 전달되기 어렵다.

반면 Transformer는 Self-Attention을 사용해 모든 token 관계를 한 번에 계산한다. 이 관계 계산을 행렬곱으로 한 번에 처리할 수 있기 때문에 RNN보다 병렬화에 유리하다.

x1 ↔ x2
x1 ↔ x3
x1 ↔ x4
x2 ↔ x3
x2 ↔ x4
x3 ↔ x4

이러한 Self-Attention은 입력 벡터들의 순서를 바꾸면 출력도 같은 방식으로 순서만 바뀌는 permutation equivariant 성질을 지닌다. 따라서 Self-Attention 자체는 벡터들의 집합에 대해 동작한다. 이러한 특성 때문에 Self-Attention은 token 간 관계는 잘 계산하지만, 그 자체만으로는 순서 정보를 알지 못한다. 이것이 Transformer에 Positional Encoding이 필요한 이유이다. 즉 ,Self-Attention은 token 간 관계를 계산하고, Positional Encoding이 token의 위치 정보를 보완한다.

Positional Encoding

Self-Attention은 같은 sequence 안의 token들이 서로를 얼마나 참고할지 계산하는 구조이다. 즉, token 간 관계는 잘 계산한다. 하지만 Self-Attention 자체는 입력을 순서가 있는 문장이라기보다 벡터들의 집합처럼 다룬다. 그래서 입력 벡터들의 순서를 바꾸면 출력도 같은 방식으로 순서만 바뀌는 permutation equivariant 성질을 가진다. 이 말은 곧, Self-Attention만으로는 token의 순서 정보를 명시적으로 알 수 없다는 뜻이다.

예를 들어 다음 두 문장은 단어는 비슷하지만 순서가 다르다.

I love you
You love I

사람은 순서가 다르기 때문에 의미가 다르다는 것을 알지만, Self-Attention만 사용하면 어떤 token이 몇 번째 위치에 있는지에 대한 정보가 부족하다. 따라서 Transformer는 token embedding에 Positional Encoding을 더해준다.

Transformer 입력 = token embedding + positional encoding

이렇게 하면 모델은 token의 의미뿐 아니라 그 token이 문장 안에서 어디에 있는지도 함께 알 수 있다. 논문에서도 Transformer는 recurrence와 convolution을 사용하지 않기 때문에 sequence 순서를 활용하려면 token의 상대적 또는 절대적 위치 정보를 주입해야 하며, 이를 위해 encoder와 decoder 입력 embedding에 positional encoding을 더한다고 설명한다.

또한, Transformer 논문에서 사용한 대표적인 방식은 sinusoidal positional encoding이다. 이는 sin과 cos 함수를 이용해 위치별로 서로 다른 패턴의 벡터를 만드는 방식이다. 즉, 짝수 차원에는 sin 값을 넣고, 홀수 차원에는 cos 값을 넣어 각 위치마다 고유한 위치 벡터가 만들어진다.

이러한 sin/cos positional encoding은 위치마다 서로 다른 주기 패턴을 가진다. 가까운 위치는 positional encoding 패턴이 비교적 비슷하고, 먼 위치는 다른 패턴을 보인다.

그래서 모델은 token의 절대 위치뿐 아니라 상대적인 거리 정보도 어느 정도 학습할 수 있다. Transformer 논문에서도 sinusoidal positional encoding을 사용한 이유 중 하나로, 특정 offset k에 대해 PE(pos+k)가 PE(pos)의 선형 함수로 표현될 수 있어 상대 위치를 학습하기 좋을 것이라고 설명한다.

쉽게 말해, pos 1과 pos 2는 비교적 가까운 위치라 비슷한 패턴 / pos 1과 pos 100은 먼 위치라 다른 패턴을 보여 위치 차이를 모델이 구분할 수 있게 된다.

다만, Positional Encoding 자체가 단어 의미를 담는 것은 아니다. 예를 들어, love라는 단어의 의미는 token embedding에 들어 있다. Positional Encoding은 단지 그 token이 몇 번째 위치에 있는지를 알려준다. 두 벡터를 더해서 Transformer에 넣으면, 모델은 이 단어가 무엇인지와 이 단어가 어디에 있는지를 함께 사용할 수 있다.

** positional encoding 자체가 의미를 담는 것은 아니고, 의미 표현은 token embedding과 여러 attention layer를 거치며 형성된다.
token embedding = 단어의 의미 정보
positional encoding = token의 위치 정보

Encoder Attention과 Decoder Causal Mask

BERT나 ViT처럼 입력 전체를 이해하는 encoder는 보통 모든 token이 서로를 볼 수 있다. 반면 GPT 계열 decoder는 다음 token을 예측해야 하므로 미래 token을 보면 안 된다. 이를 위해 causal mask를 사용한다.

Encoder Attention

Encoder Attention은 입력 전체를 이해하기 위한 attention이다. Encoder에서는 각 token이 자기 자신을 포함해 모든 token을 볼 수 있다. 왜냐하면 encoder의 목적은 입력 문장 전체를 이해하는 것이기 때문이다.

Encoder에서는 각 입력 위치가 자기 자신을 포함한 모든 입력 위치를 참고할 수 있다. 행렬 관점에서는 모든 query-key 쌍에 대해 score가 계산된다.
Encoder-style attention에서는 별도 causal mask 없이 모든 token을 볼 수 있다.
BERT나 ViT 같은 encoder-style 모델은 전체 입력을 보고 분류, 이해, 표현 학습을 수행한다.

Encoder Attention
= 모든 token이 모든 token을 볼 수 있음
= 입력 전체 이해에 사용
= BERT, ViT 같은 encoder-style 모델에서 사용

Decoder Causal Mask

이와 달리, GPT 같은 decoder-only 모델은 현재까지 나온 token을 보고 다음 token을 예측하는 모델이다. 예를 들어, I love deep라는 문장이 있을 때 deep까지만 보고 다음 단어 learning을 예측해야 한다.

학습할 때 현재 위치가 미래 token을 볼 수 있으면 문제가 생긴다. 예를 들어 deep 위치에서 이미 뒤에 있는 learning을 볼 수 있다면, 모델은 정답을 미리 보고 맞히는 꼴이 된다. 이러면 실제 생성 상황과 맞지 않는다. 실제로 글을 생성할 때는 미래 단어를 모르기 때문이다. 그래서 decoder에서는 미래 token을 가려야 한다.

이를 위해 Causal Mask를 활용한다. Causal Mask는 decoder가 미래 token을 보지 못하도록 막는 mask이다. 현재 위치 i는 자기 자신과 이전 위치 j ≤ i까지만 볼 수 있다.

이러한 Causal Mask는 softmax 전에 적용된다. attention score가 있다고 할 때, 미래 token에 해당하는 score를 아주 작은 값, 보통 -inf로 바꾼다. 그 다음 softmax를 적용하면 -inf였던 위치의 attention weight는 0이 된다. 즉, 미래 token은 attention weight가 0이 되므로 참고하지 못한다.

scores = QK^T / √d_k

구분	Encoder Attention	Decoder Causal Attention
볼 수 있는 범위	모든 token	과거 token + 현재 token
미래 token 접근	가능	불가능
mask 사용	보통 causal mask 없음	causal mask 사용
대표 모델	BERT, ViT	GPT 계열
목적	입력 전체 이해	다음 token 예측, 텍스트 생성

Decoder Causal Attention
= 현재 token이 미래 token을 보지 못하게 함
= causal mask를 사용
= GPT 계열의 다음 token 예측에 필요

Encoder Attention에서는 입력 전체를 이해해야 하므로 각 token이 자기 자신을 포함한 모든 token을 참고할 수 있다. 반면 GPT 계열 decoder는 현재까지의 token을 바탕으로 다음 token을 예측하는 auto-regressive 모델이므로, 현재 위치에서 미래 token을 보면 안 된다. 이를 방지하기 위해 causal mask를 사용하며, 현재 위치 i는 j ≤ i인 위치만 참고할 수 있다. Causal mask는 softmax 전에 미래 위치의 score를 매우 작은 값으로 바꾸어, softmax 이후 해당 위치의 attention weight가 0이 되도록 한다.

GPT 계열 decoder-only 모델은 다음 token을 예측해야 하므로 현재 위치에서 미래 token을 보지 못하도록 mask를 적용한다. 오른쪽의 GPT 구조에서 Mask → Softmax → Matmul 흐름이 causal attention 계산과 연결된다.

Multi-Head Self-Attention과 Shape 변화

Self-Attention은 token들이 서로를 얼마나 참고할지 계산하는 구조이다. 그런데 하나의 attention head만 사용하면 token 간 관계를 한 가지 방식으로만 볼 수 있다. 문장 안에는 여러 종류의 관계가 있다. 그러나, 하나의 attention head만 있으면 이런 다양한 관계를 한 번에 충분히 포착하기 어렵다. 그래서 Transformer는 여러 개의 attention head를 병렬로 사용한다.

Multi-Head Attention은 입력을 여러 개의 서로 다른 projection 공간으로 보내고, 각 공간에서 attention을 따로 계산한다. 즉, 하나의 입력 X에서 여러 head마다 서로 다른 Q, K, V를 만든다.

!image.png

Head 1: Q1, K1, V1로 attention 계산
Head 2: Q2, K2, V2로 attention 계산
Head 3: Q3, K3, V3로 attention 계산
...
Head H: QH, KH, VH로 attention 계산

각 head는 같은 문장을 보지만, 서로 다른 가중치 행렬을 사용하기 때문에 서로 다른 관점에서 token 관계를 학습할 수 있다.

Multi-Head Attention의 전체 흐름은 다음과 같다.
1. 입력 X를 받는다.
2. 각 head마다 Q, K, V를 만든다.
3. 각 head에서 Scaled Dot-Product Attention을 계산한다.
4. 각 head의 attention output을 concat한다.
5. concat된 결과에 output projection을 적용한다.
6. 다음 layer로 전달한다.

즉, 여러 attention head가 서로 다른 projection 공간에서 병렬로 관계를 계산하고, 각 head의 출력은 concat 후 output projection을 거쳐 다음 layer로 전달되는 흐름을 지닌다. 이러한 구조는 서로 다른 representation subspace와 위치의 정보를 동시에 볼 수 있게 해준다.

여기서 각 head는 기본적으로 Scaled Dot-Product Attention을 수행한다. 하지만 head마다 사용하는 projection matrix가 다르다. 그래서 같은 입력 X를 보더라도 head마다 다른 표현 공간에서 관계를 계산한다.

Head 1:
Q1 = XW_Q1
K1 = XW_K1
V1 = XW_V1

Head 2:
Q2 = XW_Q2
K2 = XW_K2
V2 = XW_V2

Shape 변화

B = batch size
L = sequence length
D = d_model
H = number of heads
d_h = D / H

단계	설명	Shape
입력	token embedding	`[B, L, D]`
Q/K/V projection	Linear layer 통과	`[B, L, D]`
head 분리	`D`를 `H × d_h`로 나눔	`[B, L, H, d_h]`
transpose	head 차원을 앞으로 이동	`[B, H, L, d_h]`
score 계산	`QKᵀ`	`[B, H, L, L]`
softmax	attention weight	`[B, H, L, L]`
V와 곱함	각 head의 output	`[B, H, L, d_h]`
concat	head들을 다시 합침	`[B, L, D]`
output projection	최종 선형변환	`[B, L, D]`

concat 후 output projection을 하는 이유

각 head는 서로 다른 관점에서 attention 결과를 만든다. 하지만 head별 결과가 따로따로 있으면 다음 layer에서 사용하기 어렵다. 그래서 각 head의 output을 하나로 이어 붙인다. concat하면 다시 [B, L, D]의 형태가 된다. 그 다음 output projection을 적용해서 여러 head에서 나온 정보를 다시 섞고 정리한다. 즉, output projection은 여러 head의 결과를 종합해서 다음 Transformer block에 넘기기 위한 단계이다.

Concat(head1, head2, ..., headH) → Output Projection

구분	Single-Head Self-Attention	Multi-Head Self-Attention
head 개수	1개	여러 개
관계 포착	한 가지 관점	여러 관점
Q/K/V projection	한 세트	head마다 다른 projection
출력 처리	바로 output	head output concat 후 projection
장점	구조가 단순함	다양한 관계를 동시에 학습 가능

Transformer 구조

Transformer는 기존 RNN 기반 Encoder-Decoder 구조처럼 Encoder와 Decoder를 가진다. 하지만 중요한 차이는 RNN이나 CNN을 사용하지 않고 Attention을 중심으로 구성된다는 점이다. 즉, RNN처럼 입력을 순서대로 처리하지 않고, Self-Attention을 통해 token들 사이의 관계를 한 번에 계산한다.

Encoder

Encoder는 입력 문장을 이해하는 역할을 한다. Encoder layer 하나는 보통 다음과 같이 구성된다. 논문에서는 encoder가 N=6개의 동일한 layer로 구성되고, 각 layer는 Multi-Head Self-Attention과 position-wise Feed-Forward Network 두 sub-layer를 가진다고 설명한다. 각 sub-layer 주변에는 residual connection이 있고, 그 뒤에 layer normalization을 적용한다.

이때, Self-Attention만 token들 사이의 상호작용을 담당하고, LayerNorm과 MLP는 각 token vector에 독립적으로 적용된다. 즉, token끼리 정보를 섞는 부분은 attention이고, MLP는 이미 섞인 각 token 표현을 더 복잡하게 변환하는 역할이다.

구성 요소	역할
Multi-Head Self-Attention	입력 token들이 서로를 참고해 문맥 정보 생성
Feed Forward Network	각 token 표현을 비선형적으로 변환
Add & Norm	Residual Connection + Layer Normalization

Input
 → Multi-Head Self-Attention
 → Add & Norm
 → Feed Forward Network
 → Add & Norm

Decoder

Decoder는 출력 문장을 생성하는 역할을 한다. Decoder layer는 Encoder보다 attention block이 하나 더 많다.

Output Embedding
 → Masked Multi-Head Self-Attention
 → Add & Norm
 → Encoder-Decoder Attention
 → Add & Norm
 → Feed Forward Network
 → Add & Norm
 → Output

Decoder는 크게 세 부분으로 구성된다.

구성 요소	역할
Masked Multi-Head Self-Attention	지금까지 생성된 token들만 보고 다음 token 예측
Encoder-Decoder Attention	Encoder의 출력 정보를 참고
Feed Forward Network	각 token 표현을 비선형적으로 변환

Decoder의 첫 attention은 masked self-attention이다. 다음 단어를 예측할 때 미래 단어를 보면 안 되기 때문에, 현재 위치 이후 token은 가린다. 즉, decoder self-attention은 auto-regressive 성질을 유지하기 위해 미래 위치를 볼 수 없도록 mask를 적용한다.

Decoder에는 Encoder에는 없는 attention이 하나 더 있다. Encoder-Decoder Attention(=Cross Attention)이다. 이는 Decoder가 출력 단어를 만들 때, Encoder가 이해한 입력 문장 정보를 참고하는 부분이다. 예를 들어 번역에서 Decoder가 cielo를 만들 때 Encoder 출력 중 sky와 관련된 정보를 참고할 수 있다. 즉, decoder가 자기 상태를 Query로 삼아 encoder output에서 필요한 정보를 찾아오는 attention이다. 이렇게 decoder가 출력을 만들 때 encoder가 봐야할 부분을 찾아올 수 있다.

입력: we see the sky
출력: vediamo il cielo

Decoder의 현재 상태 → Query
Encoder 출력 → Key, Value

정리하면, Self-Attention은 같은 sequence 내부에서 token들이 서로 보는 것이고, Encoder-Decoder Attention은 Decoder가 Encoder의 출력 정보를 보는 것이다.

왜 Transformer 구조가 좋은가?

Transformer는 RNN처럼 입력을 순차적으로 처리하지 않고, Self-Attention을 이용해 sequence 내 모든 token 간 관계를 한 번에 계산한다. 따라서 training example 내부에서 병렬화가 가능하며, 멀리 떨어진 token도 attention을 통해 직접 연결할 수 있어 장기 의존성 학습에 유리하다.

RNN은 이전 hidden state가 계산되어야 다음 hidden state를 계산할 수 있으므로 sequential operation이 O(n)이고 병렬화가 어렵다. 반면 Self-Attention은 sequential operation과 maximum path length가 O(1)이므로 병렬화와 장거리 정보 전달에 유리하다.

다만 모든 token 쌍을 비교하므로 per-layer complexity가 O(n²d)로, 매우 긴 sequence에서는 계산량과 메모리 사용량이 커지는 한계가 있다.

장점	설명
병렬 처리 가능	RNN처럼 앞 token 계산이 끝나야 다음 token을 계산하는 구조가 아님
장거리 의존성 학습에 유리	멀리 떨어진 token도 attention으로 바로 연결 가능
확장성이 좋음	언어, 이미지, 음성 등 다양한 데이터에 적용 가능

Self-Attention, RNN, Convolution 비교

Transformer 논문은 Self-Attention, RNN, Convolution을 계산 복잡도, 병렬화 가능성, 장기 의존성 경로 길이 관점에서 비교한다. 표에서는 Self-Attention이 모든 위치를 한 번에 연결하므로 sequential operation과 maximum path length가 O(1)이고, RNN은 순서대로 계산해야 해서 O(n)이라고 정리한다.

정리하면, Self-Attention은 긴 거리의 token을 직접 연결할 수 있어 장기 의존성 학습에 유리하고 병렬화도 잘 된다. 다만 sequence 길이 n에 대해 attention score matrix가 [L, L]로 생기기 때문에 아주 긴 sequence에서는 계산량과 메모리 사용량이 커진다.

관점	Self-Attention	RNN	Convolution
장기 의존성	멀리 떨어진 token도 한 번에 연결	여러 time step을 거쳐야 함	kernel 크기/층 수에 따라 점진적으로 연결
병렬화	좋음. 모든 token 동시 계산 가능	나쁨. 이전 hidden state가 필요	좋음. 위치별 병렬 계산 가능
sequential operation	`O(1)`	`O(n)`	`O(1)`
maximum path length	`O(1)`	`O(n)`	`O(log_k n)`
per-layer complexity	`O(n²d)`	`O(nd²)`	`O(knd²)`
단점	sequence가 길면 `n²` 때문에 비용 큼	긴 문맥/병렬화에 약함	먼 위치 연결에 여러 layer 필요

Transformer 기반 모델

Encoder-only / Decoder-only / Encoder-Decoder 모델 정리

구조	핵심 특징	대표 모델	대표 task
Encoder-only	입력 전체를 양방향으로 보고 이해함	BERT, ViT	문장 분류, 감정 분석, 이미지 분류
Decoder-only	과거 token만 보고 다음 token을 생성함	GPT-2	텍스트 생성
Encoder-Decoder	Encoder가 입력을 이해하고, Decoder가 출력 생성/예측을 수행함	DETR, 번역 모델	객체 검출, 번역, seq2seq

BERT

Encoder-only 모델은 입력 전체를 한 번에 보고 이해하는 구조이다. Encoder에서는 각 token이 앞뒤 token을 모두 볼 수 있다. 그래서 문장 분류, 감정 분석, 이미지 분류처럼 입력 전체를 보고 판단하는 task에 많이 쓰인다.

그 중 하나인 BERT는 텍스트용 Transformer Encoder이다. BERT는 문장을 입력받아 전체 문맥을 양방향으로 이해한다. 즉, 어떤 token을 해석할 때 앞 token과 뒤 token을 모두 참고할 수 있다. BERT 입력은 보통 세 가지 embedding을 더해서 만든다.

BERT는 token embedding, segment embedding, position embedding을 더해 encoder에 넣고, 사전학습에서는 일부 token을 [MASK]로 바꾼 뒤 주변 문맥으로 원래 token을 맞히는 masked language modeling을 사용한다.

또 BERT는 문장을 단어 그대로 처리하지 않고 subword token으로 나눈다. 예를 들어 하나의 단어가 ##가 붙은 여러 조각 token으로 나뉠 수 있다.

ViT

ViT는 이미지용 Transformer Encoder이다. 기존 CNN처럼 이미지를 convolution으로 처리하는 것이 아니라, 이미지를 작은 patch로 나누고 각 patch를 token처럼 Transformer에 넣는다. 예를 들어 google/vit-base-patch16-224는 224×224 이미지를 16×16 patch로 나눈다.

224 / 16 = 14
14 × 14 = 196개 patch

위의 예시에서 [CLS] token을 추가하면 sequence length는 197이 된다. ViT는 이미지를 일정한 크기의 patch로 나누고, 각 patch를 token처럼 embedding하며, [CLS] token의 최종 representation을 MLP head에 넣어 이미지 분류 결과를 낸다.

GPT

Decoder-only 모델은 현재까지 나온 token들을 보고 다음 token을 예측하는 구조이다. 이때 미래 token을 보면 안 되므로 causal mask 또는 masked self-attention을 사용한다. 그래서 텍스트 생성 task에 적합하다.

GPT-2는 Decoder-only Transformer로, 주어진 prompt 뒤에 이어질 token을 하나씩 생성한다. 예를 들어, Once upon a time,이라는 prompt가 주어지면, GPT-2는 다음에 올 단어를 예측하고, 다시 그 단어를 이용해 그다음 단어를 예측하는 방식으로 문장을 생성한다.

DETR

Encoder-Decoder 구조는 입력을 이해하는 Encoder와 출력을 만드는 Decoder를 함께 사용한다. 기계번역처럼 입력 sequence와 출력 sequence가 다를 때 많이 사용된다. 객체 검출에서도 DETR처럼 Encoder-Decoder 구조를 사용할 수 있다.

DETR은 Detection Transformer로, 객체 검출에 Transformer Encoder-Decoder 구조를 적용한 모델이다. 이미지를 입력받고, 이미지 안의 객체가 무엇인지와 어디에 있는지를 예측한다. 즉, 출력은 단순 class 하나가 아니라 객체 class + bounding box 위치 + confidence score이다.

정리

BERT, GPT-2, ViT, DETR은 모두 Transformer 기반 모델이지만 구조와 task가 다르다. BERT는 Encoder-only 구조로 텍스트 입력을 양방향으로 이해하며, token embedding, position embedding, segment embedding을 더해 encoder에 입력한다. 주로 문장 분류나 감정 분석 같은 자연어 이해 task에 사용된다. GPT-2는 Decoder-only 구조로, masked self-attention을 사용해 미래 token을 보지 않고 다음 token을 예측하므로 텍스트 생성에 적합하다. ViT는 이미지를 patch로 나누어 각 patch를 token처럼 처리하는 Encoder-only 모델이며, [CLS] token의 최종 표현을 이용해 이미지 분류를 수행한다. DETR은 Encoder-Decoder 구조를 가진 객체 검출 모델로, 이미지 내 객체의 class와 bounding box를 예측한다.

모델	구조	입력 형태	출력	대표 task	핵심 특징
BERT	Encoder-only	텍스트 token	문장/Token 표현, 분류 결과	문장 분류, 감정 분석	양방향 문맥 이해
GPT-2	Decoder-only	텍스트 prompt	다음 token sequence	텍스트 생성	causal mask로 미래 token 차단
ViT	Encoder-only	이미지 patch token	이미지 class	이미지 분류	이미지를 patch sequence로 처리
DETR	Encoder-Decoder	이미지	class + bounding box	객체 검출	이미지 내 객체 위치와 종류 예측

인화

얼렁뚱땅 바보 학부생...

이전 포스트

RNN, LSTM, and GRU

다음 포스트