강화학습 기초: 보상으로 배우는 에이전트

정답 대신 보상만 보고 시행착오로 배우는 강화학습의 핵심을 넘파이로 직접 구현해요. 슬롯머신 문제로 탐험과 활용의 줄다리기를, 절벽 걷기로 Q-러닝과 SARSA가 왜 서로 다른 길을 배우는지를, 보너스 칸을 끝없이 밟는 에이전트로 보상 해킹을 확인하고, 행동 확률을 직접 밀어 올리는 정책 경사가 LLM의 사람 피드백 강화 학습으로 어떻게 이어지는지 정리해요.

고급강의 4 / 6약 15분

지금까지의 머신러닝은 정답이 있는 데이터로 배웠어요. 사진마다 "고양이", 문의마다 "배송"이라는 정답이 있었죠. 그런데 바둑에서 지금 둔 수가 좋은 수였는지는 대국이 끝나야 알 수 있고, 로봇이 걷는 법에는 한 걸음마다의 정답이 없어요. 이럴 때 쓰는 것이 강화학습이에요. 정답 대신 보상이라는 신호만 받으면서, 시행착오로 더 많은 보상을 받는 행동을 스스로 찾아내요.

강화학습은 2015년 화면만 보고 아타리 게임들을 사람 수준으로 해낸 DQN, 2016년 이세돌 9단을 4대 1로 이긴 알파고로 유명해졌어요. 그리고 사전 학습과 정렬 강의에서 본 것처럼, 지금의 대화형 언어 모델을 다듬는 사람 피드백 강화 학습도 이 원리를 써요.

강화학습의 낱말들

  • 에이전트: 배우고 행동하는 주체예요.
  • 환경: 에이전트가 상호작용하는 세계예요.
  • 상태 ss: 지금 상황이에요. 미로라면 현재 위치예요.
  • 행동 aa: 에이전트가 고를 수 있는 선택이에요.
  • 보상 rr: 행동 뒤에 환경이 주는 점수예요. 좋으면 양수, 나쁘면 음수예요.
  • 정책 π\pi: 상태마다 어떤 행동을 할지 정한 규칙이에요. 배우려는 대상이에요.

목표는 당장의 보상이 아니라 앞으로 받을 보상의 합을 최대로 하는 거예요. 먼 미래의 보상은 조금씩 깎아서 더해요.

Gt=rt+1+γ rt+2+γ2rt+3+⋯(0≤γ≤1)G_t = r_{t+1} + \gamma\, r_{t+2} + \gamma^2 r_{t+3} + \cdots \qquad (0 \le \gamma \le 1)

γ\gamma(할인율)가 0이면 눈앞의 보상만 보고, 1에 가까우면 먼 미래까지 내다봐요. 오늘의 만 원이 1년 뒤의 만 원보다 값진 것과 비슷한 생각이에요.

1. 탐험과 활용: 슬롯머신 문제

가장 단순한 강화학습 문제부터 볼게요. 슬롯머신 10대가 있고, 기계마다 평균 보상이 다르지만 그 값은 몰라요. 한 번 당길 때마다 평균 근처에서 흔들리는 보상이 나와요. 1,000번 당겨서 보상을 최대로 받으려면 어떻게 해야 할까요?

여기에 강화학습의 핵심 고민이 있어요. 지금까지 가장 좋았던 기계만 당기면(활용) 더 좋은 기계를 영영 못 찾을 수 있고, 다른 기계를 시험하면(탐험) 그동안 보상을 손해 봐요. 간단한 해법이 엡실론 탐욕 전략이에요. 대부분은 가장 좋아 보이는 기계를 고르고, ε\varepsilon의 확률로만 아무 기계나 골라요.

import numpy as np

def bandit(eps, runs=500, steps=1000, k=10, seed=0):
    rng = np.random.default_rng(seed)
    true = rng.normal(0, 1, (runs, k))               # 기계마다 진짜 평균 보상 (에이전트는 몰라요)
    best = true.argmax(1)
    Q = np.zeros((runs, k))                          # 지금까지 본 평균 보상
    N = np.zeros((runs, k))                          # 당긴 횟수
    rewards, optimal = np.zeros(steps), np.zeros(steps)
    idx = np.arange(runs)
    for t in range(steps):
        explore = rng.random(runs) < eps
        a = np.where(explore, rng.integers(0, k, runs), Q.argmax(1))
        r = rng.normal(true[idx, a], 1)
        N[idx, a] += 1
        Q[idx, a] += (r - Q[idx, a]) / N[idx, a]     # 평균을 조금씩 갱신
        rewards[t], optimal[t] = r.mean(), (a == best).mean()
    return rewards, optimal

for eps in (0.0, 0.01, 0.1):
    r, o = bandit(eps)
    print(f"ε={eps}: 마지막 200번 평균 보상 {r[-200:].mean():.3f}, 가장 좋은 기계를 고른 비율 {o[-200:].mean():.1%}")
ε=0.0: 마지막 200번 평균 보상 1.026, 가장 좋은 기계를 고른 비율 37.2%
ε=0.01: 마지막 200번 평균 보상 1.307, 가장 좋은 기계를 고른 비율 63.2%
ε=0.1: 마지막 200번 평균 보상 1.363, 가장 좋은 기계를 고른 비율 80.9%

서로 다른 기계 세트 500개로 실험해 평균했어요. 탐험을 전혀 안 하면(ε=0) 처음에 운 좋게 괜찮아 보인 기계에 매달려서, 가장 좋은 기계를 37%의 경우에만 찾아요. 10%만 탐험해도 81%로 올라가요. 1%만 탐험하면 찾는 속도가 느려서 1,000번 안에는 63%에 머물러요. 대신 더 오래 하면 덜 탐험한 만큼 손해가 적어서 결국 따라잡아요. 탐험의 양은 얼마나 오래 할 것인가에 따라 달라져요.

이 문제는 실제 서비스에서도 그대로 나와요. 추천 시스템이 늘 인기 상품만 보여 주면 새 상품의 진짜 인기를 알 수 없어요. 그래서 일부 사용자에게는 새 상품을 일부러 보여 줘요.

2. 상태가 있는 문제: Q-러닝

슬롯머신은 행동이 미래에 영향을 주지 않았어요. 미로에서는 지금의 한 걸음이 다음 위치를 바꾸고, 보상은 한참 뒤에 와요. 그래서 상태 ss에서 행동 aa를 했을 때 앞으로 받을 보상의 합의 기댓값 Q(s,a)Q(s, a)를 배워요. 이 값은 이런 관계를 만족해요(벨먼 방정식).

Q(s,a)=E[ r+γmax⁡a′Q(s′,a′) ]Q(s, a) = \mathbb{E}\left[\, r + \gamma \max_{a'} Q(s', a') \,\right]

"지금 행동의 가치 = 바로 받는 보상 + 다음 상태에서 가장 좋은 행동의 가치". Q-러닝은 한 걸음 움직일 때마다 이 관계에 맞도록 QQ를 조금씩 고쳐요.

Q(s,a)←Q(s,a)+α(r+γmax⁡a′Q(s′,a′)−Q(s,a))Q(s, a) \leftarrow Q(s, a) + \alpha \left( r + \gamma \max_{a'} Q(s', a') - Q(s, a) \right)

괄호 안은 "예상과 실제의 차이"예요. 딥러닝의 경사 하강법처럼, 오차의 방향으로 조금씩 움직여요.

절벽 걷기

강화학습 교과서의 고전 예제로 실험해 볼게요. 4×12 격자에서 왼쪽 아래(출발)부터 오른쪽 아래(목표)까지 가요. 한 걸음마다 -1점이고, 그 사이 맨 아랫줄은 절벽(C)이라 떨어지면 -100점을 받고 출발점으로 돌아가요. 학습 중에는 10%의 확률로 아무 방향이나 가는 엡실론 탐욕으로 움직여요. Q-러닝과 함께, 다음 칸에서 실제로 고른 행동의 가치를 쓰는 변형인 SARSA도 학습시켜 비교할게요.

H, W = 4, 12
START, GOAL = (3, 0), (3, 11)
MOVES = [(-1, 0), (1, 0), (0, -1), (0, 1)]           # 위, 아래, 왼쪽, 오른쪽
ARROWS = "↑↓←→"

def step(s, a):
    r, c = s[0] + MOVES[a][0], s[1] + MOVES[a][1]
    r, c = min(max(r, 0), H - 1), min(max(c, 0), W - 1)   # 벽에 부딪히면 제자리
    if r == 3 and 1 <= c <= 10:
        return START, -100, False                    # 절벽: 큰 벌점, 출발점으로
    return (r, c), -1, (r, c) == GOAL

def choose(Q, s, eps, rng):                          # 엡실론 탐욕
    if rng.random() < eps:
        return int(rng.integers(4))
    q = Q[s]
    return int(rng.choice(np.flatnonzero(q == q.max())))

def learn(method, episodes=500, alpha=0.5, gamma=1.0, eps=0.1, seed=0):
    rng = np.random.default_rng(seed)
    Q = np.zeros((H, W, 4))
    totals = []
    for _ in range(episodes):
        s, total, done = START, 0, False
        a = choose(Q, s, eps, rng)
        while not done:
            s2, r, done = step(s, a)
            a2 = choose(Q, s2, eps, rng)
            if method == "q":                        # Q-러닝: 다음 칸에서 가장 좋은 행동의 가치
                target = r + gamma * Q[s2].max() * (not done)
            else:                                    # SARSA: 다음 칸에서 실제로 고른 행동의 가치
                target = r + gamma * Q[s2][a2] * (not done)
            Q[s][a] += alpha * (target - Q[s][a])
            s, a, total = s2, a2, total + r
        totals.append(total)
    return Q, np.array(totals)

def greedy_path(Q):                                  # 탐험 없이 가장 좋은 행동만 따라가요
    grid = [["." for _ in range(W)] for _ in range(H)]
    for c in range(1, 11):
        grid[3][c] = "C"
    s, seen = START, set()
    while s != GOAL and s not in seen:
        seen.add(s)
        a = int(Q[s].argmax())
        grid[s[0]][s[1]] = ARROWS[a]
        s, _, _ = step(s, a)
    grid[3][11] = "G"
    return "\n".join("".join(row) for row in grid)

for method in ("q", "sarsa"):
    totals = np.mean([learn(method, seed=s)[1] for s in range(30)], axis=0)
    Q, _ = learn(method, seed=0)
    print(f"{method}: 학습 중 마지막 100판 평균 점수 {totals[-100:].mean():.1f}")
    print(greedy_path(Q))
q: 학습 중 마지막 100판 평균 점수 -52.1
............
............
→→→→→→→→→→→↓
↑CCCCCCCCCCG
sarsa: 학습 중 마지막 100판 평균 점수 -26.2
....→→→→→→→↓
.→→→↑......↓
→↑.........↓
↑CCCCCCCCCCG

두 방법이 다른 길을 배웠어요.

  • Q-러닝은 절벽 바로 위를 따라가는 최단 경로(13걸음)를 배웠어요. 다음 칸에서는 늘 가장 좋은 행동을 할 거라고 가정하고 계산하니까요.
  • SARSA는 절벽에서 멀리 떨어진 안전한 길(17걸음)을 배웠어요. 자기가 10%의 확률로 엉뚱한 방향으로 간다는 사실까지 가치에 반영하니까요. 절벽 옆에서 한 번 미끄러지면 -100점이니, 돌아가는 편이 낫다고 판단한 거예요.

학습하는 동안의 점수는 SARSA(-26.2)가 Q-러닝(-52.1)보다 훨씬 좋아요. Q-러닝은 절벽 옆을 걷다가 탐험 때문에 자주 떨어지거든요. 어느 쪽이 나은지는 상황에 달렸어요. 학습이 끝난 뒤 탐험 없이 쓸 거라면 Q-러닝의 길이 최선이고, 현실의 로봇처럼 배우는 동안의 실수도 비싼 경우라면 SARSA처럼 자기 실수까지 고려하는 쪽이 안전해요.

3. 보상을 잘못 설계하면: 보상 해킹

강화학습 에이전트는 보상을 최대로 하는 일을 정말 열심히 해요. 문제는 그게 우리가 원한 일과 다를 수 있다는 거예요. 5×5 격자에서 오른쪽 위의 목표에 도착하면 +10점을 주고, 길을 잘 찾으라고 출발점 옆의 보너스 칸에 +1점을 주기로 했어요. 그런데 이 보너스는 밟을 때마다 줘요.

def step2(s, a, bonus_once, got):
    r, c = s[0] + MOVES[a][0], s[1] + MOVES[a][1]
    r, c = min(max(r, 0), 4), min(max(c, 0), 4)
    if (r, c) == (0, 4):
        return (r, c), 10, True, got                 # 목표: +10, 끝
    if (r, c) == (4, 1) and not (bonus_once and got):
        return (r, c), 1, False, True                # 보너스 칸: +1
    return (r, c), 0, False, got

def learn2(bonus_once, episodes=3000, alpha=0.2, gamma=0.9, eps=0.1, seed=0, max_steps=50):
    rng = np.random.default_rng(seed)
    Q = np.zeros((5, 5, 2, 4))                       # 위치와 "보너스를 받았는지"가 상태
    for _ in range(episodes):
        s, got = (4, 0), False
        for _ in range(max_steps):
            key = (*s, int(got))
            if rng.random() < eps:
                a = int(rng.integers(4))
            else:
                a = int(rng.choice(np.flatnonzero(Q[key] == Q[key].max())))
            s2, r, done, got2 = step2(s, a, bonus_once, got)
            Q[key][a] += alpha * (r + gamma * Q[(*s2, int(got2))].max() * (not done) - Q[key][a])
            s, got = s2, got2
            if done:
                break
    s, got, total = (4, 0), False, 0                 # 다 배운 뒤 탐험 없이 50걸음
    for t in range(1, 51):
        s, r, done, got = step2(s, int(Q[(*s, int(got))].argmax()), bonus_once, got)
        total += r
        if done:
            return f"총점 {total}, {t}걸음 만에 목표 도착"
    return f"총점 {total}, 50걸음 동안 목표에 못 감 (마지막 위치 {s})"

print("보너스를 밟을 때마다:", learn2(bonus_once=False))
print("보너스는 한 번만:", learn2(bonus_once=True))
보너스를 밟을 때마다: 총점 50, 50걸음 동안 목표에 못 감 (마지막 위치 (4, 1))
보너스는 한 번만: 총점 11, 8걸음 만에 목표 도착

에이전트는 보너스 칸으로 가서 아래쪽 벽에 계속 부딪히며 제자리에 머물렀어요. 걸음마다 +1점씩 50점을 모았고, 목표에는 가지 않았어요. 계산해 보면 당연해요. 할인율 0.9에서 매 걸음 1점씩 영원히 받는 가치는 1/(1−0.9)=101 / (1 - 0.9) = 10인데, 8걸음 떨어진 목표의 가치는 10×0.97≈4.810 \times 0.9^{7} \approx 4.8이거든요. 에이전트는 보상이 시킨 일을 정확히 했어요. 우리가 원한 일을 하지 않았을 뿐이에요.

이것이 보상 해킹이에요. 2016년 OpenAI는 보트 경주 게임에서 에이전트가 결승선으로 가는 대신 점수 아이템이 다시 생기는 곳을 빙빙 돌며 점수를 쌓는 사례를 보고했어요. 사전 학습과 정렬 강의의 굿하트 법칙, 그리고 RLHF에서 KL 벌점을 두는 이유가 바로 이거예요. 보상은 진짜 목표에 대해서만 주는 것이 기본이고, 길잡이 보상을 줄 때는 위처럼 반복해서 챙길 수 있는 구멍이 없게 설계해요. 위치의 "좋음"의 차이로만 길잡이를 주면 최적 행동이 바뀌지 않는다는 이론(1999년)도 있어요.

4. 정책을 직접 배우기: 정책 경사

Q-러닝은 행동의 가치를 배우고, 가치가 가장 큰 행동을 골랐어요. 다른 방법은 정책 자체를 매개변수로 두고 바로 배우는 거예요. 행동 확률을 소프트맥스로 만들고, 평균보다 좋은 보상을 받은 행동의 확률을 밀어 올려요.

θ←θ+η (r−b) ∇θlog⁡πθ(a)\theta \leftarrow \theta + \eta\, (r - b)\, \nabla_\theta \log \pi_\theta(a)

bb는 지금까지의 평균 보상(기준선)이에요. 평균보다 좋으면 그 행동의 확률을 올리고, 나쁘면 내려요. 기준선이 없으면 보상이 모두 양수일 때 모든 행동을 올리게 돼서 학습이 흔들려요. 이 방법을 REINFORCE(1992년)라고 불러요. 평균 보상이 1.0, 1.5, 0.5인 슬롯머신 세 대로 해 볼게요.

rng = np.random.default_rng(0)
means = np.array([1.0, 1.5, 0.5])
theta = np.zeros(3)
baseline, lr = 0.0, 0.05
for t in range(1, 1001):
    pi = np.exp(theta) / np.exp(theta).sum()         # 소프트맥스 정책
    a = rng.choice(3, p=pi)
    r = rng.normal(means[a], 1)
    grad = -pi
    grad[a] += 1                                     # log π(a)의 기울기: (고른 행동) - (확률)
    theta += lr * (r - baseline) * grad
    baseline += 0.05 * (r - baseline)                # 기준선은 최근 보상의 평균
    if t in (1, 100, 300, 1000):
        print(t, (np.exp(theta) / np.exp(theta).sum()).round(3))
1 [0.326 0.349 0.326]
100 [0.431 0.446 0.123]
300 [0.118 0.838 0.044]
1000 [0.012 0.98  0.008]

처음에는 셋을 고르게 고르다가, 1,000번 뒤에는 가장 좋은 둘째 기계를 98% 확률로 골라요. log⁡π\log \pi의 기울기가 (고른 행동) 빼기 (확률)이 되는 건, 정보 이론 강의에서 본 소프트맥스와 교차 엔트로피의 기울기 "예측 빼기 정답"과 같은 모양이에요.

언어 모델로 이어지기

이 식이 그대로 LLM의 강화 학습이 돼요. 언어 모델은 토큰을 고르는 정책이에요.

  1. 프롬프트에 대해 답을 생성해요(행동을 샘플링).
  2. 보상 모델이 답에 점수를 매겨요(보상).
  3. 평균보다 좋은 답을 이루는 토큰들의 log⁡\log 확률을 밀어 올려요(정책 경사).
  4. 원래 모델에서 너무 멀어지지 않게 KL 벌점을 더해요(보상 해킹 방지).

실제로는 한 번에 너무 크게 바뀌지 않도록 갱신 폭을 제한하는 PPO 같은 방법을 써요. 최근의 추론 모델들은 보상 모델 대신 정답을 확인할 수 있는 문제(수학 답, 코드 테스트)의 성공 여부를 보상으로 써서, 보상 해킹의 여지를 줄였어요.

깊은 강화학습과 현실

  • 신경망으로 가치 배우기: 상태가 화면 픽셀처럼 엄청나게 많으면 표로 QQ를 저장할 수 없어서 신경망으로 근사해요. 2015년의 DQN이 이렇게 아타리 게임 수십 개를 화면만 보고 배웠어요.
  • 스스로 두며 배우기: 알파고의 후속인 알파제로(2017년)는 사람의 기보 없이 자기 자신과 대국하며 바둑, 체스, 장기를 모두 익혔어요.
  • 어려운 점: 수백만 번의 시행착오가 필요해서(표본 효율이 낮아요) 현실보다 시뮬레이션에서 주로 배우고, 시뮬레이션과 현실의 차이가 또 문제가 돼요. 보상 설계가 어렵고, 학습이 불안정하고, 탐험 중의 실수가 위험할 수 있어요.
  • 실무에서는: 많은 문제는 강화학습보다 지도 학습이 더 간단하고 잘 돼요. 강화학습이 실무에서 많이 쓰이는 곳은 추천과 광고의 탐험(슬롯머신 문제), 그리고 LLM의 정렬과 추론 학습이에요.

실습

  1. 슬롯머신 실험을 5,000번으로 늘려 ε=0.01과 ε=0.1을 비교해 보세요. 결국 어느 쪽이 앞서나요? 이유는?
  2. 절벽 걷기에서 학습할 때의 ε를 0.01로 줄이면 SARSA가 배우는 길은 어떻게 바뀌나요?
  3. 절벽 걷기의 할인율 gamma를 0.5로 낮추면 무슨 일이 생기나요? 걸음마다 -1점인 보상과 함께 생각해 보세요.
  4. 보상 해킹 예제에서 할인율을 0.99로 올리면, 보너스를 밟을 때마다 주는 설정에서도 목표로 가나요? 계산으로 먼저 예상해 보세요.
  5. 정책 경사에서 기준선(baseline)을 늘 0으로 두면 학습이 어떻게 달라지나요?

자주 하는 실수

  • 탐험 없이 배우기. 처음 괜찮아 보인 선택에 갇혀요.
  • 반복해서 챙길 수 있는 보상 만들기. 에이전트는 반드시 그 구멍을 찾아요.
  • 학습 중의 점수와 학습 뒤의 실력을 혼동하기. 절벽 걷기의 Q-러닝처럼, 학습 중 점수는 나빠도 배운 길은 최선일 수 있어요.
  • 할인율을 아무렇게나 정하기. 할인율에 따라 "얼마나 멀리 내다보는가"가 바뀌어서 배우는 행동 자체가 달라져요.
  • 지도 학습으로 될 문제에 강화학습 쓰기. 정답 데이터가 있다면 대개 지도 학습이 더 간단하고 안정적이에요.

점검 문제

  1. 강화학습이 지도 학습과 다른 점은?
  2. 탐험과 활용의 줄다리기란? 엡실론 탐욕은 이를 어떻게 다루나요?
  3. 벨먼 방정식을 말로 풀어 보세요.
  4. 절벽 걷기에서 SARSA가 Q-러닝보다 먼 길을 배운 이유는?
  5. 보상 해킹 예제에서 에이전트가 목표 대신 보너스 칸에 머문 이유를 계산으로 설명해 보세요.
  6. 정책 경사에서 기준선을 빼는 이유는?
  7. LLM의 사람 피드백 강화 학습에서 정책, 행동, 보상은 각각 무엇인가요?

정답

  1. 정답 대신 보상만 주어지고, 그 보상이 행동 뒤에 늦게 올 수 있으며, 에이전트의 행동이 다음에 볼 데이터를 바꿔요.
  2. 지금 가장 좋아 보이는 선택을 할지(활용), 더 좋은 선택을 찾기 위해 다른 것을 시험할지(탐험)의 갈등이에요. 엡실론 탐욕은 대부분 활용하고 ε\varepsilon의 확률로만 탐험해요.
  3. 어떤 상태에서 어떤 행동의 가치는, 바로 받는 보상에 다음 상태에서 고를 수 있는 가장 좋은 행동의 가치를 할인해서 더한 것의 기댓값이에요.
  4. SARSA는 다음 칸에서 실제로 고를 행동(10%는 엉뚱한 방향)의 가치로 배워서, 절벽 옆에서 미끄러질 위험까지 반영했기 때문이에요.
  5. 매 걸음 1점씩 영원히 받는 가치는 1/(1−0.9)=101 / (1 - 0.9) = 10이고, 멀리 있는 목표의 10점은 할인되어 약 4.8이 돼요. 보너스에 머무는 쪽의 가치가 더 커요.
  6. 보상이 평균보다 좋은지 나쁜지에 따라 확률을 올리거나 내리게 해서, 갱신의 흔들림(분산)을 줄이기 위해서예요.
  7. 정책은 언어 모델, 행동은 생성한 답(토큰들), 보상은 보상 모델의 점수(와 KL 벌점)예요.

다음 강의

모델을 학습시키는 것만큼이나 빠르고 싸게 돌리는 것도 중요해요. 다음 강의에서는 모델의 숫자를 줄여 메모리와 속도를 아끼는 양자화, 여러 요청을 묶어 처리하는 배치, 계산을 다시 하지 않게 저장해 두는 캐시까지 추론 최적화를 직접 재 봐요.