Transformer 어텐션 메커니즘부터 GPT·BERT까지 — 완전 정복
2017년 논문 한 편이 AI의 역사를 바꿨다. "Attention Is All You Need" — 지금 여러분이 쓰는 ChatGPT, Claude, Gemini 모두 이 구조를 기반으로 한다. Transformer가 무엇인지, 어떻게 작동하는지 그림으로 낱낱이 해부한다.
Transformer는 왜
등장했는가
Transformer 이전, 자연어 처리의 주류는 RNN(Recurrent Neural Network)과 그 변형인 LSTM, GRU였다. 이 모델들은 텍스트를 왼쪽에서 오른쪽으로 순서대로 처리했다. 문제는 두 가지였다.
최초 발표
저자 수
(2024 기준)
Transformer 기반 비율
RNN은 긴 문장에서 앞쪽 단어의 정보가 뒤로 전달되는 과정에서 점점 희석된다. "나는 10년 전에 프랑스에서 유학했기 때문에 프랑스어를 잘한다"에서 "프랑스어"와 "프랑스"의 연결을 파악하려면 수십 단계를 거쳐야 했다. Transformer는 모든 토큰이 서로를 한 번에 직접 참조해 이 문제를 근본적으로 해결한다.
Transformer 전체 구조
한눈에 보기
원논문의 Transformer는 인코더(Encoder)와 디코더(Decoder)가 결합된 구조다. 번역 태스크를 위해 설계되었으며, 입력(원문)을 인코더가 이해하고 디코더가 출력(번역문)을 생성한다.
입력을 숫자로 —
임베딩과 위치 인코딩
Transformer는 텍스트를 직접 읽지 못한다. 먼저 각 단어(토큰)를 고차원 벡터(숫자 배열)로 변환해야 한다. 이 과정을 임베딩(Embedding)이라 한다.
왜 위치 인코딩이 필요한가? Transformer는 모든 토큰을 동시에(병렬) 처리하므로, 원래는 단어의 순서를 모른다. 위치 인코딩은 "이 단어가 문장의 몇 번째에 있는지"를 수학적 패턴(사인·코사인 함수)으로 벡터에 주입해 순서 정보를 보존한다.
Transformer의 심장 —
Self-Attention 완전 해부
Self-Attention은 Transformer의 가장 핵심적인 혁신이다. 각 단어가 문장 내 다른 모든 단어와의 관련성을 스스로 계산해, 어디에 "주의(Attention)"를 줄지 결정한다.
핵심 직관: "그 동물은 … 피곤했기 때문이다"에서 "그"가 무엇을 가리키는지 파악하려면, Transformer는 "동물은"과의 어텐션 가중치를 높게 계산해 둘을 연결한다. RNN은 중간 단어들을 모두 거쳐야 했지만, Self-Attention은 한 번에 모든 쌍의 관계를 직접 계산한다.
Multi-Head Attention —
여러 관점에서 동시에 보다
하나의 Self-Attention만 사용하면 한 가지 관점으로만 문맥을 파악한다. Multi-Head Attention은 Q, K, V를 여러 헤드(Head)로 나눠 병렬로 서로 다른 어텐션을 계산하고 합친다. 각 헤드는 서로 다른 언어적 관계(문법, 의미, 지시어 등)를 학습한다.
나머지 블록들 —
FFN, 잔차연결, LayerNorm
Feed-Forward Network (FFN)
Multi-Head Attention 이후 각 토큰 벡터는 독립적인 2층 완전연결 신경망(FFN)을 통과한다. Attention이 토큰 간 관계를 처리한다면, FFN은 각 토큰의 표현을 더 풍부하게 변환하는 역할이다.
잔차 연결(Residual Connection)이 중요한 이유: 96층 깊이의 GPT-3도 안정적으로 학습할 수 있는 것은 잔차 연결 덕분이다. 입력 x를 변환 후 결과에 그대로 더해주면, 최소한 x 자체를 보존할 수 있어 기울기가 역전파 과정에서 소실되지 않는다. ResNet에서 처음 도입된 이 아이디어가 Transformer에도 핵심 역할을 한다.
인코더 vs 디코더 —
무엇이 다른가
| 구분 | 🟢 인코더 (Encoder) | 🔴 디코더 (Decoder) |
|---|---|---|
| 주요 역할 | 입력 문장의 의미를 이해 (표현 추출) | 출력 문장을 순차적으로 생성 |
| Attention 방식 | Bidirectional Self-Attention (전후 모든 토큰 참조) |
Masked Self-Attention (미래 토큰은 가림) + Cross-Attention |
| Cross-Attention | 없음 | 있음 (Encoder 출력의 K, V를 참조) |
| 대표 모델 | BERT, RoBERTa, ELECTRA | GPT 시리즈, LLaMA, Claude |
| 주요 태스크 | 분류, NER, 질의응답, 감성 분석 | 텍스트 생성, 대화, 코드 작성 |
| 인코더+디코더 결합 | T5, BART, 원본 Transformer — 번역, 요약, 질의응답 | |
Masked Self-Attention이란? 디코더가 텍스트를 생성할 때, 아직 생성하지 않은 미래 토큰을 미리 볼 수 없도록 마스킹(masking)한다. 예를 들어 "나는 AI를"까지 생성한 상태에서 다음 단어를 예측할 때, 정답인 "공부"를 미리 보면 안 되기 때문이다. 이렇게 해야 실제 추론 환경(미래 모름)과 학습 환경이 일치한다.
Transformer 기반 모델들 —
GPT, BERT, T5 완전 비교
Transformer가 발표된 후 수많은 파생 아키텍처가 탄생했다. 각각 어떤 부분을 사용하느냐에 따라 특성이 완전히 달라진다.
실전 코드로 구현하는
Transformer 핵심
PyTorch로 Self-Attention의 핵심을 직접 구현해보자. 수십 줄의 코드가 수십억 파라미터 모델의 근간이 된다.
import torch
import torch.nn as nn
import torch.nn.functional as F
import math
# ══════════════════════════════════════════════
# 1. Scaled Dot-Product Attention (핵심 수식)
# ══════════════════════════════════════════════
def scaled_dot_product_attention(Q, K, V, mask=None):
"""
Args:
Q: Query [batch, heads, seq_len, d_k]
K: Key [batch, heads, seq_len, d_k]
V: Value [batch, heads, seq_len, d_v]
mask: 디코더에서 미래 토큰 가리기
"""
d_k = Q.size(-1)
# ① QKᵀ / √d_k — 유사도 점수 계산
scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(d_k)
# ② 마스킹 (디코더 전용): 미래 위치를 -inf로 설정 → softmax 후 0
if mask is not None:
scores = scores.masked_fill(mask == 0, float('-inf'))
# ③ Softmax — 확률 분포로 정규화
attn_weights = F.softmax(scores, dim=-1) # [batch, heads, seq, seq]
# ④ × V — 가중 합산
output = torch.matmul(attn_weights, V) # [batch, heads, seq, d_v]
return output, attn_weights
# ══════════════════════════════════════════════
# 2. Multi-Head Attention
# ══════════════════════════════════════════════
class MultiHeadAttention(nn.Module):
def __init__(self, d_model=512, n_heads=8):
super().__init__()
assert d_model % n_heads == 0
self.d_k = d_model // n_heads # 각 헤드의 차원
self.n_heads = n_heads
# Q, K, V, 출력 프로젝션 (학습 파라미터)
self.W_q = nn.Linear(d_model, d_model)
self.W_k = nn.Linear(d_model, d_model)
self.W_v = nn.Linear(d_model, d_model)
self.W_o = nn.Linear(d_model, d_model)
def split_heads(self, x, batch_size):
# [batch, seq, d_model] → [batch, heads, seq, d_k]
x = x.view(batch_size, -1, self.n_heads, self.d_k)
return x.transpose(1, 2)
def forward(self, x, mask=None):
B = x.size(0)
Q = self.split_heads(self.W_q(x), B) # 각 헤드로 분리
K = self.split_heads(self.W_k(x), B)
V = self.split_heads(self.W_v(x), B)
attn_out, _ = scaled_dot_product_attention(Q, K, V, mask)
# 헤드 재합성: [batch, heads, seq, d_k] → [batch, seq, d_model]
attn_out = attn_out.transpose(1, 2).contiguous()
attn_out = attn_out.view(B, -1, self.n_heads * self.d_k)
return self.W_o(attn_out) # 최종 선형 프로젝션
# ══════════════════════════════════════════════
# 3. Transformer Encoder Block (한 층)
# ══════════════════════════════════════════════
class TransformerEncoderBlock(nn.Module):
def __init__(self, d_model=512, n_heads=8, d_ffn=2048, dropout=0.1):
super().__init__()
self.attn = MultiHeadAttention(d_model, n_heads)
self.ffn = nn.Sequential(
nn.Linear(d_model, d_ffn),
nn.ReLU(),
nn.Linear(d_ffn, d_model),
)
self.norm1 = nn.LayerNorm(d_model)
self.norm2 = nn.LayerNorm(d_model)
self.drop = nn.Dropout(dropout) # 하이퍼파라미터!
def forward(self, x, mask=None):
# 잔차 연결 + LayerNorm (Post-Norm 방식)
x = self.norm1(x + self.drop(self.attn(x, mask))) # ← Add & Norm
x = self.norm2(x + self.drop(self.ffn(x))) # ← Add & Norm
return x
# ══ 사용 예시 ══
d_model, n_heads, seq_len, batch = 512, 8, 64, 32
block = TransformerEncoderBlock(d_model, n_heads)
x = torch.randn(batch, seq_len, d_model) # 임의 입력
out = block(x)
print(out.shape) # torch.Size([32, 64, 512]) — 동일 형태 유지실전 팁: 위 코드는 개념 구현이다. 실제 프로젝트에서는 torch.nn.TransformerEncoderLayer나 HuggingFace의 transformers 라이브러리를 활용하면 된다. 원리를 이해한 후 라이브러리를 쓰는 것이 핵심이다.
Transformer가 바꾼
AI의 모든 것
Transformer의 본질은 "모든 것이 어텐션으로 연결된다"는 아이디어다. 순서를 고집하던 RNN을 버리고, 모든 토큰이 서로를 직접 참조하게 했다. 이 단순한 발상이 NLP를 넘어 이미지(ViT), 음성(Whisper), 단백질 구조(AlphaFold), 동영상(Sora)까지 AI 전 영역을 재편했다.
— "Attention Is All You Need", Vaswani et al., 2017오늘 우리가 살펴본 것들을 정리하면: ① 병렬 처리로 RNN의 한계 극복 → ② Q·K·V 어텐션으로 문맥 포착 → ③ Multi-Head로 다양한 관계 동시 학습 → ④ 잔차 연결로 깊은 모델 안정 학습. 이 네 가지가 Transformer의 전부다.
다음 시리즈에서는 BERT의 사전학습 방식(MLM, NSP)과 GPT의 Autoregressive 생성 원리를 더 깊게 파고든다. 구독과 북마크로 이어지는 내용을 놓치지 말자.
가치 보강: 2026년 5월 23일 기준
이 글은 독자가 바로 적용할 수 있는 기준을 더하기 위해 2026년 5월 23일 기준으로 보강했습니다. 단순 정보 나열보다 실제 예시, 확인 순서, 관련 글 연결을 함께 보는 것이 블로그 글의 가치를 높입니다.
실전 적용 예시
| 상황 | 어떻게 보면 좋은가 |
|---|---|
| 처음 읽을 때 | 글의 결론과 적용 대상을 먼저 확인합니다. |
| 실제로 쓸 때 | 내 상황에 맞는 예시만 골라 적용하고, 숫자나 정책은 원문을 확인합니다. |
| 다음 행동 | 관련 글을 이어 읽어 주제 전체 흐름을 잡습니다. |
읽고 바로 확인할 것
- 내 상황에 적용 가능한 글인지 확인했는가?
- 날짜, 정책, 요금, 게임 정보처럼 바뀌는 내용은 다시 확인했는가?
- 관련 글을 함께 읽어 맥락을 보완했는가?
- 글의 예시를 그대로 복사하지 않고 내 상황에 맞게 바꿨는가?
같이 보면 좋은 글
'AI란 무엇인가 > AI 기본' 카테고리의 다른 글
| Positional Encoding&Layer Normalization (0) | 2026.04.04 |
|---|---|
| Transformer 어텐션 메커니즘 완전 해부 (0) | 2026.04.01 |
| AI 파라미터란 무엇인가 — 종류·역할·차이점 완전 정복 (3) | 2026.03.30 |
| 대형 언어 모델 vs 멀티모달 모델 — 완전 정복 (LLM vs MLM) (0) | 2026.03.30 |
| AI란 무엇인가? 인공지능의 모든 것을 파헤치다 (0) | 2026.03.30 |