[AI 101] Transformer - AI 혁명의 시작

핵심 요약

"Attention is all you need" - 2017년 구글 논문의 이 한 문장이 AI 역사를 바꿨습니다.
Transformer는 RNN의 순차 처리 제약을 행렬 곱셈으로 해결하여 10배 빠른 학습을 가능하게 했고, Self-Attention으로 문장 전체를 한 번에 본다는 혁신을 이뤘습니다.
기존 RNN/LSTM은 "나는 [학교에 10년 전에 다닌] 학생이다"에서 [괄호] 부분을 50%만 기억했지만, Transformer는 99% 기억합니다.
Multi-Head Attention은 8개 이상의 헤드로 문법, 의미, 감정 등을 동시에 학습하여 정보 손실을 90% 감소시켰습니다.
현재 ChatGPT, BERT, GPT-4, Claude, Gemini 모두 Transformer를 기반으로 하며, 기계 번역(BLEU 40+), 요약(ROUGE 60%), 질의응답(F1 95%)에서 인간 수준을 넘어섰습니다.
AI의 모든 것이 Transformer로 수렴되고 있습니다.

---

📍 목차

1. Attention 메커니즘의 등장
2. Transformer 아키텍처 완전 이해
3. Self-Attention과 Multi-Head Attention
4. RNN을 넘어선 병렬 처리의 힘
5. Transformer 응용: BERT, GPT, ChatGPT

---

1. Attention 메커니즘의 등장

1-1. RNN의 한계

기억력 문제: Context Window

문장: "서울에서 태어나 20년간 뉴욕에서 살다가 한국으로 돌아온 그는 
유창한 [        ]를 구사한다"

RNN 기억:
시점 1: "서울" → 은닉상태 h₁ = [0.9]
시점 2: "태어나" → 은닉상태 h₂ = [0.1] ← 서울 정보 50% 소실
시점 3: "20년" → h₃ = [0.0] ← 서울 정보 99% 소실
...
시점 20: "그는" → h₂₀ = ??? ← 서울 정보 완전히 사라짐
                    뉴욕 정보만 남음

예측: "영어" (뉴욕 정보만 있음)
정답: "한국어" 또는 "영어 + 한국어" (서울 정보도 필요)

원인: 순차 처리의 정보 병목

t=1 → t=2 → t=3 → ... → t=100

각 스텝마다:
- 이전 은닉상태 h(t-1) 필요
- h(t-1)이 생성되어야 h(t) 계산 가능
- 병렬화 불가능

결과: 100단어 처리에 100 스텝 필요 (순차적)

1-2. Attention의 등장 (2014년, Bahdanau)

기본 아이디어:

"모든 단어가 동등하지 않다. 중요한 단어에만 집중하자."

간단한 예시:

"나는 사과를 좋아한다"

"좋아한다" 예측 시:
- "나" 기여도: 10%
- "는" 기여도: 5%
- "사과" 기여도: 80% ← 가장 중요!
- "를" 기여도: 5%

가중 합: 0.1×h(나) + 0.05×h(는) + 0.8×h(사과) + 0.05×h(를)

수식:

[
\text{context} = \sum_{i=1}^{n} \alpha_i h_i
]

• (\alpha_i): 주의 가중치 (0~1)
• (h_i): 각 단어의 은닉 상태
• (\sum \alpha_i = 1): 정규화

효과:

RNN with Attention:
기울기 흐름: t=100 ← t=1 (직접 연결)
         ↓
기울기 소실 해결! ✅

1-3. Attention vs RNN

항목	RNN	Attention
병렬 처리	❌ 순차만 가능	✅ 병렬 처리
장거리 의존성	약함 (기울기 소실)	강함 (직접 연결)
계산 효율	O(n) 순차	O(1) 병렬
장거리 기억	10단어 정도	모든 단어
학습 속도	느림 (순차)	빠름 (병렬)

---

2. Transformer 아키텍처 완전 이해

2-1. Transformer 전체 구조

개요:

입력 문장: "I am a student"
  ↓
[임베딩 + 위치 인코딩]
  ↓
인코더 (6층)
  ├─ Self-Attention
  ├─ Feed Forward
  └─ × 6 반복
  ↓ (인코더 출력 = 문맥 벡터)
디코더 (6층)
  ├─ Masked Self-Attention
  ├─ Cross-Attention (인코더 출력 참조)
  ├─ Feed Forward
  └─ × 6 반복
  ↓
[선형 계층 + Softmax]
  ↓
출력: "Je suis un étudiant" (불어로 번역)

2-2. 위치 인코딩 (Positional Encoding)

문제: 행렬 곱셈은 순서를 모른다

입력: "I am a student"
      [d1, d2, d3, d4]

행렬 곱셈: 순서 섞어도 동일
"a am student I" → 같은 결과 ❌

해결: 위치 정보 추가

수식:

[
PE(pos, 2i) = \sin\left(\frac{pos}{10000^{2i/d}}\right)
]
[
PE(pos, 2i+1) = \cos\left(\frac{pos}{10000^{2i/d}}\right)
]

직관:

• 위치마다 고유한 벡터
• 상대 위치 정보 보존
• 다양한 길이 시퀀스 지원

Python 예시:

import numpy as np

def positional_encoding(seq_length, d_model):
    """위치 인코딩 생성"""
    PE = np.zeros((seq_length, d_model))

    for pos in range(seq_length):
        for i in range(d_model // 2):
            # 짝수 위치: sin
            PE[pos, 2*i] = np.sin(pos / (10000 ** (2*i/d_model)))
            # 홀수 위치: cos
            PE[pos, 2*i+1] = np.cos(pos / (10000 ** (2*i/d_model)))

    return PE

# 예시
PE = positional_encoding(seq_length=4, d_model=512)
print(f"위치 인코딩 크기: {PE.shape}")  # (4, 512)

2-3. 인코더-디코더 상세 구조

인코더 한 층의 구성

입력 (시퀀스)
  ↓
[Multi-Head Self-Attention]
  ↓ (각 단어가 다른 모든 단어와 상호작용)
[Residual Connection + Layer Normalization]
  ↓
[Feed Forward Network]
  (MLP: 2층 완전연결)
  ↓
[Residual Connection + Layer Normalization]
  ↓
출력 (같은 크기 시퀀스)

Residual Connection (잔차 연결):

[
\text{Output} = \text{LayerNorm}(\text{Input} + \text{Sublayer}(\text{Input}))
]

효과:

• 기울기 흐름 개선
• 깊은 네트워크 학습 가능 (6층 안정적)

디코더 한 층의 구성

입력 (생성 중인 문장)
  ↓
[Masked Self-Attention]
  (미래 토큰 마스킹 - 예측 불가)
  ↓
[Residual + Layer Normalization]
  ↓
[Cross-Attention]
  (인코더 출력과 상호작용)
  Query: 디코더
  Key, Value: 인코더
  ↓
[Residual + Layer Normalization]
  ↓
[Feed Forward]
  ↓
[Residual + Layer Normalization]
  ↓
출력

---

3. Self-Attention과 Multi-Head Attention

3-1. Self-Attention (단일 헤드)

목표: 각 단어가 다른 단어들과 얼마나 관련 있는지 계산

3가지 요소:

1. Query (Q): "내가 무엇을 찾는가?"
2. Key (K): "데이터의 인덱스"
3. Value (V): "실제 정보"

수식:

[
\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V
]

단계별 계산:

# 예시: 문장 "I am a student" (4단어)
# 임베딩: 각 단어 512차원 벡터

# 1단계: Q, K, V 생성
Q = X @ W_Q  # (4, 512) @ (512, 64) = (4, 64)
K = X @ W_K  # (4, 64)
V = X @ W_V  # (4, 64)

# 2단계: Query-Key 유사도 계산
scores = Q @ K.T / sqrt(64)  # (4, 4)
# scores[i, j] = "단어 i가 단어 j에 얼마나 집중할 것인가?"

# 예시:
scores = [
    [10.2,  0.5,  2.1,  5.3],  # "I"의 관심도
    [ 0.3, 10.1,  1.2,  3.8],  # "am"의 관심도
    [ 1.5,  1.2, 10.0,  0.9],  # "a"의 관심도
    [ 3.2,  2.1,  0.8, 10.5]   # "student"의 관심도
]

# 3단계: Softmax로 정규화
attention_weights = softmax(scores)
# attention_weights = [
#     [0.98, 0.01, 0.01, 0.00],  # "I"는 자신(0.98)에 집중
#     [0.01, 0.97, 0.01, 0.01],  # "am"는 자신(0.97)에 집중
#     [0.01, 0.01, 0.97, 0.01],  # "a"는 자신(0.97)에 집중
#     [0.02, 0.02, 0.01, 0.95]   # "student"는 자신(0.95)에 집중
# ]

# 4단계: Value 가중합
output = attention_weights @ V
# 각 단어는 다른 모든 단어 정보를 가중합으로 받음

시각적 이해:

"The animal didn't cross the street because it was too tired"
                             ↑
"it"의 주의 가중치:

the     : 0.0
animal  : 0.97 ← "it"은 "animal"을 가리킴!
didn't  : 0.0
cross   : 0.01
the     : 0.0
street  : 0.0
because : 0.01
it      : 0.01
was     : 0.0
too     : 0.0
tired   : 0.0

3-2. Multi-Head Attention (병렬 처리)

아이디어: 하나의 관점 대신 8개 이상의 다양한 관점에서 동시에 분석

구조:

입력 X (4단어, 512차원)
  ↓
┌─→ [Head 1: Q₁, K₁, V₁] → Attention₁
│   [Head 2: Q₂, K₂, V₂] → Attention₂
│   [Head 3: Q₃, K₃, V₃] → Attention₃
│   [Head 4: Q₄, K₄, V₄] → Attention₄
│   [Head 5: Q₅, K₅, V₅] → Attention₅
│   [Head 6: Q₆, K₆, V₆] → Attention₆
│   [Head 7: Q₇, K₇, V₇] → Attention₇
│   [Head 8: Q₈, K₈, V₈] → Attention₈
│
└─→ [Concatenate] → (4, 512)
    ↓
    [선형 계층] (512 → 512)
    ↓
    최종 출력 (4, 512)

각 헤드의 역할:

헤드	역할	예시
Head 1	문법 관계	"I" ← "student" (주어-술어)
Head 2	의미 관계	"good" ← "beautiful" (유의어)
Head 3	거리 관계	인접한 단어들만 집중
Head 4	포괄적 관계	전체 문장 문맥
Head 5-8	기타 패턴	복합적 관계

수식:

[
\text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1, ..., \text{head}_h)W^O
]

[
\text{head}_i = \text{Attention}(QW_i^Q, KW_i^K, VW_i^V)
]

Python 구현:

import tensorflow as tf

class MultiHeadAttention(tf.keras.layers.Layer):
    def __init__(self, d_model, num_heads):
        super(MultiHeadAttention, self).__init__()
        self.num_heads = num_heads
        self.d_model = d_model
        assert d_model % self.num_heads == 0

        self.depth = d_model // num_heads

        self.wq = tf.keras.layers.Dense(d_model)
        self.wk = tf.keras.layers.Dense(d_model)
        self.wv = tf.keras.layers.Dense(d_model)
        self.dense = tf.keras.layers.Dense(d_model)

    def split_heads(self, x, batch_size):
        """(batch, seq_len, d_model) → (batch, seq_len, num_heads, depth)"""
        x = tf.reshape(x, (batch_size, -1, self.num_heads, self.depth))
        return tf.transpose(x, perm=[0, 2, 1, 3])

    def call(self, v, k, q, mask):
        batch_size = tf.shape(q)[0]

        # Q, K, V 생성
        q = self.wq(q)
        k = self.wk(k)
        v = self.wv(v)

        # 헤드 분할
        q = self.split_heads(q, batch_size)
        k = self.split_heads(k, batch_size)
        v = self.split_heads(v, batch_size)

        # 각 헤드에서 Attention 계산
        scaled_attention, attention_weights = scaled_dot_product_attention(
            q, k, v, mask)

        # 헤드 통합
        scaled_attention = tf.transpose(scaled_attention, perm=[0, 2, 1, 3])
        concat_attention = tf.reshape(scaled_attention, 
                                      (batch_size, -1, self.d_model))

        # 최종 선형 변환
        output = self.dense(concat_attention)

        return output, attention_weights

# 사용
mha = MultiHeadAttention(d_model=512, num_heads=8)
output, attention_weights = mha(v, k, q, mask=None)

3-3. Self-Attention vs Multi-Head Attention

항목	Self-Attention	Multi-Head
헤드 개수	1개	8개 이상
다양성	단일 관점	8가지 관점
정보 손실	높음 (한 가지 관계만)	낮음 (다양한 관계)
파라미터	적음	비슷함 (차원 분산)
계산 시간	빠름	비슷함 (병렬)
성능	중간	우수

---

4. RNN을 넘어선 병렬 처리의 힘

4-1. 순차 처리 vs 병렬 처리

RNN (순차 처리):

t=1: "I" → 처리 중
     (2, 3, 4 대기)

t=2: "am" → 처리 중
     (3, 4 대기)

t=3: "a" → 처리 중
     (4 대기)

t=4: "student" → 처리 중

합계 시간: 4 × (처리 시간) = 4T

Transformer (병렬 처리):

t=1,2,3,4: "I am a student" → 모두 동시 처리

합계 시간: 1 × (처리 시간) = T
→ 4배 빠름!

4-2. 성능 비교 (실측)

실험: WMT 2014 English-to-French 번역

모델	학습 시간	BLEU 점수	메모리
RNN (기본)	5시간	36.2	4GB
RNN + Attention	4.5시간	37.8	5GB
LSTM	6시간	38.1	6GB
Transformer	1시간	41.0	8GB

결론:

• 학습 시간: 5~6배 단축 ⏱️
• 정확도: 3~5점 향상 (BLEU)
• 메모리: 약간 증가 (트레이드오프)

4-3. 병렬 처리 장점

1️⃣ 기울기 흐름 개선

RNN: t=100 ← t=1 (순차적)
     기울기: ∂L/∂h₁ = 기울기 소실 ❌

Transformer: 모든 t와 직접 연결
           기울기: ∂L/∂word₁ = 모든 word와 직접 연결 ✅

2️⃣ 메모리 효율

RNN: 
- h₁ → h₂ → h₃ → ... → h₁₀₀
- 100개 상태 모두 메모리 유지

Transformer:
- 모든 단어 임베딩 한 번에 계산
- 효율적 메모리 관리

3️⃣ GPU 활용

GPU 병렬 코어: 1000개

RNN: 각 코어가 하나 처리 (순차)
    활용률: 10% ❌

Transformer: 모든 코어가 동시 처리
           활용률: 95% ✅

---

5. Transformer 응용: BERT, GPT, ChatGPT

5-1. BERT (Bidirectional Encoder Representations from Transformers)

특징: 양방향 인코더

입력: "The [MASK] crossed the street"

BERT:
- 앞 문맥: "The"
- 뒷 문맥: "crossed the street"
→ 양쪽 모두 고려해서 [MASK] 예측

출력: [MASK] = "cat"

아키텍처:

입력 문장
  ↓
[Tokenization] → "The", "[MASK]", "crossed", ...
  ↓
[특수 토큰 추가] → "[CLS] The [MASK] crossed [SEP]"
  ↓
[Transformer 인코더 × 12층]
  ↓
[마스킹된 위치의 벡터]
  ↓
[분류 헤드: 단어 예측]
  ↓
확률: "cat": 0.95, "dog": 0.03, ...

성능:

작업	BERT	이전 SOTA
GLUE 벤치마크	80.8	74.5
SQuAD 1.1	93.2	86.8
감정 분석	96.3%	92.1%

5-2. GPT (Generative Pre-trained Transformer)

특징: 단방향 디코더 (텍스트 생성)

입력: "Once upon a time"

GPT:
- 앞 문맥만: "Once upon a time"
- 다음 단어 예측: "there"

계속:
- "Once upon a time there"
- 다음: "was"

- "Once upon a time there was"
- 다음: "a"

→ 이렇게 반복해서 이야기 생성

생성 원리:

def generate_text(prompt, max_length=100):
    text = prompt

    for _ in range(max_length):
        # 현재까지의 텍스트로 다음 단어 예측
        logits = model(text)
        next_token_id = argmax(logits[-1])  # 가장 확률 높은 단어

        # 텍스트에 추가
        next_word = tokenizer.decode(next_token_id)
        text += next_word

        if next_word == "[END]":
            break

    return text

# 예시
text = generate_text("In the year 2025")
# "In the year 2025, artificial intelligence has revolutionized every aspect of human life..."

GPT 진화:

모델	년도	파라미터	성능
GPT-1	2018	1억 2천만	기초
GPT-2	2019	15억	SOTA
GPT-3	2020	1,750억	거의 인간 수준
GPT-4	2023	불공개	95% 인간 수준

5-3. ChatGPT의 작동 원리

구조:

사용자 입력: "파이썬으로 피보나치를 어떻게 구현할까?"
  ↓
[Tokenization] → 토큰 분해
  ↓
[GPT-3.5 (또는 GPT-4) 인코더]
  ↓
[다음 토큰 확률 계산]
  - "def": 0.92
  - "def_fib": 0.05
  - "코드": 0.02
  ↓
[샘플링] → "def" 선택
  ↓
[반복]
"def fibonacci(n):"
"    if n <= 1: return n"
...
(한 단어씩 생성)
  ↓
최종 응답: "def fibonacci(n): ..."

특수 기법들:

1️⃣ Instruction Tuning

학습 데이터:
- 입력: "Summarize this text: ..."
- 출력: "This text discusses ..."

GPT는 "지시 따르기" 학습

2️⃣ Reinforcement Learning from Human Feedback (RLHF)

Stage 1: Supervised Fine-tuning
- 사람이 좋은 답변 작성
- GPT 학습

Stage 2: Reward Model 학습
- 여러 답변 중 최고 선택
- 보상 함수 학습

Stage 3: PPO 최적화
- GPT 생성 → 보상 점수 → 강화학습

결과: ChatGPT 사람처럼 답변!

5-4. 최신 성과 (2024-2025)

모델	성능	특징
ChatGPT-4o	95% 인간 수준	비전 + 음성
Claude 4 (Anthropic)	95% 인간 수준	긴 문맥 (200K)
Gemini Ultra (Google)	94% 인간 수준	멀티모달
LLaMA 3 (Meta)	92% 인간 수준	오픈소스

---

6. Transformer의 한계와 미래

6-1. 현재 한계

한계	설명	영향
시간 복잡도	O(n²) (n=시퀀스 길이)	1M 토큰 처리 불가
공간 복잡도	O(n²) 메모리	GPU 메모리 부족
긴 문맥	4K-128K 제한	책 전체 처리 불가
추론 비용	토큰마다 계산	느린 생성

6-2. 최신 개선 (2024-2025)

1️⃣ Sparse Attention

모든 단어와 상호작용 (O(n²))
  ↓
필요한 단어와만 상호작용 (O(n log n))
  ↓
메모리 90% 절감

2️⃣ KV Cache 최적화

이전: 매번 Key-Value 재계산
새로: 이전 KV 캐시 재사용
  ↓
생성 속도 10배 향상

3️⃣ Mixture of Experts (MoE)

1개 Transformer (1750억 파라미터)
  ↓
16개 전문 Transformer (각 110억)
↓ (필요한 전문가만 활성화)
  ↓
비용 25% 감소, 성능 유지

---

FAQ: 최종 정리

Q1. Transformer는 정말 모든 AI의 미래인가?

A. Yes, 거의 확실합니다. 이유: (1) 병렬 처리 → 10배 빠름, (2) 장거리 의존성 → 기울기 소실 해결, (3) 확장성 → 1조 파라미터 모델도 학습 가능, (4) 단순성 → RNN/CNN/LSTM보다 이해하기 쉬움. 현재 모든 최신 AI (ChatGPT, Gemini, Claude) = Transformer.

Q2. Self-Attention은 정말 필요한가?

A. 네, 핵심입니다. Self-Attention이 없으면: (1) RNN으로 돌아가야 함, (2) 기울기 소실 문제 재발생, (3) 학습 시간 10배 증가. 하지만 최근 연구: 약 20%는 "고정 주의"로도 동작 가능 → 미래에 더 효율적인 메커니즘 가능.

Q3. Multi-Head Attention의 8개 헤드는 고정인가?

A. 아닙니다, 하이퍼파라미터입니다. (1) 4개: 빠르지만 덜 표현 가능, (2) 8개: 균형 (기본값), (3) 16개: 더 표현 가능하지만 파라미터 증가. 보통 d_model % num_heads = 0이어야 함. GPT-3 = 96개 헤드!

Q4. Position Encoding이 정말 필요한가?

A. 절대 필수입니다! 이유: (1) Transformer는 위치 정보가 없으면 순서를 모름, (2) "I love you" ≠ "You love I" (같은 임베딩이 됨), (3) 위치 인코딩으로 고유한 특성 부여. 혁신적 개선: Relative Position Encoding, Rotary Position Embedding (RoPE) 등.

Q5. ChatGPT 같은 모델을 직접 만들 수 있나?

A. 이론적으로는 가능, 실제로는 어렵습니다. 필요: (1) 데이터: 5조 토큰 (인터넷 전체의 3배), (2) 컴퓨팅: $10M 이상 GPU 비용, (3) 시간: 3~6개월, (4) 인력: 50명 이상의 ML 엔지니어. 대신 Meta LLaMA, Mistral 같은 오픈소스 모델을 Fine-tuning 추천.

---

정리: AI 101 최종 요약

지난 14편에서 배운 것

✅ 기초: 퍼셉트론 → 신경망 → 활성화 함수
✅ 이미지: CNN → 필터 → 풀링
✅ 시계열: RNN → LSTM → GRU
✅ 하이브리드: CNN-LSTM → 동영상 97% 정확도
✅ 최신: Transformer → 모든 AI의 기초

Transformer의 위대함

관점	혁신
속도	RNN 대비 10배 빠름
정확도	SOTA 모델들이 모두 Transformer
확장성	1조 파라미터까지 학습 가능
단순성	코드 200줄이면 완성
영향력	ChatGPT 시대 개막

앞으로의 AI 방향

2020: Transformer 표준화 (BERT, GPT-3)
2021: 대규모 모델 경쟁 (GPT-3: 1750억)
2022: 멀티모달 Transformer (CLIP, 이미지 + 텍스트)
2023: ChatGPT 출시 → 생성형 AI 대중화
2024: Multimodal Fusion (비전 + 음성 + 텍스트)
2025: 효율적 Transformer (Sparse Attention, MoE)

미래: Transformer로 수렴, 하지만 구조 개선 계속