콘텐츠로 이동
Search

WorldModels:Tutorial:07-PlanningMPC

lastmod 2026-11-18created 2026-11-172 edits

상상으로 계획하기: MPC 와 CEM은 World Model 튜토리얼의 7장이다. 6장에서 학습한 동역학 모델 안에서 행동열 수백 개를 상상으로 시험하고, 가장 좋은 것의 첫 행동만 실행한 뒤 다시 계획하는 모델 예측 제어(MPC)로 진자를 세운다. 정책 신경망과 보상 학습 없이 모델과 탐색(랜덤 슈팅, CEM)만 쓰며, 후반부는 모델이 모르는 곳을 드러내게 하는 확률적 앙상블과 PETS 를 다룬다.

계획: 행동열 최적화

지금 관측이 \(o_t\) 일 때 앞으로 \(H\) 스텝 동안의 행동열 \(a_{t:t+H-1} = (a_t, a_{t+1}, \dots, a_{t+H-1})\) 을 정하면, World Model \(f_\theta\) 로 그 결과를 실행 없이 상상할 수 있다.

\(\hat o_t = o_t, \qquad \hat o_{t+k+1} = f_\theta(\hat o_{t+k},\ a_{t+k}) \quad (k = 0, 1, \dots, H-1)\)

상상한 궤적의 보상 합이 그 행동열의 점수이다.

\(J(a_{t:t+H-1}) = \sum_{k=0}^{H-1} r\big(\hat o_{t+k},\ a_{t+k}\big)\)

계획(planning)은 이 점수를 가장 크게 하는 행동열을 찾는 최적화 문제이다.

\(a^*_{t:t+H-1} = \operatorname*{arg\,max}_{a_{t:t+H-1}\ \in\ [-2,\,2]^H}\ J(a_{t:t+H-1})\)

  • \([-2, 2]^H\) 는 각 성분이 \(-2\) 와 \(2\) 사이인 길이 \(H\) 의 벡터 전체이다(진자의 토크 범위).
  • 보상 \(r\) 은 알고 있는 함수 pendulum_reward 를 쓴다. 모델이 대신하는 것은 다음 관측뿐이다.
  • 5장의 강화학습은 정책 \(\pi(a \mid s)\) 를 학습해 두고 행동할 때 한 번 계산한다. 계획은 정책을 학습하지 않고 매번 그 자리에서 최적화로 행동을 계산한다. 계산은 무겁지만 보상 함수를 바꾸면 다시 학습하지 않고 새 목표에 맞춰 계획할 수 있다.

전수 탐색이 안 되는 이유

행동을 \(\{-2, -1, 0, 1, 2\}\) 다섯 값으로만 나눠도 \(H = 25\) 의 행동열은 \(5^{25} \approx 3\times10^{17}\) 개이다. 1초에 백만 개씩 시험해도 9천 년이 넘는다. 그래서 일부만 시험하는 방법이 필요하고, 이 장은 미분을 쓰지 않는 표본 기반 방법 두 가지(랜덤 슈팅, CEM)를 쓴다. 구현이 간단하고, 후보 수백 개를 배치로 한꺼번에 계산하기 좋고, 모델이 매끄럽지 않아도(예: 각속도 잘림) 동작한다. 모델을 미분해 기울기로 행동을 고치는 방법은 12장에서 다룬다.

후보 행동열 점수 매기기

두 방법 모두 후보 행동열 \(N\) 개의 점수를 한꺼번에 계산하는 함수를 쓴다.

@torch.no_grad()
def evaluate_sequences(model, obs, actions):
    """후보 행동열 N 개를 모델 속에서 굴려, 각 행동열의 예측 총 보상 J 를 계산한다.

    obs     : (3,)        지금의 진짜 관측 o_t (여기서 상상을 시작한다)
    actions : (N, H, 1)   후보 행동열 N 개, 각각 길이 H
    반환    : (N,)        J = Σ_k r(ô_{t+k}, a_{t+k})
    """
    N, H, _ = actions.shape
    o = obs.expand(N, -1)  # (N, 3): 모든 후보가 같은 곳에서 출발
    total = torch.zeros(N, device=actions.device)
    for k in range(H):
        a = actions[:, k]  # (N, 1)
        total += pendulum_reward(o, a)  # 알려진 보상 함수로 점수를 매긴다
        o, _ = model.predict(o, a)  # 상상 속 다음 관측
    return total
  • obs.expand(N, -1) 는 메모리를 복사하지 않고 관측 하나를 \(N\) 번 복사한 것처럼 보이게 한다.
  • 반복문은 시간 \(k\) 에 대해서만 돈다. 후보는 배치 차원이므로 \(N = 400\) 이어도 신경망 호출은 \(H\) 번이다.

모델 예측 제어 (MPC)

계획으로 얻은 \(H\) 스텝 행동열을 끝까지 실행하지 않는다. 6장에서 보았듯 상상은 길어질수록 틀리기 때문이다. 대신 다음을 매 스텝 되풀이한다.

  1. 지금의 진짜 관측 \(o_t\) 에서 \(H\) 스텝을 계획한다: \(a^*_{t:t+H-1}\).
  2. 그 가운데 첫 행동 \(a^*_t\) 하나만 진짜 환경에서 실행한다.
  3. 새 진짜 관측 \(o_{t+1}\) 을 받아 1번으로 돌아가 처음부터 다시 계획한다.

이것이 모델 예측 제어(model predictive control, MPC)이다. 계획 창이 시간과 함께 한 칸씩 밀려가므로 후퇴 지평(receding horizon) 제어라고도 한다. 1970~80년대 화학 공정 제어에서 널리 쓰이기 시작했고 지금은 로봇·자율주행 제어의 기본 도구이다. 매 스텝 \(H\) 칸짜리 계획을 세우지만 실행하는 것은 첫 칸뿐이고 나머지는 상상만 하고 버린다(원문 그림 7-1). 전조등이 비추는 앞 50m 를 보고 핸들을 조금 꺾고, 1초 뒤 새로 보이는 50m 로 다시 정하는 야간 운전과 같다.

MPC 가 6장의 오차 누적 문제와 맞는 까닭은 두 가지이다.

  • 상상은 짧게: \(H\) 스텝만 상상하므로 오차가 무한히 쌓이기 전에 끊긴다.
  • 되먹임: 매 스텝 진짜 관측에서 다시 시작하므로(닫힌 고리) 지난 계획의 오차가 다음 계획으로 넘어가지 않는다.

대가는 계산량이다. 행동 하나를 고르는 데 모델을 수만 번 호출한다. 큰 모델에서는 이것이 무거워서 12장의 Dreamer 처럼 계획 대신 정책을 상상 속에서 학습하는 방법이 나온다.

코드에서는 run_episode(env, planner) (ch07_mpc.py 의 region run_episode)가 매 스텝 planner(obs) 를 새 관측으로 다시 부른다. 계획기는 계획 전체가 아니라 실행할 첫 행동 하나만 돌려준다.

랜덤 슈팅

가장 단순한 계획기이다.

  1. \([-2, 2]\) 에서 고르게(uniform) 무작위 행동열 \(N\) 개를 뽑는다.
  2. 모델 속에서 각각의 점수 \(J\) 를 계산한다.
  3. 점수가 가장 높은 행동열의 첫 행동을 고른다.

RandomShootingPlanner (region random_shooting, 기본 horizon=25, n_candidates=1000)가 이 절차이다. 신경망 World Model 과 MPC 를 결합한 초기 연구(Nagabandi 외, 2018)도 랜덤 슈팅을 썼다. 하지만 지평이 길어지면 한계에 부딪힌다.

좋은 후보를 뽑을 확률

무작위 행동열 가운데 충분히 좋은 것의 비율이 \(p\) 이고 \(N\) 개를 독립적으로 뽑는다.

\(\begin{align} P(\text{하나도 좋지 않음}) &= (1-p)^N = e^{N\log(1-p)} \\ P(\text{적어도 하나 좋음}) &= 1 - (1-p)^N \approx 1 - e^{-pN} \end{align}\)

근사는 \(p\) 가 작을 때 \(\log(1-p) \approx -p\) 를 쓴 것이다(\(\log(1+x)\) 의 \(x=0\) 에서의 값이 0, 기울기가 1). \(pN\) 은 좋은 후보의 기대 개수이며, 1 정도면 약 63%, 3 이면 약 95% 의 확률로 좋은 후보를 얻는다.

  • 예: \(p = 0.001\), \(N = 1000\) 이면 정확한 값 \(1 - 0.999^{1000} = 0.6323\), 근사 \(1 - e^{-1} = 0.6321\) 이다.
  • 문제는 \(p\) 가 지평 \(H\) 에 따라 지수적으로 작아진다는 점이다. 매 스텝 괜찮은 행동의 비율이 절반이어도 25 스텝 모두 괜찮을 비율은 \(0.5^{25} \approx 3\times10^{-8}\) 이다. 좋은 후보 근처를 집중적으로 뽑는 방법이 필요하다.

교차 엔트로피 방법 (CEM)

교차 엔트로피 방법(cross-entropy method, CEM)은 랜덤 슈팅을 여러 번 되풀이하되 매번 앞에서 잘한 후보들 근처에서 다시 뽑는다(Rubinstein, 1999). 행동열의 각 성분마다 가우시안을 하나씩 둔다.

\(a_{t+k} \sim \mathcal{N}(\mu_k,\ \sigma_k^2), \qquad k = 0, 1, \dots, H-1\)

한 번의 반복은 다음과 같다.

  1. 뽑기: 행동열 \(N\) 개를 뽑는다. \(a^{(i)}_{t+k} = \mu_k + \sigma_k\,\epsilon^{(i)}_k\), \(\epsilon \sim \mathcal{N}(0, 1)\), 그리고 \([-2, 2]\) 로 자른다.
  2. 점수 매기기: 모델 속에서 각 후보의 \(J\) 를 계산한다.
  3. 정예 고르기: 점수 상위 \(K\) 개를 정예(elite)로 고른다.
  4. 다시 맞추기: 정예 \(K\) 개에 가장 잘 맞는 가우시안으로 \(\mu\), \(\sigma\) 를 바꾼다.

이것을 몇 번(여기서는 5번) 되풀이하면 가우시안이 좋은 행동열 쪽으로 옮겨 가며 좁아진다. 마지막 평균 \(\mu_0\) 이 실행할 첫 행동이다.

원문의 2차원 데모(표본 60개, 정예 10개, 높은 봉우리와 낮은 봉우리가 하나씩 있는 점수 함수)에서는 대여섯 번 반복하면 타원(평균 ± 2σ)이 봉우리 위로 좁아지지만, 열 번에 한 번쯤은 낮은 봉우리에 갇힌다. CEM 은 전역 최적을 보장하지 않는 국소 탐색이다.

정예에 다시 맞추기는 최대우도 추정

4번 단계는 2장의 최대우도 추정이다. 한 성분만 보면 정예의 값 \(x_1, \dots, x_K\) 에 대해 로그 가능도를 최대화한다.

\(\begin{align} \ell(\mu, \sigma^2) &= \sum_{i=1}^K \log\mathcal{N}(x_i;\mu,\sigma^2) = \sum_{i=1}^K\left[-\frac12\log(2\pi\sigma^2) - \frac{(x_i - \mu)^2}{2\sigma^2}\right] \\ &= -\frac{K}{2}\log(2\pi) - \frac{K}{2}\log\sigma^2 - \frac{1}{2\sigma^2}\sum_{i=1}^K (x_i-\mu)^2 \end{align}\)

\(\mu\) 로 미분해 0 으로 두면 평균이 나온다.

\(\frac{\partial \ell}{\partial \mu} = \frac{1}{\sigma^2}\sum_{i=1}^K (x_i - \mu) = 0 \ \Rightarrow\ \hat\mu = \frac1K\sum_{i=1}^K x_i\)

\(v = \sigma^2\) 를 하나의 변수로 보고 미분해 0 으로 두면 분산이 나온다.

\(\frac{\partial \ell}{\partial \sigma^2} = -\frac{K}{2\sigma^2} + \frac{1}{2(\sigma^2)^2}\sum_{i=1}^K (x_i-\mu)^2 = 0 \ \Rightarrow\ \hat\sigma^2 = \frac1K\sum_{i=1}^K (x_i - \hat\mu)^2\)

정예의 표본 평균과 표본 분산(나누기 \(K\), 편향된 표본 분산)이 곧 새 가우시안이다. 코드의 elites.mean(dim=0), elites.std(dim=0, unbiased=False) 가 이 두 식이다.

이름의 "교차 엔트로피" 도 여기서 나온다. 각 정예에 확률 \(\frac1K\) 을 준 분포 \(\hat p\) 와 가우시안 \(q\) 사이의 교차 엔트로피(3장, 여기의 \(H(\cdot,\cdot)\) 는 계획 길이가 아니다)는

\(H(\hat p, q) = -\mathbb{E}_{x\sim\hat p}[\log q(x)] = -\frac1K\sum_{i=1}^K \log q(x_i)\)

이므로, 교차 엔트로피 최소화는 정예의 로그 가능도 최대화와 같다. 정예의 분포를 가장 잘 흉내 내는 가우시안을 찾는 것이다.

평활과 웜 스타트

평활(smoothing): 새 값으로 단번에 바꾸지 않고 옛 값을 비율 \(\alpha\) 만큼 섞는다.

\(\mu \leftarrow \alpha\,\mu_{\text{old}} + (1-\alpha)\,\hat\mu, \qquad \sigma \leftarrow \alpha\,\sigma_{\text{old}} + (1-\alpha)\,\hat\sigma\)

  • \(\alpha = 0.1\) 이면 새 값을 90% 믿는다. 예: \(\mu_{\text{old}} = 0\), \(\hat\mu = 1.5\) 이면 \(\mu = 1.35\) 이다.
  • 정예가 우연히 한쪽에 몰려 \(\sigma\) 가 갑자기 0 에 가까워져 더 탐색하지 못하는 일을 막는다.
  • PETS 의 공개 구현은 표준편차가 아니라 분산 \(\sigma^2\) 을 같은 식으로 섞는다. 여기서는 \(\sigma\) 를 섞었고 하는 일은 같다.

웜 스타트(warm start): 바로 전 스텝의 계획 \(\mu_{0:H-1}\) 은 이번 스텝에도 좋은 출발점이다. 첫 행동은 이미 실행했으므로 한 칸 당긴 \((\mu_1, \mu_2, \dots, \mu_{H-1}, 0)\) 을 이번 계획의 처음 평균으로 쓴다. 매번 0 에서 시작할 때보다 적은 반복으로 좋은 계획에 도달한다.

class CEMPlanner:
    """교차 엔트로피 방법(CEM): 가우시안에서 행동열을 뽑고, 정예(elite)에 가우시안을 다시 맞추기를 되풀이한다."""

    def __init__(self, model, horizon=25, n_candidates=400, n_elites=40, n_iters=5,
                 alpha=0.1, init_std=1.0, device="cpu"):
        self.model, self.H, self.N, self.K = model, horizon, n_candidates, n_elites
        self.n_iters, self.alpha, self.init_std, self.device = n_iters, alpha, init_std, device
        self.reset()

    def reset(self):
        # 에피소드가 시작될 때 평균 행동열을 0 으로 (= 아무 정보 없음)
        self.mean = torch.zeros(self.H, 1, device=self.device)

    def evaluate(self, obs, actions):
        # 후보 행동열의 점수. 확률적 모델(ch07_pets.py)은 이 메서드만 바꿔 끼운다.
        return evaluate_sequences(self.model, obs, actions)

    def __call__(self, obs):
        obs = torch.as_tensor(obs, dtype=torch.float32, device=self.device)
        mean = self.mean.clone()  # (H, 1) μ
        std = torch.full_like(mean, self.init_std)  # (H, 1) σ
        for _ in range(self.n_iters):
            # 1) 표본 뽑기: a = μ + σ ⊙ ε,  ε ~ N(0, I). 범위 밖은 잘라낸다.
            eps = torch.randn(self.N, self.H, 1, device=self.device)
            actions = (mean + std * eps).clamp(-MAX_U, MAX_U)  # (N, H, 1)
            # 2) 모델 속에서 점수 매기기
            returns = self.evaluate(obs, actions)  # (N,)
            # 3) 점수 상위 K 개 = 정예
            elites = actions[returns.topk(self.K).indices]  # (K, H, 1)
            # 4) 정예에 가우시안을 최대우도로 맞춘다: 평균 = 표본 평균, 분산 = 표본 분산
            new_mean = elites.mean(dim=0)
            new_std = elites.std(dim=0, unbiased=False)
            # 5) 평활: 한 번에 너무 크게 바뀌지 않게 옛 값을 α 만큼 섞는다
            mean = self.alpha * mean + (1 - self.alpha) * new_mean
            std = self.alpha * std + (1 - self.alpha) * new_std
        # 웜 스타트: 다음 시각의 계획은 이번 계획을 한 칸 당긴 것에서 시작한다
        self.mean = torch.cat([mean[1:], torch.zeros(1, 1, device=self.device)])
        return mean[0].cpu().numpy()  # 첫 행동만 실행한다 (MPC)

웜 스타트로 넘기는 것은 평균뿐이고, 표준편차는 매 스텝 init_std 로 다시 시작한다. evaluate 메서드를 따로 둔 것은 PETS 가 이 부분만 바꿔 끼우기 위해서이다.

하이퍼파라미터

이름

이 장의 값

키우면

줄이면

지평 \(H\)

25 (1.25초)

더 먼 미래를 고려하지만 모델 오차가 쌓이고 계산이 늘어난다

근시안적이 되어 "일단 반대로 흔들기" 같은 행동을 못 찾는다

후보 수 \(N\)

400

더 좋은 행동열을 찾을 확률 증가, 계산 증가

탐색이 거칠어진다

정예 수 \(K\)

40 (10%)

가우시안이 천천히 좁아진다(탐색 많이)

빨리 좁아진다(잘못된 곳에 갇힐 위험)

반복 수

5

더 정밀한 최적화, 계산 증가

덜 정밀하다

평활 \(\alpha\)

0.1

변화가 느려진다

정예에 바로 맞춘다

초기 \(\sigma\)

1.0

처음에 넓게 탐색한다

처음부터 평균 근처만 본다

이 설정에서 행동 하나를 고르는 데 모델을 \(5\times400\times25 = 50{,}000\) 번(배치로는 125번) 호출하고, 200 스텝 에피소드 하나면 천만 번이다. 노트북 CPU 4스레드에서 행동 하나에 약 0.09초, 에피소드 하나에 약 18초가 걸렸다.

진자 세우기: 모델 기반 강화학습 고리

처음에는 데이터가 거의 없으므로 다음 고리를 되풀이한다(원문 그림 7-2).

  1. 데이터 \(\mathcal{D}\): 처음에는 무작위 행동 에피소드 1개.
  2. 모델 학습: 6장의 train_model.
  3. CEM-MPC 로 진짜 환경에서 한 에피소드(200 스텝)를 실행한다.
  4. 새 경험(에피소드 1개 = 200 전이)을 데이터에 더하고 2번으로 돌아간다.

모델로 계획하며 행동하면 무작위 행동으로는 가 보지 못한 곳(예: 위로 선 자세)의 데이터가 쌓이고, 모델이 그곳에서도 정확해진다.

    # 1) 시드 데이터: 무작위 행동 에피소드 몇 개
    env = Pendulum(seed=args.seed)
    data = collect_episodes(env, args.seed_episodes, seed=args.seed)
    print(f"seed data: {args.seed_episodes} random episodes, "
          f"mean return {np.mean([ep['reward'].sum() for ep in data]):.1f}")

    # 2) 되풀이: 모델 학습 → 그 모델로 계획하며 진짜 환경에서 한 에피소드 → 데이터에 더하기
    returns_per_iter = []
    for it in range(1, args.iterations + 1):
        model, loss = fit_model(data, device, seed=args.seed + it, train_steps=train_steps)
        planner = CEMPlanner(model, horizon=args.horizon, device=device)
        episode, ret = run_episode(env, planner)
        data.append(episode)
        returns_per_iter.append(ret)
        print(f"iter {it:2d} | data {len(data):2d} episodes | model loss {loss:.5f} | "
              f"CEM-MPC return {ret:8.1f} | {time.time() - start:5.0f}s")

매 반복마다 모델을 처음부터 다시 학습한다. fit_model 은 데이터 크기와 상관없이 약 3,000 번의 기울기 스텝(배치 256)을 밟도록 에폭 수를 정한다. 이어서 학습하는 것보다 느리지만, 예전 데이터에 맞춰진 가중치가 새 데이터 학습을 방해하지 않아 단순하고 안정적이다. 기본값은 시드 에피소드 1개, 반복 8회이다.

seed data: 1 random episodes, mean return -1071.9
iter  1 | data  2 episodes | model loss 0.00005 | CEM-MPC return   -218.4 |    40s
iter  2 | data  3 episodes | model loss 0.00005 | CEM-MPC return   -114.7 |    70s
iter  3 | data  4 episodes | model loss 0.00007 | CEM-MPC return   -123.9 |   103s
iter  4 | data  5 episodes | model loss 0.00010 | CEM-MPC return   -126.4 |   128s
iter  5 | data  6 episodes | model loss 0.00005 | CEM-MPC return   -122.5 |   164s
iter  6 | data  7 episodes | model loss 0.00014 | CEM-MPC return   -251.5 |   209s
iter  7 | data  8 episodes | model loss 0.00010 | CEM-MPC return   -119.0 |   244s
iter  8 | data  9 episodes | model loss 0.00007 | CEM-MPC return   -241.5 |   291s
  • 무작위 에피소드 하나(200 전이)로 학습한 모델로 첫 MPC 에피소드에서 이미 \(-218\) 을 얻었다. 진자는 상태가 3차원뿐이고 물리가 매끄러워 200 개의 전이로도 흔들어 올리기에 필요한 만큼 정확한 모델이 나온다.
  • 반복마다 리턴이 \(-115\) 와 \(-250\) 사이를 오가는 것은 주로 시작 상태 때문이다. 시작 각도가 바닥에 가까워 한 번 더 흔들어야 하는 에피소드는 \(-250\) 근처, 한 번에 올라가는 에피소드는 \(-115\) 근처가 된다.
  • 그림: 반복에 따른 CEM-MPC 에피소드 리턴과 무작위 정책 평균

세 방법 비교

마지막 데이터(9 에피소드)로 학습한 모델 하나를 두고 세 방법을 같은 10개의 시작 상태에서 비교한 결과이다.

random policy       : mean return  -1202.1 ±  183.2  (episodes: -866, -1248, -1183, -1173, -1397, -1307, -1506, -1296, -1068, -975)
random shooting MPC : mean return   -147.1 ±  106.4  (episodes: -1, -119, -125, -120, -243, -123, -366, -248, -126, -1)
CEM MPC             : mean return   -110.4 ±   66.6  (episodes: -0, -119, -126, -119, -124, -116, -249, -123, -128, -0)

방법

평균 리턴 (10 에피소드)

표준편차

행동 하나당 모델 호출

무작위 정책

\(-1202.1\)

183.2

0

랜덤 슈팅 MPC (\(N=1000\), \(H=25\))

\(-147.1\)

106.4

25,000

CEM MPC (\(N=400\), \(K=40\), 5회, \(H=25\))

\(-110.4\)

66.6

50,000

  • CEM 은 3초 안에, 랜덤 슈팅도 늦어도 4초쯤이면 진자를 세우고 끝까지 유지한다. 무작위 정책은 각도가 계속 돈다.
  • 랜덤 슈팅의 토크는 균형을 잡는 동안에도 매 스텝 \(\pm2\) 사이를 오간다. CEM 은 흔들어 올릴 때만 \(\pm2\) 를 쓰고 균형을 잡을 때는 대체로 \(\pm1\) 안쪽에서 움직인다(잔떨림은 남는다). 좋은 행동열 근처를 집중적으로 다듬었기 때문이다.
  • 리턴이 0 에 가까운 에피소드는 거의 선 자세에서 시작한 경우이다.
  • 5장의 기준(시작 상태 100개)은 무작위 정책 약 \(-1234\), 에너지 식을 알고 손으로 만든 정책 약 \(-183\) 이었다. CEM MPC 의 \(-110\) 은 물리 법칙을 쓰지 않고도 그보다 좋다. 다만 여기는 시작 상태가 10개뿐이고 시드가 달라 엄밀한 비교는 아니다.
  • 그림: 세 방법의 각도와 토크 궤적 10개씩

핵심: 정책 학습 없이 "데이터로 배운 World Model + 그 안에서의 탐색(CEM) + 매 스텝 다시 계획하기(MPC)" 만으로 진자 스윙업을 풀었다. 진짜 환경과의 상호작용은 9 에피소드(1,800 스텝)뿐이었다. 시행착오를 진짜 세상 대신 모델 안에서 하는 것이 World Model 의 가장 직접적인 이득이다.

모델 착취 문제

계획기는 모델이 말하는 점수를 그대로 믿고 그 점수를 최대화하는 행동열을 찾는다. 모델이 어딘가에서 "여기로 가면 보상이 아주 크다" 고 틀리게 예측하면 계획기는 그 틀린 곳을 찾아낸다. 최적화는 오차를 고르게 겪지 않고 자기에게 유리한 쪽으로 틀린 오차를 골라 이용한다. 이것이 모델 착취(model exploitation)이다. 채점 기준의 허점을 찾은 학생이 높은 점수를 받는 상황과 같다.

특히 위험한 곳은 데이터가 없는 곳이다. 그곳의 예측은 아무 제약이 없어서, 계획기가 우연히 낙관적인 예측을 찾으면 실제 실행 결과는 기대와 전혀 다르다. 진자에서는 모델이 매끄럽고 데이터가 고르게 퍼져 크게 문제 되지 않았지만 상태·행동이 많은 문제에서는 자주 일어난다. 대처 방법은 세 가지이다.

  • 고리를 돌기: 착취한 행동을 진짜로 실행하면 그 결과가 데이터에 들어가 모델이 고쳐진다.
  • 지평을 짧게, 자주 다시 계획하기: 틀린 상상이 길게 이어지지 않게 한다(MPC).
  • 모델이 모르는 곳을 알게 하기: 모델이 자신 없는 곳을 표시할 수 있으면 그곳의 낙관적인 예측을 믿지 않을 수 있다. 이 장 후반부의 주제이다.

확률적 모델: 평균과 분산을 함께 예측

6장의 모델은 다음 상태를 숫자 하나로 예측했다. 이제 각 출력에 대해 평균 \(\mu_\theta(x)\) 와 분산 \(\sigma^2_\theta(x)\) 를 함께 내어 다음 상태를 분포로 예측한다.

\(p_\theta(y \mid x) = \mathcal{N}\big(y;\ \mu_\theta(x),\ \sigma_\theta^2(x)\big)\)

분산이 입력 \(x\) 마다 다를 수 있다(이분산, heteroscedastic). 결과가 늘 거의 같은 상태와 들쭉날쭉한 상태를 구별할 수 있다.

분산까지 배우는 가우시안 NLL

6장에서는 분산을 고정해서 NLL 이 MSE 가 되었다. 이번에는 분산도 모델이 정하므로 NLL 의 모든 항이 살아 있다. 신경망은 분산 대신 로그 분산 \(s = \log\sigma^2\) 을 낸다. \(\sigma^2 = e^{s}\) 는 \(s\) 가 어떤 실수여도 양수이고, 아주 작은 분산과 아주 큰 분산을 비슷한 크기의 숫자로 다룰 수 있다.

\(\begin{align} -\log\mathcal{N}(y;\mu,\sigma^2) &= \frac12\log(2\pi) + \frac12\log\sigma^2 + \frac{(y-\mu)^2}{2\sigma^2} \\ &= \frac12\log(2\pi) + \frac12\left[(y-\mu)^2 e^{-s} + s\right] \end{align}\)

상수 \(\frac12\log 2\pi\) 를 버리고 2 를 곱해도 최솟값의 위치는 같으므로 손실은 다음과 같다. 코드의 ((target - mean) ** 2) * torch.exp(-logvar) + logvar 가 이 식이다.

\(\mathcal{L}(\mu, s) = (y - \mu)^2 e^{-s} + s\)

두 항이 줄다리기를 한다. 기울기는 다음과 같다.

\(\frac{\partial\mathcal{L}}{\partial\mu} = -\frac{2(y-\mu)}{\sigma^2}, \qquad \frac{\partial\mathcal{L}}{\partial s} = 1 - \frac{(y-\mu)^2}{\sigma^2}\)

  • 평균의 기울기는 MSE 의 기울기 \(-2(y-\mu)\) 를 \(\sigma^2\) 로 나눈 것이다. 모델이 시끄럽다고(분산 큼) 한 곳의 오차는 덜, 확실하다고 한 곳의 오차는 크게 반영한다.
  • \(\frac{\partial\mathcal{L}}{\partial s} = 0 \Leftrightarrow \sigma^2 = (y-\mu)^2\) 이다. 분산이 실제 제곱 오차보다 작으면 기울기가 음수라 \(s\) 를 키우고, 크면 줄인다. 여러 데이터에 대해 평균 내면 학습된 분산은 그 입력 근처의 평균 제곱 오차에 맞춰진다. 모델이 자기 오차의 크기를 스스로 예측하게 된다.
  • 수치 예: \(y = 1.0\), \(\mu = 0.4\), \(s = 0\) 이면 \(\mathcal{L} = 0.36\), \(\frac{\partial\mathcal{L}}{\partial\mu} = -1.2\) (\(\mu\) 를 키운다), \(\frac{\partial\mathcal{L}}{\partial s} = 0.64\) (\(s\) 를 줄인다. 분산 1 은 실제 오차 0.36 에 비해 너무 크다).

주의: 어떤 데이터 점에서 \(\mu\) 가 정답을 정확히 맞히면 \(\mathcal{L} = s\) 가 되어 \(s \to -\infty\) (분산 → 0)로 끝없이 작아질 수 있다. 반대로 \(s\) 를 아주 크게 만들어 오차 항을 없애는 것도 가능하다. 그래서 로그 분산을 일정 범위 안에 가둔다.

softplus 로 로그 분산 가두기

torch.clamp 로 자르면 범위 밖에서 기울기가 0 이 되어 학습이 멈춘다. PETS 는 \(\mathrm{softplus}(x) = \log(1 + e^{x})\) 로 부드럽게 가둔다. softplus 는 늘 0 보다 크고, \(x\) 가 크면 \(\approx x\), 아주 작으면 \(\approx 0\) 인 부드러운 ReLU 이다.

\(\begin{align} s' &= s_{\max} - \mathrm{softplus}(s_{\max} - s_{\text{raw}}) \\ s &= s_{\min} + \mathrm{softplus}(s' - s_{\min}) \end{align}\)

  • 첫 식에서 \(s' \le s_{\max}\) 이고, \(s_{\text{raw}}\) 가 \(s_{\max}\) 보다 한참 작으면 \(s' \approx s_{\text{raw}}\) 로 그대로 지나간다. 둘째 식은 같은 논리로 \(s \ge s_{\min}\) 이다.
  • 범위 한가운데에서는 \(s \approx s_{\text{raw}}\) 이고 양 끝에서 부드럽게 휜다. 어디서나 기울기가 0 이 아니다. 정확한 위쪽 한계는 \(\log(e^{s_{\min}} + e^{s_{\max}})\) 로 \(s_{\max}\) 를 아주 조금 넘지만 무시할 만하다.
  • 예: \(s_{\max} = 0.5\), \(s_{\text{raw}} = 3\) 이면 \(s' = 0.5 - \log(1 + e^{-2.5}) = 0.5 - 0.0789 = 0.421\) 이다. 이어서 \(s_{\min} = -10\) 이면 \(s = -10 + \log(1+e^{10.421}) \approx 0.421\) 이다.
  • \(s_{\max}\), \(s_{\min}\) 도 학습되는 매개변수이고(처음 값 0.5, -10), 손실에 \(0.01\,(s_{\max} - s_{\min})\) 을 더해 범위가 쓸데없이 넓어지지 않게 한다.

두 가지 불확실성과 앙상블

우연적 불확실성 (aleatoric)

인식적 불확실성 (epistemic)

원인

세상 자체가 무작위이다 (주사위, 센서 잡음)

모델이 아직 충분히 보지 못했다 (데이터 부족)

데이터를 더 모으면

줄지 않는다

줄어든다

예

같은 힘으로 던져도 공이 떨어지는 곳이 조금씩 다르다

한 번도 가 본 적 없는 상태의 결과

모델에서

각 모델이 내는 분산 \(\sigma^2_\theta(x)\)

여러 모델의 예측이 서로 다른 정도

분산을 내는 모델 하나는 우연적 불확실성만 표현한다. 데이터가 없는 곳에서 자신 있게 틀리는 것은 모델 하나로는 알 수 없다. 그래서 모델을 여러 개 학습시키는 앙상블(ensemble)을 쓴다. 멤버들은 데이터가 있는 곳에서는 비슷한 답을 내고, 없는 곳에서는 초기값과 학습 경로에 따라 서로 다른 답을 낸다. 의견이 갈리는 정도가 인식적 불확실성이다.

=== 전체 분산 = 우연적 + 인식적 === 멤버 \(E\) 개가 각자 \(\mathcal{N}(\mu_e, \sigma_e^2)\) 를 예측할 때, 멤버 하나를 고르게 골라 그 분포에서 뽑는 혼합 분포의 분산을 구한다.

\(\begin{align} \mathbb{E}[y] &= \frac1E\sum_{e=1}^E \mu_e =: \bar\mu \\ \mathbb{E}[y^2] &= \frac1E\sum_{e=1}^E \mathbb{E}[y^2 \mid e] = \frac1E\sum_{e=1}^E (\sigma_e^2 + \mu_e^2) \\ \operatorname{Var}[y] &= \mathbb{E}[y^2] - \mathbb{E}[y]^2 = \frac1E\sum_e \sigma_e^2 + \frac1E\sum_e \mu_e^2 - \bar\mu^2 \\ &= \underbrace{\frac1E\sum_{e=1}^E \sigma_e^2}_{\text{우연적: 분산의 평균}} + \underbrace{\frac1E\sum_{e=1}^E (\mu_e - \bar\mu)^2}_{\text{인식적: 평균들의 분산}} \end{align}\)

첫 줄은 전체 기댓값의 법칙, 둘째 줄은 각 멤버 안에서 \(\operatorname{Var} = \mathbb{E}[y^2] - \mathbb{E}[y]^2\) 를 쓴 것이다. 코드의 장난감 실험 toy_uncertainty_figure 가 두 항을 따로 계산한다: aleatoric = var.mean(0), epistemic = mu.var(0).

장난감 문제는 1차원 회귀 \(y = \sin(1.3x) + \text{잡음}\) 이다. 데이터는 \(x \in [-4,-1]\) (잡음 표준편차 0.04, 100개)과 \([1.5, 4]\) (잡음 표준편차 0.25, 100개)에만 있다. 멤버 5개, 은닉 64 이다.

  toy x=-2.50: aleatoric std 0.044, epistemic std 0.024
  toy x= 0.25: aleatoric std 0.071, epistemic std 0.238
  toy x= 2.75: aleatoric std 0.270, epistemic std 0.036
  toy x= 6.00: aleatoric std 0.080, epistemic std 0.389
  • 학습된 우연적 표준편차(0.044, 0.270)가 실제 잡음(0.04, 0.25)을 잘 찾아냈다.
  • 데이터가 없는 \(x = 0.25\), \(x = 6\) 에서는 인식적 표준편차(0.238, 0.389)가 데이터 위(0.024, 0.036)보다 열 배 가까이 크다.
  • 다섯 멤버의 평균 예측은 데이터 위에서 하나로 겹치고 빈 구간과 바깥에서 갈라진다. 다만 \(x \approx 6\) 에서는 진짜 함수가 ±2σ 띠 밖에 있다. 앙상블도 데이터 밖을 다 알지는 못한다.
  • 그림: 1차원 장난감 문제의 멤버별 예측과 우연적·전체 불확실성 띠

부트스트랩

멤버들이 서로 다른 의견을 갖도록 초기값뿐 아니라 학습 데이터도 멤버마다 다르게 준다. \(N\) 개의 데이터에서 복원 추출로 \(N\) 개를 뽑는 부트스트랩(bootstrap)이다. 한 데이터가 한 번도 안 뽑힐 확률은 \(\left(1 - \frac1N\right)^N\) 이고 \(N\) 이 크면 \(e^{-1} \approx 0.368\) 에 가까워진다(랜덤 슈팅 유도에서 \(p = \frac1N\) 으로 둔 것과 같은 계산). 그래서 멤버마다 원래 데이터의 약 63.2% 만 본다.

class EnsembleLinear(nn.Module):
    """E 개의 Linear 층을 배치 행렬곱 한 번으로 계산한다. x (E, B, in) → (E, B, out)."""

    def __init__(self, n_members: int, in_dim: int, out_dim: int):
        super().__init__()
        bound = 1.0 / math.sqrt(in_dim)  # nn.Linear 와 같은 초기화 범위
        self.weight = nn.Parameter(torch.empty(n_members, in_dim, out_dim).uniform_(-bound, bound))
        self.bias = nn.Parameter(torch.empty(n_members, 1, out_dim).uniform_(-bound, bound))

    def forward(self, x):
        return torch.baddbmm(self.bias, x, self.weight)  # bias + x @ weight  (멤버마다 따로)


class GaussianEnsemble(nn.Module):
    """멤버 E 개가 각자 평균 μ 와 로그 분산 log σ² 을 내는 확률적 앙상블."""

    def __init__(self, in_dim: int, out_dim: int, n_members: int = 5, hidden: int = 128):
        super().__init__()
        self.E = n_members
        self.layers = nn.ModuleList([
            EnsembleLinear(n_members, in_dim, hidden),
            EnsembleLinear(n_members, hidden, hidden),
            EnsembleLinear(n_members, hidden, hidden),
            EnsembleLinear(n_members, hidden, 2 * out_dim),  # 평균 + 로그 분산
        ])
        # 로그 분산의 위 · 아래 한계 (이것도 학습한다)
        self.max_logvar = nn.Parameter(torch.full((out_dim,), 0.5))
        self.min_logvar = nn.Parameter(torch.full((out_dim,), -10.0))

    def forward(self, x):
        h = x
        for layer in self.layers[:-1]:
            h = F.silu(layer(h))
        mean, raw_logvar = self.layers[-1](h).chunk(2, dim=-1)
        # softplus 로 부드럽게 [min_logvar, max_logvar] 안에 가둔다
        logvar = self.max_logvar - F.softplus(self.max_logvar - raw_logvar)
        logvar = self.min_logvar + F.softplus(logvar - self.min_logvar)
        return mean, logvar
  • EnsembleLinear 는 가중치를 (E, in, out) 모양 하나로 두고 torch.baddbmm(배치 행렬곱 + 편향)으로 다섯 멤버를 한 번에 계산한다. 입력도 (E, B, in) 이라 멤버마다 다른 입력을 넣을 수 있다.
  • 마지막 층은 출력 차원의 두 배를 내서 앞 절반을 평균, 뒤 절반을 가두기 전의 로그 분산으로 쓴다.
def gaussian_nll(mean, logvar, target):
    """가우시안 음의 로그 가능도에서 상수(½ log 2π)와 앞의 ½ 을 뺀 것: (y − μ)²/σ² + log σ²."""
    return (((target - mean) ** 2) * torch.exp(-logvar) + logvar).mean()


def train_ensemble(model, X, Y, steps=3000, batch_size=256, lr=1e-3, device="cpu", seed=0):
    """X (N, in), Y (N, out) 는 numpy 배열 (진자에서는 호출하는 쪽이 미리 표준화한다). 멤버마다 부트스트랩 표본으로 학습한다.

    돌려주는 값은 마지막 미니배치의 손실(NLL + 로그 분산 범위 벌점)이다.
    """
    g = torch.Generator().manual_seed(seed)
    N, E = len(X), model.E
    X, Y = to_tensor(X, device), to_tensor(Y, device)
    boot = torch.randint(N, (E, N), generator=g).to(device)  # 멤버 e 의 데이터 = X[boot[e]] (복원 추출)
    opt = torch.optim.Adam(model.parameters(), lr=lr)
    for step in range(steps):
        pos = torch.randint(N, (E, batch_size), generator=g).to(device)
        idx = torch.gather(boot, 1, pos)  # (E, B): 멤버마다 자기 부트스트랩 목록에서 뽑은 번호
        mean, logvar = model(X[idx])  # (E, B, out)
        loss = gaussian_nll(mean, logvar, Y[idx])
        loss = loss + 0.01 * (model.max_logvar.sum() - model.min_logvar.sum())  # 한계를 좁게 유지
        opt.zero_grad()
        loss.backward()
        opt.step()
    return loss.item()

boot[e] 가 멤버 \(e\) 의 부트스트랩 번호 목록이고, 매 스텝 각 멤버가 자기 목록에서 미니배치를 뽑는다(torch.gather). 손실은 다섯 멤버의 NLL 평균에 \(0.01\sum_d (s_{\max,d} - s_{\min,d})\) (출력 차원마다 하나씩)을 더한 것이다.

PETS: 확률적 앙상블로 계획하기

PETS(Probabilistic Ensembles with Trajectory Sampling, Chua 외, NeurIPS 2018)는 지금까지의 조각을 합친다. 모델은 확률적 앙상블, 계획기는 CEM, 그 사이를 잇는 것이 궤적 표본 전파(trajectory sampling, TS)이다.

궤적 표본 전파 (TS∞)

확률적 모델에서는 행동열 하나의 결과가 하나로 정해지지 않는다. 그래서 행동열마다 입자(particle) \(P\) 개를 띄워 각각 따로 굴린다.

  1. 입자 \(p\) 마다 앙상블 멤버 하나 \(e(p)\) 를 정해 두고 상상이 끝날 때까지 바꾸지 않는다(그래서 TS∞).
  2. 매 스텝 입자는 자기 멤버의 분포에서 다음 상태를 뽑는다: \(\hat o^{(p)}_{k+1} = \hat o^{(p)}_k + \mu_{e(p)} + \sigma_{e(p)}\,\epsilon\), \(\epsilon \sim \mathcal{N}(0, I)\) (표준화를 되돌리는 계산은 생략한 표기).
  3. 행동열의 점수는 입자들의 총 보상의 평균이다: \(\hat J = \frac1P\sum_{p=1}^P \sum_k r(\hat o^{(p)}_k, a_k)\).

3번은 기대 리턴 \(\mathbb{E}[J]\) 의 몬테카를로 추정이다. 1번이 핵심으로, 입자마다 멤버를 고정하면 각 입자는 "데이터와 맞는 그럴듯한 세상 하나" 에서 끝까지 산다. 멤버들이 갈리는 곳(데이터가 없는 곳)에서는 입자들이 서로 다른 세상으로 흩어진다.

PETS 의 점수는 입자들의 단순 평균이고 불확실성에 대한 감점 항은 따로 없다. 그래도 두 가지 까닭으로 모델 착취가 줄어든다.

  • 멤버 하나만 우연히 낙관적으로 틀린 곳은 나머지 멤버의 입자와 평균 나면서 점수가 깎인다.
  • 목표에서 멀어질수록 제곱으로 벌점을 주는 보상에서는 흩어짐 자체가 평균 보상을 낮춘다. \(\mathbb{E}[-\theta^2] = -\mathbb{E}[\theta]^2 - \operatorname{Var}[\theta]\) 이므로 입자들의 분산만큼 손해이다.

그래서 CEM 은 모델들이 의견을 모으는(데이터가 있는) 쪽의 행동열을 고르기 쉬워진다.

진자용 모델 ProbabilisticDynamics (region prob_dynamics)는 GaussianEnsemble(4, 3) 으로 \([o_t, a_t] \to \Delta o_t\) 의 분포를 예측하고, 입출력을 표준화해 학습한다. sample_next(obs, act) 는 재매개변수화 형태 \(\mu + \sigma\odot\epsilon\) 으로 표본을 뽑는다(8장). 입력 모양이 (E, B, 3) 이라 첫 번째 차원이 어느 멤버가 굴리는지를 정한다.

@torch.no_grad()
def evaluate_sequences_ts(dyn, obs, actions, n_particles=10):
    """궤적 표본 전파(TS∞): 후보마다 입자 P 개를 띄우고, 입자마다 앙상블 멤버 하나를 끝까지 고정해 굴린다.

    obs (3,), actions (N, H, 1) → 기대 총 보상 (N,) = 그 후보에 속한 입자들의 총 보상 평균
    배치 모양: 멤버 E 개 × (후보 N × 멤버당 입자 m) — 후보 n 의 입자는 행 n·m … n·m+m−1.
    """
    N, H, _ = actions.shape
    E = dyn.E
    m = max(1, n_particles // E)  # 후보 하나에서 멤버 하나가 맡는 입자 수
    o = obs.expand(E, N * m, 3).clone()  # (E, N·m, 3) 모든 입자가 지금 관측에서 출발
    total = torch.zeros(E, N * m, device=actions.device)
    for k in range(H):
        a = actions[:, k].repeat_interleave(m, dim=0).expand(E, N * m, 1)  # 후보의 행동을 그 입자들에게
        total += pendulum_reward(o, a)
        o = dyn.sample_next(o, a)
    return total.view(E, N, m).mean(dim=(0, 2))  # 입자 평균 = 기대 리턴의 몬테카를로 추정


class PETSPlanner(CEMPlanner):
    """CEM 은 그대로 두고, 점수 매기기만 TS 입자 평균으로 바꾼 계획기."""

    def __init__(self, dyn, n_particles=10, **kwargs):
        super().__init__(dyn, **kwargs)
        self.P = n_particles

    def evaluate(self, obs, actions):
        return evaluate_sequences_ts(self.model, obs, actions, self.P)
  • 배치를 (E, N·m, 3) 모양으로 짠다. 후보 \(N\) 개마다 멤버 하나가 입자 \(m = P/E\) 개를 맡으므로 후보 하나에 모두 \(P\) 개의 입자가 붙는다.
  • repeat_interleave(m, dim=0) 는 후보 \(n\) 의 행동을 행 \(nm, \dots, nm + m - 1\) 에 복사하고, 마지막에 view(E, N, m) 으로 되돌려 후보별 평균을 낸다.
  • 이 장의 설정(\(N = 200\), \(P = 10\), \(E = 5\), \(m = 2\))이면 한 스텝에 \(5\times400 = 2{,}000\) 행을 계산한다.

데이터가 없는 곳에서는 입자가 흩어진다

두 앙상블을 학습해 비교한다. 하나는 늘 매달린 자세 근처에서 시작하는 에피소드 20개로만 학습한다(무작위 행동으로는 위쪽 절반에 가지 못해 이 데이터에서 \(\cos\theta\) 의 최댓값은 \(-0.33\) 이다). 다른 하나는 시작 자세가 고른 에피소드 20개로 학습한다. 둘 다 거의 선 자세(\(\theta = 0.4\))에서 같은 무작위 행동열(60 스텝)로 입자 50개를 굴린다.

  bottom-start data only  : particle std of θ̇ at step 10/30/60 = 1.958 / 3.792 / 5.273
  uniform-start data      : particle std of θ̇ at step 10/30/60 = 0.037 / 0.455 / 0.753
  • 아래쪽 데이터만 본 모델은 입자가 처음부터 사방으로 흩어지고 \(\cos\theta \gt 1\) 처럼 있을 수 없는 값까지 상상한다.
  • 고른 데이터로 학습한 모델의 입자는 2초 남짓까지 진짜 궤적을 따라 좁게 모여 있다. 입자의 흩어짐이 "여기는 모른다" 는 신호가 된다.
  • 이 신호에는 한계가 있다. 고른 데이터 쪽에서도 2.3초쯤부터는 입자들이 조금 퍼지기는 하지만 무리 전체가 진짜에서 벗어나, 흩어진 폭보다 실제 오차가 더 크다. 멤버들이 같은 방향으로 틀리면 앙상블도 알아채지 못한다.
  • 그림: 거의 선 자세에서 출발한 입자 50개의 롤아웃과 진짜 궤적

PETS 로 진자 세우기

고리는 전반부와 같고 모델과 계획기만 바뀐다(region pets_loop). 매 반복 ProbabilisticDynamics() 를 새로 만들어 fit(data, steps=3000) 으로 학습하고, PETSPlanner(dyn, n_particles=10, horizon=25, n_candidates=200, n_elites=30) 으로 한 에피소드를 실행해 데이터에 더한다.

iter  1 | data  2 episodes | NLL  -8.821 | PETS return   -221.8 |   127s
iter  2 | data  3 episodes | NLL  -9.090 | PETS return   -115.1 |   261s
iter  3 | data  4 episodes | NLL  -7.906 | PETS return   -123.9 |   418s
iter  4 | data  5 episodes | NLL  -9.217 | PETS return   -127.0 |   532s
iter  5 | data  6 episodes | NLL  -8.947 | PETS return   -124.1 |   629s
iter  6 | data  7 episodes | NLL  -9.025 | PETS return   -253.8 |   682s
iter  7 | data  8 episodes | NLL  -9.100 | PETS return   -119.6 |   751s
iter  8 | data  9 episodes | NLL  -8.872 | PETS return   -243.3 |   796s
PETS (eval)         : mean return   -110.5 ±   66.4  (episodes: -1, -119, -123, -120, -125, -118, -248, -124, -128, -1)
  • 평가 10 에피소드의 평균 리턴은 \(-110.5 \pm 66.4\) 로 결정적 모델 + CEM(\(-110.4 \pm 66.6\))과 사실상 같다. 에피소드별 점수와 고리를 도는 동안의 리턴도 거의 같다.
  • 계산은 훨씬 무겁다. 같은 CPU 에서 행동 하나에 약 0.23초(후보 200 × 입자 10, 정예 30)로 결정적 CEM(약 0.09초, 후보 400)의 2.5배였다. 전체 스크립트는 다른 계산과 CPU 를 나눠 쓰는 상태에서 약 19분 걸렸다. GPU 에서는 행동 하나에 약 0.09초로 2.6배 빨랐다.
  • NLL 열은 학습 마지막 미니배치의 손실(NLL 평균 + 범위 벌점)이다. 값이 \(-9\) 근처인 것은 로그 분산 \(s\) 가 아래 한계(처음 값 \(-10\), 학습되어 조금 움직인다) 근처까지 내려갔다는 뜻이다. 진자에는 잡음이 없어서 모델이 분산을 줄일 수 있는 데까지 줄였다.
  • 진자에서 차이가 작은 이유: 잡음이 전혀 없고(우연적 불확실성 0) 상태가 3차원뿐이라 데이터 몇 에피소드면 거의 모든 곳을 덮는다. PETS 논문에서 확률적 앙상블이 결정적 모델보다 뚜렷이 나았던 것은 상태가 스무 차원 안팎인 로봇 팔, 반치타(half-cheetah) 같은 과제였다. 불확실성을 다루는 기술은 문제가 어렵고 데이터가 부족할 때 효과가 드러나고, 계산은 입자 수 \(P\) 배만큼 늘어난다.

계획하는 World Model 의 장단점

장점

단점

정책을 학습하지 않아도 바로 행동할 수 있다

행동 하나마다 무거운 최적화(수만 번의 모델 호출)

보상 함수를 바꾸면 다시 학습 없이 새 목표에 맞춰 계획한다

지평 \(H\) 밖의 일은 고려하지 못한다(가치 함수가 없으므로)

진짜 환경과의 상호작용이 아주 적다(데이터 효율)

행동 차원과 지평이 커지면 표본 기반 탐색이 어려워진다

매 스텝 다시 계획해 모델 오차를 되먹임으로 바로잡는다

모델 착취: 최적화가 모델의 허점을 찾아낸다

  • 지평 밖을 못 보는 문제는 지평 끝에 가치 함수(거기서부터 앞으로 얻을 보상의 추정)를 더해 해결한다(13장의 TD-MPC).
  • 무거운 계산은 상상 속에서 정책을 학습해 두는 방법으로 해결한다(12장의 Dreamer).

원문이 권하는 실험은 다음과 같다.

  • python ch07_mpc.py --horizon 8 처럼 지평을 줄여 몇부터 실패하는지 본다(흔들어 올리려면 잠시 반대로 가야 한다).
  • CEMPlanner 의 n_iters 를 1 로 두고 랜덤 슈팅과 비교한다.
  • run_episode 를 계획한 행동열 전체를 끝까지 실행하는 열린 고리로 바꿔 본다.
  • pendulum_reward 대신 "매달린 자세에서 가만히 있기" 보상으로 계획한다. 모델은 다시 학습할 필요가 없다.

정리

  • 계획은 모델 속에서 상상한 총 보상 \(J(a_{t:t+H-1}) = \sum_k r(\hat o_{t+k}, a_{t+k})\) 를 최대화하는 행동열을 찾는 것이다.
  • MPC 는 매 스텝 \(H\) 스텝을 계획하고 첫 행동만 실행한 뒤 다시 계획한다. 짧은 상상과 되먹임으로 모델 오차를 견딘다.
  • 랜덤 슈팅은 좋은 후보의 비율 \(p\) 가 지평에 따라 지수적으로 줄어 한계가 있다(\(1 - e^{-pN}\)).
  • CEM 은 정예에 가우시안을 최대우도로 다시 맞추기(평균 = 표본 평균, 분산 = 표본 분산)를 되풀이하고, 평활과 웜 스타트를 쓴다.
  • "모으기 → 학습 → 계획하며 모으기" 고리로 진짜 경험 9 에피소드 만에 진자를 세웠다(무작위 \(-1202\) → CEM \(-110\)).
  • 확률적 모델은 NLL \((y-\mu)^2e^{-s} + s\) 로 평균과 로그 분산을 함께 배우고, 학습된 분산은 제곱 오차에 맞춰진다.
  • 앙상블의 전체 분산 = 분산의 평균(우연적) + 평균의 분산(인식적)이다. PETS 는 TS∞ 입자로 이 불확실성을 계획에 반영한다.

확인 문제

1. 랜덤 슈팅에 필요한 후보 수
\(p = 10^{-4}\) 일 때 좋은 후보를 적어도 하나 얻을 확률을 95% 로 하려면? \(1 - e^{-pN} = 0.95\) 에서 \(pN = \log 20 \approx 3.0\), 그래서 \(N \approx 30{,}000\) 개이다.
2. CEM 한 번 손으로 돌리기
정예 \(K = 4\) 개의 값이 \(1.0,\ 1.4,\ 1.8,\ 1.8\), \(\mu_{\text{old}} = 0\), \(\sigma_{\text{old}} = 1\), \(\alpha = 0.1\) 이다. \(\hat\mu = 1.5\), \(\hat\sigma^2 = (0.25 + 0.01 + 0.09 + 0.09)/4 = 0.11\), \(\hat\sigma = 0.3317\) 이므로 \(\mu = 0.9\times1.5 = 1.35\), \(\sigma = 0.1 + 0.9\times0.3317 = 0.3985\) 이다.
3. 분산 학습의 평형점
오차가 \(y - \mu = 0.1,\ -0.3,\ 0.2\) 인 데이터 세 개에 하나의 로그 분산 \(s\) 를 낼 때 NLL 합을 최소로 하는 분산은? \(s\) 로 미분하면 \(-e^{-s}\sum_i(y_i-\mu_i)^2 + 3 = 0\) 이므로 \(\sigma^2 = \frac{0.01+0.09+0.04}{3} = 0.0467\), 곧 평균 제곱 오차이다.
4. 앙상블 분산 나누기
멤버 세 개가 \((\mu_e, \sigma_e^2) = (1.0, 0.04),\ (1.2, 0.04),\ (1.4, 0.07)\) 을 예측했다. 우연적 = \(0.15/3 = 0.05\), \(\bar\mu = 1.2\), 인식적 = \(0.08/3 \approx 0.0267\), 전체 = \(0.0767\) 이다.
5. 왜 TS∞ 인가
매 스텝 멤버를 무작위로 다시 고르면(PETS 논문의 TS1) 한 입자가 여러 세상을 섞어 사는 셈이라 멤버 사이의 체계적인 차이(인식적 불확실성)가 스텝마다 평균 나며 일부 상쇄된다. TS∞ 는 멤버 사이의 차이가 궤적 끝까지 그대로 벌어져 인식적 불확실성이 더 분명히 드러난다. PETS 논문은 두 방식을 모두 실험했고 과제에 따라 성능 차이는 크지 않았다.

See also

Favorite site

author MCPBot, Zer0 sitemap