GPT 구조: Decoder-only의 힘

학습 목표

이 레슨을 완료하면:

• •GPT가 왜 Decoder만 사용하는지 이해한다
• •자기회귀(Autoregressive) 생성 방식의 원리를 설명할 수 있다
• •Next Token Prediction 학습 방법을 이해한다
• •GPT 시리즈의 발전 과정(GPT-1 ~ GPT-4)을 안다
• •Encoder-Decoder 모델과의 차이를 명확히 구분할 수 있다

---

핵심 메시지

"GPT는 '다음에 올 단어가 무엇일까?'를 끊임없이 예측하는 것만으로 인간 수준의 언어 능력을 얻었다." 단순해 보이는 '다음 단어 예측'이 얼마나 강력한 학습 방법인지 알아봅니다.

---

GPT란 무엇인가?

비유: 문장 완성 게임 "오늘 날씨가 ___" 라는 문장을 보면 자연스럽게 "좋다", "춥다" 같은 단어가 떠오릅니다. GPT는 이 "문장 완성 게임"을 수십억 개의 문장으로 연습한 모델입니다. 충분히 많이 연습하면, 단순한 완성을 넘어 글쓰기, 번역, 코딩까지 할 수 있게 됩니다.

---

왜 Decoder만 사용하는가?

이전 레슨에서 Transformer는 Encoder + Decoder 구조라고 배웠습니다. GPT는 Encoder를 완전히 제거하고 Decoder만 사용합니다. 왜일까요?

Encoder-Decoder vs Decoder-only

Encoder-Decoder의 사고방식: 입력: "I love AI" → Encoder가 이해 → Decoder가 번역 출력: "나는 AI를 좋아한다" = "입력을 이해한 뒤, 다른 형태로 변환한다"

GPT(Decoder-only)의 사고방식: 입력: "인공지능의 미래는" 출력: "인공지능의 미래는 매우 밝습니다. 왜냐하면..." = "앞에 있는 텍스트를 보고, 뒤에 올 텍스트를 예측한다" = Cross-Attention이 필요 없다! (참조할 별도 입력이 없으니까)

GPT Decoder 레이어의 구성

GPT의 Decoder 레이어는 원래 Transformer Decoder에서 Cross-Attention을 제거한 것입니다:

GPT 레이어 1개:

입력 토큰 벡터들
  |
  v
[Masked Self-Attention] -- 미래 토큰 차단, 과거만 참조
  |
  v
[Add & Layer Norm]
  |
  v
[Feed-Forward Network]
  |
  v
[Add & Layer Norm]
  |
  v
출력

원래 Transformer Decoder (3단계):
  Masked Self-Attention -> Cross-Attention -> FFN

GPT Decoder (2단계):
  Masked Self-Attention -> FFN
  (Cross-Attention 제거!)

---

자기회귀 생성 (Autoregressive Generation)

비유: 도미노 도미노를 세워놓고 첫 번째를 쓰러뜨리면, 다음 도미노가 쓰러지고, 그 다음 도미노가 쓰러지고... 연쇄적으로 진행됩니다. GPT도 마찬가지로, 하나의 토큰을 생성하면 그것이 다음 토큰 생성의 입력이 됩니다.

생성 과정을 단계별로

최종 결과: "AI는 정말 놀라운 기술입니다"

수학적으로 표현하면

전체 문장의 확률:

$P( ext{"AI는 정말 놀라운 기술입니다"}) = P( ext{"AI는"}) imes P( ext{"정말"} | ext{"AI는"}) imes P( ext{"놀라운"} | ext{"AI는 정말"}) imes P( ext{"기술입니다"} | ext{"AI는 정말 놀라운"})$

이것이 "자기회귀(Autoregressive)"입니다:

• •"자기(Auto)": 자신이 생성한 토큰을
• •"회귀(Regressive)": 다시 입력으로 사용한다

조건부 확률의 연쇄(chain): $P(x_1, x_2, ..., x_n) = P(x_1) imes P(x_2|x_1) imes P(x_3|x_1,x_2) imes ... imes P(x_n|x_1,...,x_{n-1})$

실행해보기: 자기회귀 생성 시뮬레이션

python
실행복사
import numpy as np

np.random.seed(42)

# 간단한 단어 확률 테이블 (실제 GPT는 수만 개 어휘)
next_word_probs = {
    "<start>": {"오늘": 0.3, "내일": 0.2, "AI는": 0.3, "세상은": 0.2},
    "오늘": {"날씨가": 0.4, "점심은": 0.3, "기분이": 0.3},
    "AI는": {"정말": 0.35, "매우": 0.25, "앞으로": 0.2, "이미": 0.2},
    "AI는 정말": {"놀라운": 0.4, "대단한": 0.3, "신기한": 0.3},
    "AI는 정말 놀라운": {"기술입니다": 0.5, "발명입니다": 0.3, "도구입니다": 0.2},
}

def generate(prompt, max_tokens=5):
    tokens = [prompt]
    context = prompt

    print(f"프롬프트: '{prompt}'")
    print("-" * 50)

    for step in range(max_tokens):
        if context not in next_word_probs:
            print(f"  (더 이상 생성할 수 없음)")
            break

        probs = next_word_probs[context]
        words = list(probs.keys())
        probabilities = list(probs.values())

        # 확률에 따라 다음 단어 선택
        chosen = np.random.choice(words, p=probabilities)
        tokens.append(chosen)
        context = " ".join(tokens[0 if prompt == "<start>" else 0:])

        print(f"  Step {step+1}: P({chosen}|{context.rsplit(chosen, 1)[0].strip()}) = {probs[chosen]:.2f}")
        print(f"           현재까지: '{' '.join(tokens)}'")

    print()
    print(f"최종 생성: '{' '.join(tokens)}'")

generate("AI는")

---

Next Token Prediction: GPT의 학습 방법

비유: 빈칸 채우기 시험 (순서대로) 시험지에 "오늘 날씨가 ___" "오늘 날씨가 좋아서 ___" 같은 문제가 수십억 개 있다고 상상해보세요. GPT는 이 시험을 반복해서 풀면서 언어를 배웁니다.

학습 데이터 구성

원본 텍스트: "나는 밥을 먹었다"

GPT 학습 데이터로 변환:

하나의 문장에서 여러 학습 샘플을 동시에 만듭니다! 이것이 효율적인 이유입니다.

손실 함수: Cross-Entropy Loss

각 위치에서 모델이 예측한 확률 분포와 실제 정답을 비교합니다:

$ext{Loss} = -sum log(P( ext{정답 토큰}))$

예시:

• •모델 예측: $P( ext{"밥을"}) = 0.7$, $P( ext{"빵을"}) = 0.2$, $P( ext{"물을"}) = 0.1$
• •정답: "밥을"
• •$ext{Loss} = -log(0.7) = 0.357$

모델이 정답에 높은 확률을 부여할수록 Loss가 줄어듭니다. 학습이 진행되면 정답 확률이 점점 높아집니다.

실행해보기: Next Token Prediction 학습 원리

python
실행복사
import numpy as np

# 간소화된 Next Token Prediction 시뮬레이션
vocab = ["나는", "밥을", "먹었다", "학교에", "갔다", "[EOS]"]
vocab_size = len(vocab)

# 학습 문장: "나는 밥을 먹었다"
sentence = ["나는", "밥을", "먹었다", "[EOS]"]

print("=== Next Token Prediction 학습 ===")
print(f"학습 문장: {' '.join(sentence[:3])}")

np.random.seed(42)

# 각 위치에서의 예측 시뮬레이션
for pos in range(len(sentence) - 1):
    context = sentence[:pos + 1]
    target = sentence[pos + 1]
    target_idx = vocab.index(target)

    # 모델의 예측 (학습 전: 거의 균등 분포)
    logits = np.random.randn(vocab_size) * 0.5
    logits[target_idx] += 1.0  # 약간의 학습이 된 상태
    probs = np.exp(logits) / np.exp(logits).sum()

    loss = -np.log(probs[target_idx])

    print(f"위치 {pos+1}: 입력 = {context}")
    print(f"  정답: '{target}'")
    print(f"  예측 확률 분포:")
    for i, word in enumerate(vocab):
        marker = " <-- 정답" if word == target else ""
        print(f"    P('{word}') = {probs[i]:.3f}{marker}")
    print(f"  Loss = -log({probs[target_idx]:.3f}) = {loss:.3f}")
    print()

print("학습이 반복되면 정답 토큰의 확률이 점점 높아지고, Loss가 줄어듭니다!")

---

GPT 시리즈의 발전

GPT-1부터 GPT-4까지

GPT 아키텍처 스펙 비교

기본 구조는 동일합니다! 달라진 것은 오직 "크기"뿐입니다.

• •레이어를 더 많이 쌓고
• •차원을 더 크게 하고
• •데이터를 더 많이 학습시킨 것

이것이 "Scaling Law"의 핵심: 모델이 크면 클수록, 데이터가 많을수록, 성능이 좋아진다!

GPT-3의 혁명: In-context Learning

GPT-3 이전: 새로운 태스크마다 Fine-tuning 필요 GPT-3 이후: 프롬프트에 예시를 넣는 것만으로 태스크 수행!

Zero-shot (예시 0개):

"다음 문장을 한국어로 번역하세요: Hello world"
-> "안녕하세요 세계"

One-shot (예시 1개):

"영어를 한국어로 번역합니다.
 Hello -> 안녕하세요
 Good morning -> ???"
-> "좋은 아침이에요"

Few-shot (예시 여러 개):

"감성 분석을 합니다.
 맛있다 -> 긍정
 별로다 -> 부정
 최고다 -> 긍정
 싫다 -> ???"
-> "부정"

모델이 충분히 크면 Fine-tuning 없이도 패턴을 파악합니다!

---

GPT의 텍스트 생성 전략

생성 파라미터

Temperature (온도):

• •낮음 (0.1~0.3): 가장 확실한 단어만 선택 → 일관적이지만 단조로움
• •중간 (0.7~0.9): 적당한 다양성 → 일반적인 대화에 적합
• •높음 (1.2~2.0): 다양한 단어 선택 → 창의적이지만 이상한 문장 가능

Top-p (Nucleus Sampling):

• •누적 확률이 p가 될 때까지의 토큰에서만 선택
• •Top-p = 0.9: 상위 90% 확률 범위 내에서 선택

Top-k:

• •확률이 높은 상위 k개 토큰에서만 선택
• •Top-k = 50: 가장 가능성 높은 50개 중 선택

실행해보기: Temperature가 생성에 미치는 영향

python
실행복사
import numpy as np

def apply_temperature(logits, temperature):
    """Temperature를 적용한 확률 분포 생성"""
    scaled = logits / temperature
    exp_scaled = np.exp(scaled - np.max(scaled))  # 안정적 softmax
    return exp_scaled / exp_scaled.sum()

# 모델이 출력한 원래 logits
words = ["좋다", "나쁘다", "괜찮다", "훌륭하다", "별로다"]
logits = np.array([3.0, 0.5, 2.0, 2.5, 0.2])

print("=== Temperature에 따른 확률 분포 변화 ===")
print(f"단어:        {words}")
print(f"원래 logits: {logits}")

for temp in [0.3, 0.7, 1.0, 1.5]:
    probs = apply_temperature(logits, temp)
    bar_chart = ""
    for i, (w, p) in enumerate(zip(words, probs)):
        bar = "#" * int(p * 40)
        bar_chart += f"  {w:6s}: {p:.3f} |{bar}" + chr(10)
    print(f"Temperature = {temp}:")
    print(bar_chart)

print("Temperature가 낮을수록 -> 1등에 집중 (확실한 선택)")
print("Temperature가 높을수록 -> 골고루 분산 (다양한 선택)")

---

BERT와의 비교

핵심 차이를 한 줄로:

BERT: "문장의 빈칸을 양쪽 문맥을 보고 채운다" → 이해에 강하다

GPT: "앞의 내용을 보고 다음을 예측한다" → 생성에 강하다

---

핵심 요약

---

학습 체크리스트

• • GPT가 Encoder 없이 Decoder만 쓰는 이유를 설명할 수 있다
• • 자기회귀 생성 과정을 단계별로 설명할 수 있다
• • Next Token Prediction 학습 방식을 이해한다
• • Temperature, Top-p, Top-k의 역할을 안다
• • GPT-1부터 GPT-4까지의 핵심 발전을 안다
• • BERT와 GPT의 차이를 명확히 구분할 수 있다