[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

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)

각 헤드의 역할:

수식:

[
\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

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 번역

결론:

• 학습 시간: 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, ...

성능:

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 진화:

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️⃣ 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)

6. Transformer의 한계와 미래

6-1. 현재 한계

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의 위대함

앞으로의 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로 수렴, 하지만 구조 개선 계속

외부 참고 자료

Transformer를 더 깊게 배우고 싶다면:

• arXiv – Attention is All You Need – 원본 논문 (2017)
• WikiDocs – Transformer – 한글 완벽 설명
• TensorFlow – Transformer Tutorial – 공식 코드
• YouTube – 3Blue1Brown Attention – 시각적 설명
• HuggingFace – Transformers Library – 구현 라이브러리

축사: AI 101 시리즈 완주

축하합니다! 🎉

14주 간의 여정에서 배운 것:

1️⃣ 기초 이론: 퍼셉트론부터 Transformer까지
2️⃣ 실전 코드: 50개 이상의 Python/TensorFlow 구현
3️⃣ 최신 기술: ChatGPT, BERT, GPT-4의 작동 원리
4️⃣ 성능 비교: 각 모델의 정확도, 속도, 메모리 분석
5️⃣ 실제 응용: 이미지 인식부터 기계 번역까지

이제 여러분은:

• ✅ AI 모델을 이해할 수 있습니다
• ✅ 프로젝트를 설계할 수 있습니다
• ✅ 새로운 기술을 학습할 수 있습니다
• ✅ AI 직무 면접을 준비할 수 있습니다

같이보기

• GPT – 창의적인 글을 쓰는 AI
• BERT vs GPT – 두 거인의 차이점
• BERT – 양방향으로 언어를 이해하는 AI
• 자연어 처리(NLP) – AI와 대화하기
• ChatGPT 10배 활용법 – Prompt Engineering 완벽 마스터 가이드
• 소형 AI 모델 혁명: SLM과 온디바이스 AI가 바꾸는 미래 – 클라우드 없이 스마트폰에서 GPT급 AI를!