WorldModels:Tutorial:08-VAE
lastmod 2026-11-18created 2026-11-172 edits
눈 만들기: VAE는 World Model 튜토리얼의 8장이다. 6·7장의 World Model 은 진자의 상태를 숫자 3개 \([\cos\theta, \sin\theta, \dot\theta]\) 로 받았지만, 이 장부터 에이전트는 64×64 흑백 그림만 본다. 그림을 그대로 예측하지 않고 먼저 32개의 숫자로 압축하는 눈, 곧 변분 오토인코더(VAE)를 만든다. 잠재 변수 모델, ELBO 의 두 가지 유도, KL 항의 닫힌 꼴, 디코더 가능도의 선택, 재매개변수화 트릭, 합성곱 구현과 실험 결과를 다루며, 여기서 학습한 VAE 와 에피소드 데이터는 9·10장이 이어서 쓴다.
- 원문: 08. 눈 만들기: VAE
- 실습 코드:
code/ch08_vae.py,code/wm_envs.py(노트북 GPU 로 전체 2~4분, CPU 4스레드로 약 50분.--quick은 CPU 로 1분 안쪽) - 이전: 07. MPC 와 CEM / 다음: 09. RNN 과 MDN-RNN
왜 그림을 압축하는가
PixelPendulum 환경의 관측 \(o_t\) 는 64×64 = 4096개의 픽셀이고 픽셀마다 0~255 의 밝기를 가진다. World Model 의 일은 지금 그림과 행동을 보고 다음 그림을 예측하는 것인데, 4096개의 숫자를 통째로 예측하는 것은 어렵고 낭비가 크다.
- 대부분의 픽셀은 늘 0(검정)이다. 막대가 차지하는 픽셀은 수백 개 남짓이다.
- 그림이 달라지는 방식은 하나뿐이다. 진자 그림은 각도 \(\theta\) 하나로 완전히 정해지므로, 4096차원 공간 안에서 각도를 따라 한 바퀴 도는 가느다란 고리 위에만 놓인다.
- 256단계 픽셀 4096개로 만들 수 있는 그림은 \(256^{4096}\) 가지이지만 진자 그림은 그중 한 줄짜리 고리다.
고차원 데이터가 실제로는 훨씬 낮은 차원의 면이나 선 위에 놓여 있다는 생각을 다양체 가설(manifold hypothesis)이라고 한다. 그림을 그 선 위의 좌표로 바꾸어 예측은 좌표에서 하고, 필요할 때만 좌표를 그림으로 되돌리면 된다. Ha & Schmidhuber(2018)의 World Models 가 택한 전략이며(10장), 이 장의 VAE 는 그 구조의 V(Vision, 눈)에 해당한다.
전체 구조는 그림 \(x\) (64×64 = 4096) → 인코더 \(q_\phi(z \mid x)\) → 잠재 벡터 \(z\) (32개) → 디코더 \(p_\theta(x \mid z)\) → 복원 \(\hat{x}\) (64×64)이다. 가운데가 4096 → 32 → 4096 으로 좁아지는 병목(bottleneck)이다.
오토인코더와 그 한계
가장 단순한 압축기는 오토인코더(autoencoder, AE)다. 인코더 \(f_\phi\) 가 그림 \(x\) 를 작은 벡터 \(z = f_\phi(x)\) 로 줄이고, 디코더 \(g_\theta\) 가 \(\hat{x} = g_\theta(z)\) 로 되살린다. 정답이 입력 자신이므로 사람이 정답을 달 필요가 없고(자기 지도 학습), \(z\) 가 입력보다 훨씬 작으므로 그림을 되살리는 데 꼭 필요한 정보만 \(z\) 에 담게 된다.
\(\min_{\phi,\theta}\; \frac{1}{N}\sum_{n=1}^{N} \text{재구성 오차}\big(x^{(n)},\; g_\theta(f_\phi(x^{(n)}))\big)\)
재구성 오차로는 픽셀별 제곱 오차(MSE)나 이진 교차 엔트로피(BCE)를 쓴다. 오토인코더도 재구성은 잘 한다. 문제는 잠재 공간의 모양이다. 이 장의 코드는 VAE 와 같은 구조의 오토인코더를 함께 학습해 비교하는데, 두 가지 문제가 드러난다.
- 잠재 벡터가 어디에 있는지 모른다. \(z\) 의 범위에 아무 제약이 없다. 학습된 오토인코더의 \(z\) 는 성분 하나의 크기가 최대 36, 주성분 축으로 재면 ±60 안팎까지 퍼졌다. 새 그림을 만들려 해도 \(z\) 를 어디서 뽑아야 할지 알 수 없다.
- 잠재 공간이 듬성듬성하다. 디코더는 학습 데이터가 실제로 떨어진 점들에서만 훈련된다. 그 사이나 바깥의 \(z\) 를 넣으면 본 적 없는 입력이라 엉뚱한 그림을 낸다.
9장의 M 모델은 잠재 공간에서 다음 \(z\) 를 뽑아 미래를 상상하므로, 뽑은 \(z\) 가 디코더가 모르는 곳에 떨어지면 상상이 곧바로 무너진다. 필요한 것은 \(z\) 가 따르는 분포를 알고, 그 분포에서 뽑은 어떤 \(z\) 도 그럴듯한 그림이 되는 잠재 공간이다. 이것을 확률 모델로 푼 것이 VAE 다.
잠재 변수 모델
생성 과정과 주변 가능도
VAE 는 그림이 만들어지는 과정을 다음처럼 가정한다.
- 잠재 벡터를 표준 정규 분포에서 뽑는다. \(z \sim p(z) = \mathcal{N}(0, I)\) (32개 성분이 서로 독립이고 각각 평균 0, 분산 1).
- \(z\) 를 디코더에 넣어 그림의 분포를 정하고 거기서 그림을 뽑는다. \(x \sim p_\theta(x \mid z)\).
\(z\) 는 데이터에 직접 보이지 않으므로 잠재 변수(latent variable)라고 한다. 그림 하나의 확률(주변 가능도)은 결합 확률을 \(z\) 에 대해 주변화하고 곱셈 법칙 \(p(x, z) = p(x \mid z)\,p(z)\) 를 적용한 것이다.
\(p_\theta(x) = \int p_\theta(x, z)\, dz = \int p_\theta(x \mid z)\, p(z)\, dz\)
\(\theta^\ast = \operatorname*{arg\,max}_\theta \sum_{n=1}^{N} \log p_\theta\big(x^{(n)}\big)\)
계산할 수 없는 이유
\(z\) 가 32차원이므로 위 적분은 32겹 적분이다. 각 축을 10칸씩만 나눠도 \(10^{32}\) 개의 칸에서 디코더를 돌려야 한다. 사전 분포에서 \(z\) 를 뽑아 평균을 내는 몬테카를로 추정도 식으로는 맞다.
\(p_\theta(x) = \mathbb{E}_{z \sim p(z)}\big[p_\theta(x \mid z)\big] \approx \frac{1}{S}\sum_{s=1}^{S} p_\theta\big(x \mid z^{(s)}\big),\qquad z^{(s)} \sim p(z)\)
그러나 특정한 그림 \(x\) 를 만들어 내는 \(z\) 는 잠재 공간의 아주 작은 구역뿐이다. 아무렇게나 뽑은 \(z\) 에서는 \(p_\theta(x \mid z^{(s)})\) 가 사실상 0 이고, 그 구역에 우연히 떨어진 드문 표본 하나가 평균을 좌우한다. 추정값의 분산이 커서 학습 신호로 쓸 수 없다.
\(x\) 를 만든 \(z\) 가 어디쯤 있는지를 답하는 것이 사후 분포(posterior) \(p_\theta(z \mid x)\) 이고 베이즈 정리로 쓸 수 있다.
\(p_\theta(z \mid x) = \frac{p_\theta(x \mid z)\, p(z)}{p_\theta(x)} = \frac{p_\theta(x \mid z)\, p(z)}{\int p_\theta(x \mid z')\, p(z')\, dz'}\)
분자는 디코더를 한 번 돌리면 나오지만 분모가 바로 계산할 수 없는 그 적분이다. \(p_\theta(x)\) 도 \(p_\theta(z \mid x)\) 도 계산할 수 없는 이 상황을 사후 분포가 다루기 어렵다(intractable)고 한다.
변분 추론: 사후 분포를 추측하는 신경망
계산할 수 없는 \(p_\theta(z \mid x)\) 대신 다루기 쉬운 분포 \(q_\phi(z \mid x)\) 로 근사하는 것이 변분 추론(variational inference)이다. VAE 는 이 \(q_\phi\) 를 신경망(인코더)으로 만든다.
\(q_\phi(z \mid x) = \mathcal{N}\big(z;\ \mu_\phi(x),\ \operatorname{diag}(\sigma^2_\phi(x))\big)\)
- 인코더는 그림 \(x\) 를 받아 32개의 평균 \(\mu_\phi(x)\) 와 32개의 분산 \(\sigma^2_\phi(x)\) 를 낸다. 이 그림을 만든 \(z\) 는 \(\mu\) 근처, 오차 \(\sigma\) 정도라는 추측이다.
- \(\operatorname{diag}(\cdot)\) 은 대각 공분산, 곧 32개 성분이 서로 독립인 가우시안이라는 뜻이다. 단순하지만 계산이 쉽다.
- 실제 출력은 \(\sigma^2\) 이 아니라 \(\log \sigma^2\) 이다. 신경망 출력은 음수도 되지만 분산은 양수여야 하므로 \(\sigma = \exp(\tfrac{1}{2}\log\sigma^2)\) 로 바꾸면 늘 양수가 된다. \(\sigma\) 가 0.001 이든 100 이든 \(\log\sigma\) 로는 −6.9 와 4.6(로그 분산으로는 −13.8 과 9.2)이라 숫자 범위도 좁다.
그림마다 따로 최적화 문제를 풀지 않고 신경망 하나가 모든 그림의 \(q\) 를 한 번에 내놓으므로 분할 상환 추론(amortized inference)이라고도 한다. 무엇을 최대화하면 \(q_\phi\) 가 좋은 추측이 되면서 \(p_\theta(x)\) 도 커지는지에 대한 답이 ELBO 다.
ELBO
유도 1: 젠센 부등식
로그처럼 오목한 함수는 젠센 부등식 \(\log \mathbb{E}[Y] \ge \mathbb{E}[\log Y]\) 를 만족한다(3장). 예를 들어 \(Y\) 가 반반의 확률로 1 또는 4 이면 \(\log \mathbb{E}[Y] = \log 2.5 \approx 0.916\), \(\mathbb{E}[\log Y] = \tfrac{1}{2}(\log 1 + \log 4) \approx 0.693\) 이다. 적분 안에 \(q_\phi / q_\phi = 1\) 을 곱해 기댓값 꼴로 만든 뒤 이 부등식을 적용한다.
\(\begin{align} \log p_\theta(x) &= \log \int p_\theta(x, z)\, dz \\ &= \log \int q_\phi(z \mid x)\, \frac{p_\theta(x, z)}{q_\phi(z \mid x)}\, dz \\ &= \log \mathbb{E}_{z \sim q_\phi(z \mid x)}\left[\frac{p_\theta(x, z)}{q_\phi(z \mid x)}\right] \\ &\ge \mathbb{E}_{z \sim q_\phi(z \mid x)}\left[\log \frac{p_\theta(x, z)}{q_\phi(z \mid x)}\right] \\ &= \mathbb{E}_{q_\phi}\left[\log p_\theta(x \mid z) + \log p(z) - \log q_\phi(z \mid x)\right] \\ &= \mathbb{E}_{q_\phi}\left[\log p_\theta(x \mid z)\right] - \mathbb{E}_{q_\phi}\left[\log q_\phi(z \mid x) - \log p(z)\right] \end{align}\)
넷째 줄에서 등호가 부등호로 바뀐다. 마지막 줄의 둘째 항은 KL 발산의 정의 \(D_{\mathrm{KL}}(q\,\Vert\,p) = \mathbb{E}_q[\log q - \log p]\) 그 자체다.
\(\log p_\theta(x) \;\ge\; \underbrace{\mathbb{E}_{q_\phi(z \mid x)}\left[\log p_\theta(x \mid z)\right] - D_{\mathrm{KL}}\big(q_\phi(z \mid x)\,\Vert\,p(z)\big)}_{\text{ELBO}(\theta,\phi;\,x)}\)
오른쪽이 ELBO(Evidence Lower BOund, 증거 하한)다. 증거(evidence)는 \(p_\theta(x)\) 의 다른 이름이다. 두 항 모두 계산할 수 있다. 첫 항은 \(q_\phi\) 에서 \(z\) 를 뽑아 디코더에 넣으면 되고, 둘째 항은 두 가우시안 사이의 KL 이라 공식으로 나온다. 계산할 수 없는 \(\log p_\theta(x)\) 대신 계산할 수 있는 아래 경계를 최대화하는 것이 VAE 학습이다.
유도 2: 간격의 정체
젠센 부등식은 ELBO 가 \(\log p_\theta(x)\) 보다 작다는 것만 알려 준다. 얼마나 작은지는 근사 \(q_\phi(z \mid x)\) 와 진짜 사후 분포 \(p_\theta(z \mid x)\) 의 KL 에서 출발해 등식만으로 얻는다. 베이즈 정리에 로그를 씌운 \(\log p_\theta(z \mid x) = \log p_\theta(x, z) - \log p_\theta(x)\) 를 대입하고, \(z\) 와 무관한 상수 \(\log p_\theta(x)\) 를 기댓값 밖으로 꺼낸다.
\(\begin{align} D_{\mathrm{KL}}\big(q_\phi(z \mid x)\,\Vert\,p_\theta(z \mid x)\big) &= \mathbb{E}_{q_\phi}\left[\log q_\phi(z \mid x) - \log p_\theta(z \mid x)\right] \\ &= \mathbb{E}_{q_\phi}\left[\log q_\phi(z \mid x) - \log p_\theta(x, z) + \log p_\theta(x)\right] \\ &= \mathbb{E}_{q_\phi}\left[\log q_\phi(z \mid x) - \log p_\theta(x, z)\right] + \log p_\theta(x) \\ &= -\,\mathbb{E}_{q_\phi}\left[\log \frac{p_\theta(x, z)}{q_\phi(z \mid x)}\right] + \log p_\theta(x) \\ &= -\,\text{ELBO} + \log p_\theta(x) \end{align}\)
\(\log p_\theta(x) = \text{ELBO}(\theta, \phi; x) + D_{\mathrm{KL}}\big(q_\phi(z \mid x)\,\Vert\,p_\theta(z \mid x)\big)\)
로그 가능도(계산할 수 없다)는 ELBO(계산할 수 있다)와 근사의 오차(KL ≥ 0)의 합으로 정확히 나뉜다. 이 등식에서 다음이 나온다.
- KL ≥ 0 이므로 ELBO ≤ \(\log p_\theta(x)\) 다. 등호는 \(q_\phi(z \mid x) = p_\theta(z \mid x)\) 일 때만 성립한다.
- 인코더 \(\phi\) 에 대해 ELBO 를 올리면 간격이 줄어든다. \(\log p_\theta(x)\) 는 \(\phi\) 와 무관한 고정값이므로 ELBO 가 커진 만큼 KL 이 줄고, 인코더는 진짜 사후 분포에 가까워진다.
- 디코더 \(\theta\) 에 대해 ELBO 를 올리면 대체로 \(\log p_\theta(x)\) 가 올라간다. 아래 경계를 밀어 올리면 그 위의 값도 따라 올라간다.
VAE 는 하나의 목표 ELBO 를 \(\phi\) 와 \(\theta\) 에 대해 동시에 최대화한다. 손실 함수로는 부호를 바꾼 −ELBO 를 최소화한다.
두 항의 역할
\(\text{ELBO} = \underbrace{\mathbb{E}_{q_\phi(z \mid x)}\big[\log p_\theta(x \mid z)\big]}_{\text{(1) 재구성 항}} \;-\; \underbrace{D_{\mathrm{KL}}\big(q_\phi(z \mid x)\,\Vert\,p(z)\big)}_{\text{(2) KL 항 (정규화)}}\)
- 재구성 항
- 인코더가 추측한 \(z\) 를 뽑아 디코더에 넣었을 때 원래 그림 \(x\) 가 나올 로그 확률이다. 클수록 좋다. 오토인코더의 재구성 오차와 같은 역할이다.
- KL 항
- 그림마다의 추측 \(q_\phi(z \mid x)\) 가 사전 분포 \(\mathcal{N}(0, I)\) 에서 너무 멀어지지 않게 붙잡는다. 작을수록 좋다.
원문은 도서관 비유를 든다. 사서(인코더)가 책(그림)마다 서가 위치(\(z\))를 정할 때, 재구성 항은 위치만 보고 그 책을 다시 찾을 수 있어야 한다는 규칙이고, KL 항은 위치를 입구 근처의 정해진 구역(\(\mathcal{N}(0, I)\))에 몰아서, 한 점이 아니라 범위로 정하라는 규칙이다.
KL 항은 오토인코더의 두 문제를 이렇게 푼다.
- 어디서 뽑을지 알게 된다. 모든 그림의 \(q_\phi(z \mid x)\) 가 원점 근처, 크기 1 정도에 모이므로 전체 \(z\) 가 대략 \(\mathcal{N}(0, I)\) 를 따른다고 기대할 수 있다. 새 그림은 \(\mathcal{N}(0, I)\) 에서 \(z\) 를 뽑아 만든다.
- 잠재 공간이 촘촘해진다. 인코더가 점이 아니라 폭 \(\sigma\) 를 가진 구름을 내고, 학습 때 그 구름 안의 아무 점이나 뽑아 디코더에 넣는다. 디코더는 그 주변 전체에서 같은 그림을 내도록 배우므로 가까운 \(z\) 는 비슷한 그림이 된다. 구름들이 원점 쪽으로 끌려와 겹치면서 빈틈도 줄어든다. \(\sigma \to 0\) 이면 \(-\log\sigma^2\) 이 무한히 커지므로 KL 항은 구름이 점으로 줄어드는 것도 막는다.
두 항은 줄다리기를 한다. 재구성만 보면 구름을 아주 작게, 서로 멀리 떨어뜨리는 쪽이 유리하고(오토인코더), KL 만 보면 모든 그림을 똑같이 \(\mathcal{N}(0, I)\) 로 보내는 쪽이 유리하다(\(z\) 에 정보가 없어 재구성 불가능). VAE 는 그 사이의 균형점을 찾는다.
KL 항의 닫힌 꼴
한 차원
\(q = \mathcal{N}(\mu, \sigma^2)\), \(p = \mathcal{N}(0, 1)\) 일 때 두 로그 밀도는 다음과 같다.
\(\log q(z) = -\tfrac{1}{2}\log(2\pi) - \tfrac{1}{2}\log\sigma^2 - \frac{(z - \mu)^2}{2\sigma^2},\qquad \log p(z) = -\tfrac{1}{2}\log(2\pi) - \frac{z^2}{2}\)
빼면 공통 항 \(-\tfrac{1}{2}\log 2\pi\) 가 지워진다. 여기에 \(\mathbb{E}_q\big[(z-\mu)^2\big] = \sigma^2\) 와 \(\mathbb{E}_q\big[z^2\big] = \operatorname{Var}(z) + (\mathbb{E}[z])^2 = \sigma^2 + \mu^2\) 을 넣는다.
\(\begin{align} D_{\mathrm{KL}}(q\,\Vert\,p) &= \mathbb{E}_{z \sim q}\left[-\tfrac{1}{2}\log\sigma^2 - \frac{(z - \mu)^2}{2\sigma^2} + \frac{z^2}{2}\right] \\ &= -\tfrac{1}{2}\log\sigma^2 - \frac{\sigma^2}{2\sigma^2} + \frac{\sigma^2 + \mu^2}{2} \\ &= \tfrac{1}{2}\big(\mu^2 + \sigma^2 - 1 - \log\sigma^2\big) \end{align}\)
\(\mu = 0,\ \sigma = 1\) 이면 0 이 되어 같은 분포끼리의 KL 이 0 이라는 조건에 맞는다. \(\mu^2\) 은 평균이 0 에서 멀수록 붙는 벌점이고, \(\sigma^2 - 1 - \log\sigma^2\) 은 \(\sigma\) 가 1 에서 멀수록 붙는 벌점이다. \(g(s) = s - 1 - \log s\) (\(s = \sigma^2\))는 \(g'(s) = 1 - \tfrac{1}{s}\) 이므로 \(s \lt 1\) 에서 감소, \(s \gt 1\) 에서 증가하고 \(s = 1\) 에서 최솟값 \(g(1) = 0\) 을 가진다. 이 항은 늘 0 이상이고 \(\sigma = 1\) 일 때만 0 이다.
32차원
대각 공분산 가우시안은 성분끼리 독립이므로 밀도가 성분별 밀도의 곱이다(\(q_j = \mathcal{N}(\mu_j, \sigma_j^2)\), \(p_j = \mathcal{N}(0, 1)\)). 곱의 로그는 로그의 합이고, \(j\) 번째 항은 \(z_j\) 에만 의존하므로 나머지 성분에 대한 적분은 1 이 되어 사라진다. 대각 가우시안의 KL 은 차원별 KL 의 합이다.
\(D_{\mathrm{KL}}(q\,\Vert\,p) = \sum_{j=1}^{32} \mathbb{E}_{z_j \sim q_j}\big[\log q_j(z_j) - \log p_j(z_j)\big]\)
\(D_{\mathrm{KL}}\big(q_\phi(z \mid x)\,\Vert\,\mathcal{N}(0, I)\big) = \frac{1}{2}\sum_{j=1}^{32}\big(\mu_j^2 + \sigma_j^2 - 1 - \log\sigma_j^2\big)\)
숫자 예로 2차원에서 \(\mu = (0.5,\ 0)\), \(\sigma = (1,\ 0.5)\) 이면 \(\tfrac{1}{2}(0.25 + 1 - 1 - 0) + \tfrac{1}{2}(0 + 0.25 - 1 - \log 0.25) = 0.125 + 0.318 = 0.443\) 이다. 몬테카를로로 확인한 코드와 출력은 다음과 같다.
import torch
mu = torch.tensor([0.5, 0.0])
sigma = torch.tensor([1.0, 0.5])
# 닫힌 꼴: ½ Σ (μ² + σ² − 1 − log σ²)
closed = 0.5 * torch.sum(mu**2 + sigma**2 - 1 - torch.log(sigma**2))
# 몬테카를로: z ~ q 를 많이 뽑아 log q(z) − log p(z) 를 평균
q = torch.distributions.Normal(mu, sigma)
p = torch.distributions.Normal(torch.zeros(2), torch.ones(2))
z = q.sample((1_000_000,))
mc = (q.log_prob(z) - p.log_prob(z)).sum(-1).mean()
print(f"닫힌 꼴 {closed.item():.4f} | 몬테카를로 {mc.item():.4f}")
재구성 항: 디코더 가능도
재구성 항 \(\mathbb{E}_{q_\phi}[\log p_\theta(x \mid z)]\) 를 계산하려면 기댓값의 계산 방법과 \(p_\theta(x \mid z)\) 의 분포를 정해야 한다.
표본 하나로 기댓값 추정
\(q_\phi(z \mid x)\) 에서 \(z\) 를 하나만 뽑아 \(\log p_\theta(x \mid z^{(1)})\) 로 기댓값을 대신한다(\(S = 1\) 몬테카를로). 표본 하나는 흔들리지만 불편 추정이고, 미니배치 128장에 대해 평균을 내며 수천 번 갱신하므로 흔들림은 평균되어 사라진다. 사전 분포에서 뽑을 때는 쓸모없던 몬테카를로가 여기서 통하는 까닭은 \(z\) 를 \(x\) 를 보고 추측한 \(q_\phi(z \mid x)\) 에서 뽑기 때문이다. 대부분의 표본이 \(x\) 를 잘 만드는 구역에 떨어진다.
베르누이 디코더와 BCE
진자 그림은 대부분 검정(0)이고 막대는 밝은 회색(0.85), 끝의 추는 흰색(1)이다. 픽셀 \(i\) 의 밝기 \(x_i \in [0, 1]\) 을 흰색일 확률 \(p_i\) 인 베르누이로 본다. 디코더는 픽셀마다 로짓 \(\ell_i\) 를 내고 \(p_i = \text{sigmoid}(\ell_i) = \frac{1}{1 + e^{-\ell_i}}\) 이다. \(z\) 가 주어지면 픽셀들은 서로 독립이라고 가정한다.
\(\begin{align} p_\theta(x \mid z) &= \prod_{i=1}^{4096} p_i^{\,x_i}\,(1 - p_i)^{\,1 - x_i} \\ \log p_\theta(x \mid z) &= \sum_{i=1}^{4096}\Big(x_i \log p_i + (1 - x_i)\log(1 - p_i)\Big) \\ -\log p_\theta(x \mid z) &= \sum_{i=1}^{4096} \text{BCE}(x_i, p_i),\qquad \text{BCE}(x, p) = -\big(x\log p + (1-x)\log(1-p)\big) \end{align}\)
음의 로그 가능도가 픽셀별 이진 교차 엔트로피(Cross entropy)의 합이므로 코드의 재구성 손실은 binary_cross_entropy_with_logits(..., reduction="sum") 이다.
주의: 회색 픽셀과 BCE 의 바닥값. 막대 몸통은 밝기 0.85 이고 가장자리도 부드럽게 칠해 0 과 1 사이의 회색 픽셀이 많다. 엄밀히는 베르누이가 아니지만 실무에서 흔히 이렇게 쓴다. 대신 BCE 는 0 이 될 수 없다. 목표 \(x \in (0, 1)\) 에 대해 \(\text{BCE}(x, p)\) 를 \(p\) 로 미분하면 \(-\frac{x}{p} + \frac{1 - x}{1 - p}\) 이고 이것이 0 인 곳은 \(p = x\) 다. 그때의 값 \(-\big(x\log x + (1-x)\log(1-x)\big)\) 는 픽셀의 엔트로피다. 따라서 디코더가 목표를 정확히 맞혀도 그림당 회색 픽셀들의 엔트로피 합만큼 BCE 가 남는다. 코드가 계산한 바닥값은 그림당 약 80 내트(출력값 79.9)였고, 절반쯤은 밝기 0.85 인 막대 몸통에서, 나머지는 가장자리의 회색 픽셀에서 나온다.
가우시안 디코더와 MSE
색이 여러 가지인 자연 그림에서는 픽셀 값을 디코더 출력 \(\hat{x}_i\) 를 평균으로 하고 분산 \(s^2\) 이 고정된 가우시안으로 보기도 한다. Ha & Schmidhuber 는 이 방식(MSE)을 썼다. \(D = 4096\) 이다.
\(\log p_\theta(x \mid z) = \sum_{i=1}^{D}\log \mathcal{N}(x_i;\ \hat{x}_i,\ s^2) = \sum_{i=1}^{D}\left(-\tfrac{1}{2}\log(2\pi s^2) - \frac{(x_i - \hat{x}_i)^2}{2s^2}\right)\)
\(-\log p_\theta(x \mid z) = \frac{1}{2s^2}\,\lVert x - \hat{x}\rVert^2 + \frac{D}{2}\log(2\pi s^2)\)
둘째 항은 \(\theta\) 와 무관한 상수라 학습에 영향이 없고, 남는 것은 제곱 오차의 합에 \(\frac{1}{2s^2}\) 을 곱한 것이다. \(s\) 는 KL 항과의 가중치 비율을 정한다(아래 β-VAE).
재매개변수화 트릭
ELBO 를 경사 하강법으로 최대화하려면 \(\phi\) 에 대한 기울기가 필요하다. 그런데 재구성 항 \(\mathbb{E}_{z \sim q_\phi}[\log p_\theta(x \mid z)]\) 에서 \(\phi\) 는 \(z\) 를 어느 분포에서 뽑는가에 숨어 있다. z = torch.normal(mu, sigma) 같은 표본 추출은 \(\mu\) 를 조금 바꿨을 때 \(z\) 가 어떻게 변하는지 정의되지 않아 미분할 수 없고, 역전파가 그 줄에서 끊긴다.
가우시안은 표준 정규 표본 \(\epsilon\) 을 늘리고 옮기면 원하는 가우시안의 표본이 된다.
\(z \sim \mathcal{N}(\mu, \sigma^2) \quad\Longleftrightarrow\quad z = \mu + \sigma\,\epsilon,\quad \epsilon \sim \mathcal{N}(0, 1)\)
\(\mathbb{E}[\mu + \sigma\epsilon] = \mu\), \(\operatorname{Var}(\mu + \sigma\epsilon) = \sigma^2\) 이고 가우시안을 늘리고 옮겨도 가우시안이다. 무작위성은 \(\phi\) 와 무관한 \(\epsilon\) 에만 남고 \(z\) 는 \(\mu, \sigma\) 의 미분 가능한 함수가 된다. 이것이 재매개변수화 트릭(reparameterization trick)이다(Kingma & Welling, 2014). 계산 그래프로 보면, 재매개변수화 전에는 \(\mu, \sigma\) → 뽑기(\(z \sim \mathcal{N}\)) → \(f(z)\) 에서 기울기가 뽑기 노드에서 끊기고, 재매개변수화 후에는 \(\epsilon\) 이 옆에서 들어오는 \(\mu + \sigma\epsilon\) 노드를 지나 기울기가 \(\mu, \sigma\) 로 흐른다.
기댓값을 매기는 분포가 \(\mu, \sigma\) 와 무관해지므로 미분과 기댓값의 순서를 바꿀 수 있고, 연쇄 법칙에서 \(\frac{\partial z}{\partial \mu} = 1\), \(\frac{\partial z}{\partial \sigma} = \epsilon\) 이다.
\(\begin{align} \mathbb{E}_{z \sim \mathcal{N}(\mu,\sigma^2)}\big[f(z)\big] &= \mathbb{E}_{\epsilon \sim \mathcal{N}(0,1)}\big[f(\mu + \sigma\epsilon)\big] \\ \frac{\partial}{\partial \mu}\mathbb{E}_{\epsilon}\big[f(\mu + \sigma\epsilon)\big] &= \mathbb{E}_{\epsilon}\big[f'(\mu + \sigma\epsilon)\cdot 1\big] \\ \frac{\partial}{\partial \sigma}\mathbb{E}_\epsilon\big[f(\mu+\sigma\epsilon)\big] &= \mathbb{E}_{\epsilon}\big[f'(\mu + \sigma\epsilon)\cdot \epsilon\big] \end{align}\)
\(\nabla_{\mu,\sigma}\,\mathbb{E}\big[f(z)\big] \approx \frac{1}{S}\sum_{s=1}^{S} \nabla_{\mu,\sigma} f\big(\mu + \sigma\epsilon^{(s)}\big),\qquad \epsilon^{(s)} \sim \mathcal{N}(0,1)\)
각 표본의 기울기는 PyTorch 의 자동 미분이 계산한다. \(f(z) = z^2\) 으로 검산하면 \(\mathbb{E}[z^2] = \mu^2 + \sigma^2\) 이라 정답 기울기는 \(2\mu\), \(2\sigma\) 이고, 공식으로도 \(\mathbb{E}_\epsilon[2(\mu + \sigma\epsilon)] = 2\mu\), \(\mathbb{E}_\epsilon[2(\mu+\sigma\epsilon)\epsilon] = 2\mu\mathbb{E}[\epsilon] + 2\sigma\mathbb{E}[\epsilon^2] = 2\sigma\) 로 같다. 아래 코드는 VAE 처럼 \(\log\sigma\) 로 매개변수화했으므로 \(\frac{\partial}{\partial \log\sigma}(\mu^2 + \sigma^2) = 2\sigma\cdot\sigma = 2\sigma^2\) 이 정답이다.
import torch
torch.manual_seed(0)
mu = torch.tensor(1.5, requires_grad=True)
log_sigma = torch.tensor(0.0, requires_grad=True) # σ = e^0 = 1
eps = torch.randn(100_000) # ε ~ N(0, 1): μ, σ 와 상관없는 잡음
z = mu + log_sigma.exp() * eps # z = μ + σ ε ← 미분이 지나가는 길
loss = (z ** 2).mean() # E[z²] 의 몬테카를로 추정
loss.backward()
print(f"E[z^2] 추정 {loss.item():.3f} (정답 μ²+σ² = {1.5**2 + 1:.3f})")
print(f"dE/dμ 추정 {mu.grad.item():.3f} (정답 2μ = {2*1.5:.3f})")
print(f"dE/dlogσ 추정 {log_sigma.grad.item():.3f} (정답 2σ² = {2*1.0:.3f})")
E[z^2] 추정 3.245 (정답 μ²+σ² = 3.250)
dE/dμ 추정 2.995 (정답 2μ = 3.000)
dE/dlogσ 추정 1.998 (정답 2σ² = 2.000)
분포를 재매개변수화할 수 없을 때(예: 이산적인 선택)는 점수 함수(REINFORCE) 추정량 \(\nabla_\phi\mathbb{E}_{q_\phi}[f(z)] = \mathbb{E}_{q_\phi}[f(z)\,\nabla_\phi\log q_\phi(z)]\) 를 쓴다. 5장의 정책 기울기와 같은 식이다. 어떤 분포에도 쓸 수 있지만 분산이 훨씬 커서 가능하면 재매개변수화를 쓴다. 12장의 Dreamer 는 두 방법을 모두 쓴다.
구현: 합성곱 VAE
데이터
무작위 토크(\([-2, 2]\) 균등)로 진자를 200 에피소드 움직여 그림 40,200장을 모은다(collect_pixel_episodes, region collect). 시작 각도가 고르게 무작위라 모든 각도의 그림이 골고루 들어 있다. 돌려주는 배열은 obs (N, T+1, 64, 64) uint8, action (N, T, 1), reward (N, T), state (N, T+1, 3)이다. 정답 상태는 VAE 가 무엇을 배웠는지 확인하는 데만 쓰고 학습에는 쓰지 않는다.
출력 크기 계산
인코더는 크기 4, 보폭(stride) 2 인 합성곱(Convolution)을 네 번 거쳐 그림을 줄이고, 디코더는 전치 합성곱(transposed convolution)으로 다시 키운다. Ha & Schmidhuber 의 구조를 흑백 1채널로 바꾼 것이다.
\(\text{합성곱: } W_{\text{out}} = \left\lfloor \frac{W_{\text{in}} + 2P - K}{S} \right\rfloor + 1,\qquad \text{전치 합성곱: } W_{\text{out}} = (W_{\text{in}} - 1)\,S - 2P + K\)
- 합성곱 공식은 크기 \(K\) 인 창을 여백 \(P\) 를 포함한 가장자리에서 \(S\) 칸씩 옮길 때 창이 놓일 수 있는 자리의 수다.
- 전치 합성곱에서는 입력 칸 하나가 출력에 크기 \(K\) 의 무늬를 찍고 이웃한 입력 칸은 \(S\) 칸 떨어진 자리에 찍는다. 길이 \((W_{\text{in}}-1)S + K\) 에서 여백 \(P\) 만큼 양쪽을 잘라 낸다. 합성곱 공식을 \(W_{\text{in}}\) 에 대해 거꾸로 푼 것과 같다.
- 인코더(\(K = 4,\ S = 2,\ P = 0\)): \(64 \to 31 \to 14 \to 6 \to 2\). \(\tfrac{27}{2} = 13.5\) 는 내림해 13 이 된다. 마지막에 256채널 × 2 × 2 = 1024개의 숫자가 남는다.
- 디코더: \(z\) 를 1024개로 늘려 1×1 크기의 1024채널 그림으로 보고, 크기 5, 5, 6, 6 · 보폭 2 의 전치 합성곱으로 \(1 \to 5 \to 13 \to 30 \to 64\) 를 만든다.
| 층 | 설정 | 출력 모양 (채널, 높이, 폭) | 매개변수 수 |
| 입력 | 흑백 그림 | (1, 64, 64) | 없음 |
| 합성곱 1 | 32채널, 4×4, 보폭 2, ReLU | (32, 31, 31) | 1·32·16 + 32 = 544 |
| 합성곱 2 | 64채널, 4×4, 보폭 2, ReLU | (64, 14, 14) | 32·64·16 + 64 = 32,832 |
| 합성곱 3 | 128채널, 4×4, 보폭 2, ReLU | (128, 6, 6) | 64·128·16 + 128 = 131,200 |
| 합성곱 4 | 256채널, 4×4, 보폭 2, ReLU | (256, 2, 2) → 펼침 1024 | 128·256·16 + 256 = 524,544 |
| μ, log σ² | 완전 연결 1024 → 32 (두 개) | (32), (32) | 2 × (1024·32 + 32) = 65,600 |
| 디코더 입력 | 완전 연결 32 → 1024 | (1024, 1, 1) | 32·1024 + 1024 = 33,792 |
| 전치 합성곱 1 | 128채널, 5×5, 보폭 2, ReLU | (128, 5, 5) | 1024·128·25 + 128 = 3,276,928 |
| 전치 합성곱 2 | 64채널, 5×5, 보폭 2, ReLU | (64, 13, 13) | 128·64·25 + 64 = 204,864 |
| 전치 합성곱 3 | 32채널, 6×6, 보폭 2, ReLU | (32, 30, 30) | 64·32·36 + 32 = 73,760 |
| 전치 합성곱 4 | 1채널, 6×6, 보폭 2 (로짓) | (1, 64, 64) | 32·1·36 + 1 = 1,153 |
합성곱 층의 매개변수 수는 입력 채널 × 출력 채널 × 창 크기 + 출력 채널(편향)이다. 모두 더하면 약 435만 개이고 그중 75% 가 디코더의 첫 전치 합성곱에 몰려 있다.
모델
class ConvVAE(nn.Module):
"""합성곱 VAE. 입력 (B, 1, 64, 64) 값 범위 [0, 1] → 잠재 z (B, z_dim)."""
def __init__(self, z_dim: int = 32):
super().__init__()
self.z_dim = z_dim
# 인코더: 4×4 합성곱, 보폭 2 를 네 번. 64 → 31 → 14 → 6 → 2
self.enc = nn.Sequential(
nn.Conv2d(1, 32, 4, stride=2), nn.ReLU(), # (B, 32, 31, 31)
nn.Conv2d(32, 64, 4, stride=2), nn.ReLU(), # (B, 64, 14, 14)
nn.Conv2d(64, 128, 4, stride=2), nn.ReLU(), # (B, 128, 6, 6)
nn.Conv2d(128, 256, 4, stride=2), nn.ReLU(), # (B, 256, 2, 2)
nn.Flatten(), # (B, 1024)
)
self.fc_mu = nn.Linear(1024, z_dim) # 평균 μ
self.fc_logvar = nn.Linear(1024, z_dim) # 로그 분산 log σ²
# 디코더: z → 1024 → (1024, 1, 1) 에서 전치 합성곱으로 1 → 5 → 13 → 30 → 64
self.fc_dec = nn.Linear(z_dim, 1024)
self.dec = nn.Sequential(
nn.ConvTranspose2d(1024, 128, 5, stride=2), nn.ReLU(), # (B, 128, 5, 5)
nn.ConvTranspose2d(128, 64, 5, stride=2), nn.ReLU(), # (B, 64, 13, 13)
nn.ConvTranspose2d(64, 32, 6, stride=2), nn.ReLU(), # (B, 32, 30, 30)
nn.ConvTranspose2d(32, 1, 6, stride=2), # (B, 1, 64, 64) 로짓
)
def encode(self, x):
"""q_φ(z|x) 의 평균과 로그 분산."""
h = self.enc(x)
return self.fc_mu(h), self.fc_logvar(h)
def reparameterize(self, mu, logvar):
"""재매개변수화: z = μ + σ ⊙ ε, ε ~ N(0, I)."""
std = torch.exp(0.5 * logvar) # σ = exp(½ log σ²)
eps = torch.randn_like(std)
return mu + std * eps
def decode_logits(self, z):
"""p_θ(x|z) 의 베르누이 로짓. 픽셀 밝기 = sigmoid(로짓)."""
h = self.fc_dec(z).view(-1, 1024, 1, 1)
return self.dec(h)
def decode(self, z):
return torch.sigmoid(self.decode_logits(z))
def forward(self, x):
mu, logvar = self.encode(x)
z = self.reparameterize(mu, logvar)
return self.decode_logits(z), mu, logvar
-
fc_mu,fc_logvar는 같은 1024개 특징에서 두 개의 32차원 벡터를 낸다. \(q_\phi(z \mid x)\) 의 \(\mu\) 와 \(\log\sigma^2\) 이다. -
reparameterize는 \(\sigma = \exp(\tfrac{1}{2}\log\sigma^2) = (\sigma^2)^{1/2}\) 과 \(z = \mu + \sigma\odot\epsilon\) 을 계산한다.randn_like가 같은 모양의 \(\epsilon\) 을 뽑는다. -
decode_logits는 밝기가 아니라 로짓을 돌려준다. 시그모이드는 손실 함수 안에서 함께 계산한다. -
forward(인코드 → 재매개변수화 → 디코드)는 학습 때 쓰는 경로다. 10장에서 진짜 환경의 그림을 \(z\) 로 바꿀 때는 뽑지 않고 평균 \(\mu\) 를 쓴다. 9장의 MDN-RNN 학습에서는 저장해 둔 \(\mu, \log\sigma^2\) 에서 배치마다 \(z\) 를 새로 뽑는다. - 비교용
ConvAE는 같은 구조에서 확률(\(\sigma\), KL)만 뺀 것이고 BCE 합만으로 학습한다.
손실 함수
def vae_loss(logits, x, mu, logvar, beta: float = 1.0):
"""음의 ELBO (그림 한 장당 평균). 작을수록 좋다.
재구성 항: -log p_θ(x|z) = 픽셀마다 이진 교차 엔트로피(BCE)의 합
KL 항 : KL(N(μ, σ²) ‖ N(0, 1)) = ½ Σ_j (μ_j² + σ_j² − 1 − log σ_j²)
"""
batch = x.shape[0]
recon = F.binary_cross_entropy_with_logits(logits, x, reduction="sum") / batch
kl = 0.5 * torch.sum(mu.pow(2) + logvar.exp() - 1.0 - logvar) / batch
return recon + beta * kl, recon, kl
| 수식 | 코드 |
| \(-\log p_\theta(x \mid z) = \sum_i \text{BCE}(x_i, \text{sigmoid}(\ell_i))\) | |
| \(\tfrac{1}{2}\sum_j(\mu_j^2 + \sigma_j^2 - 1 - \log\sigma_j^2)\) | |
| 배치 평균 (그림 한 장당) | |
| \(-\text{ELBO} = \text{재구성} + \beta\cdot\text{KL}\) | |
- with_logits 를 쓰는 이유: 시그모이드를 먼저 계산한 뒤 로그를 취하면, 로짓이 +20 처럼 클 때 \(p\) 가 float32 에서 정확히 1 이 되어 \(\log(1-p) = -\infty\) 가 난다(로짓이 −100 아래면 \(p\) 가 정확히 0 이 되어 \(\log p\) 가 터진다).
binary_cross_entropy_with_logits는 \(\log\text{sigmoid}(\ell) = -\log(1 + e^{-\ell})\) 을 수치적으로 안정한 방법으로 직접 계산한다. - 픽셀에 대해 합(sum)을 쓰는 이유: 픽셀 평균을 내면 재구성 항이 4096분의 1 로 작아져 KL 항이 상대적으로 4096배 강해지고 그림이 흐려진다.
학습 루프와 실행 결과
def train_vae(frames, z_dim=32, epochs=10, batch_size=128, lr=1e-3, beta=1.0, device="cpu", log=print):
"""frames: (N, 64, 64) uint8. 학습한 VAE 와 에폭별 (재구성, KL) 기록을 돌려준다."""
model = ConvVAE(z_dim).to(device)
opt = torch.optim.Adam(model.parameters(), lr=lr)
n = len(frames)
history = []
for epoch in range(1, epochs + 1):
perm = np.random.permutation(n)
sums = np.zeros(3)
for i in range(0, n, batch_size):
x = to_float(frames[perm[i : i + batch_size]], device) # (B, 1, 64, 64)
logits, mu, logvar = model(x)
loss, recon, kl = vae_loss(logits, x, mu, logvar, beta)
opt.zero_grad()
loss.backward()
opt.step()
sums += np.array([loss.item(), recon.item(), kl.item()]) * len(x)
loss_e, recon_e, kl_e = sums / n
history.append((recon_e, kl_e))
log(f"epoch {epoch:2d} | -ELBO {loss_e:7.2f} = 재구성 {recon_e:7.2f} + KL {kl_e:5.2f}")
return model, history
하이퍼파라미터는 \(z\) 32차원, 10 에폭, 배치 128, Adam 학습률 1e-3, \(\beta = 1\) 이다. 에폭마다 순서를 섞고(permutation), uint8 그림을 255 로 나눠 [0, 1] 로 바꾸는 일은 to_float 가 한다. 명령행 인자는 --quick(에피소드 6개, 1 에폭), --episodes, --epochs, --z-dim, --beta, --seed, --fig-dir, --out 이다.
$ python ch08_vae.py
장치: cuda
에피소드 200개, 그림 40200장 모음 (10.3초)
epoch 1 | -ELBO 282.76 = 재구성 255.74 + KL 27.03
epoch 2 | -ELBO 112.65 = 재구성 94.57 + KL 18.08
epoch 3 | -ELBO 105.07 = 재구성 90.51 + KL 14.56
…
epoch 9 | -ELBO 95.57 = 재구성 85.34 + KL 10.23
epoch 10 | -ELBO 95.95 = 재구성 85.72 + KL 10.23
VAE 학습 97.1초
차원별 평균 KL (큰 순서 5개): z[26]=2.55, z[2]=2.35, z[6]=2.23, z[14]=1.23, z[28]=0.76
KL > 0.05 인 '살아 있는' 차원: 7개 / 32개
재구성 항(BCE)의 이론적 바닥값: 그림당 79.9 nats
그림 저장: figures
노트북 GPU 에서 VAE 학습 10 에폭은 단독으로 약 30초, 다른 학습과 GPU 를 나눠 쓴 위 실행에서는 약 97초가 걸렸고, 비교용 오토인코더까지 포함한 전체 실행은 2~4분이었다. CPU(4스레드)만 쓰면 한 스텝에 약 0.5초, VAE 와 오토인코더를 합쳐 약 50분이 걸린다. --epochs 3 으로 줄여도 그림 모양은 거의 같다.
결과 읽기
학습 곡선과 재구성
- 첫 에폭에 KL 이 27 내트까지 올랐다가 10 근처로 내려간다. 처음에는 잠재 공간을 넉넉히 써서 재구성부터 맞추고, 그 뒤 같은 재구성을 더 적은 정보로 하는 법을 찾는다.
- 재구성 항은 약 85 내트로 바닥값 약 80 내트에 가깝다. 남은 약 6 내트가 실제로 덜 맞힌 부분이다.
- KL 항은 그림 한 장이 \(z\) 에 담는 정보량의 위쪽 경계로 볼 수 있다. 10 내트는 \(10/\ln 2 \approx 14.4\) 비트이고, 각도를 \(2^{14} \approx 16{,}000\) 단계로 구분할 만큼의 정보다. 4096개 픽셀이 실은 14비트 남짓의 정보만 담고 있었던 셈이다.
- 재구성 비교(입력, VAE 가 평균 \(\mu\) 로 되살린 그림, 같은 구조의 오토인코더)에서 둘 다 각도를 정확히 되살린다.
- 그림: 에폭에 따른 재구성 항과 KL 항
- 그림: 입력 10장과 VAE·오토인코더의 재구성
쓰이는 차원 수
차원별 KL 이 0 이면 그 차원에 대해 모든 그림의 \(q_\phi(z_j \mid x)\) 가 \(\mathcal{N}(0, 1)\) 과 같다는 뜻이고, 그 차원은 그림에 대한 정보를 담지 않는다. VAE 는 KL 벌점 때문에 필요한 차원만 쓰고 나머지는 꺼 둔다. 32개 중 7개만 쓰였다(실행마다 6~8개).
자유도는 각도 하나인데 1개가 아닌 까닭은 두 가지다. 각도는 한 바퀴 돌면 제자리로 오는 원 위의 값이라 끊김 없이 표현하려면 최소 2차원이 필요하다. 또 인코더·디코더가 유한한 신경망이라 원을 깔끔한 원으로 펴지 못하고 몇 차원에 걸쳐 구부러진 고리로 표현한다. VAE 가 찾는 표현은 깔끔한 표현이 아니라 ELBO 를 높이는 표현이다.
- 그림: 잠재 차원 32개의 평균 KL
잠재 공간의 모양
그림 4,000장의 잠재 벡터를 주성분 분석(PCA)으로 2차원에 비추고 정답 각도로 칠하면, VAE 와 오토인코더 모두 각도를 따라 색이 연속으로 바뀌는 닫힌 고리가 나온다. 각도를 알려 주지 않았는데 그림만으로 데이터가 원 위에 있다는 것을 찾아낸 것이다. 차이는 크기다.
| VAE | 오토인코더 | |
| 성분 절댓값의 최대 | 약 3 | 약 36 |
| 주성분 축의 범위 | ±3 안쪽(\(\mathcal{N}(0, I)\) 가 주로 놓이는 범위) | ±60 안팎 |
VAE 쪽 고리가 꼬여 보이는 것은 7차원 남짓한 공간의 고리를 2차원에 비춘 그림자이기 때문이다.
잠재 공간 순회
정보가 가장 많은 세 차원을 하나씩 골라 다른 차원은 0 에 두고 그 차원만 −3 에서 3 까지 9단계로 바꾸며 디코딩한다(latent traversal). 한 차원을 움직이면 막대가 돌지만, 한 차원이 각도 하나에 깔끔하게 대응하지는 않는다. 중간에서 막대가 흐려지거나 두 각도가 겹쳐 보인다. 고리 모양의 데이터를 여러 축에 나눠 담았으므로 축 하나만 움직이면 고리에서 벗어난 곳을 지나기 때문이다. 각 차원이 사람이 이해할 수 있는 한 가지 성질만 맡게 하는 것을 분리 표현(disentanglement)이라고 하는데 보통의 VAE 는 이것을 보장하지 않는다.
- 그림: 잠재 차원 세 개의 순회
사전 분포에서 뽑기
\(z \sim \mathcal{N}(0, I)\) 를 뽑아 디코딩하면 VAE 는 거의 모든 \(z\) 에서 진자 그림을 만든다(가끔 흐리거나 두 막대가 겹친 그림도 나온다). 오토인코더는 크기가 맞지 않는 \(z\) 를 받아 의미 없는 얼룩을 만들고, 차원마다 실제 평균·표준편차에 맞춰 뽑아도(AE*) 여전히 이상한 그림이 많다. 오토인코더의 데이터는 넓은 공간 속 가느다란 고리 위에만 있는데 차원마다 따로 뽑은 점은 대부분 그 고리에서 벗어나기 때문이다. 9장의 M 모델은 잠재 공간에서 계속 새 \(z\) 를 뽑으며 미래를 상상하므로, 이 차이가 상상에 쓸 수 있는 눈과 그렇지 않은 눈을 가른다.
β-VAE 와 KL 가중치
손실의 KL 항에 가중치 \(\beta\) 를 붙인 것이 β-VAE다(Higgins 외, 2017).
\(\mathcal{L}_\beta = \mathbb{E}_{q_\phi}\big[-\log p_\theta(x \mid z)\big] + \beta\,D_{\mathrm{KL}}\big(q_\phi(z \mid x)\,\Vert\,p(z)\big)\)
- \(\beta \gt 1\): 정보를 더 적게 쓰도록 압박한다. 잠재 공간이 더 매끄럽고 분리 표현이 나오는 경향이 있지만(보장되지는 않는다) 재구성이 흐려진다.
- \(\beta \lt 1\): 재구성이 선명해지지만 잠재 공간이 오토인코더처럼 듬성해진다. \(\beta = 0\) 이면 (\(\sigma\) 가 있는) 오토인코더와 거의 같다.
\(\beta\) 는 가우시안 디코더의 분산 \(s^2\) 과 같은 역할을 한다. 가우시안 디코더의 음의 로그 가능도를 −ELBO 에 넣고 양변에 양수 \(2s^2\) 을 곱하면(최솟값의 위치는 바뀌지 않는다) 제곱 오차를 쓰는 β-VAE 와 같은 꼴이 된다.
\(\begin{align} -\text{ELBO} &= \frac{1}{2s^2}\,\mathbb{E}_{q_\phi}\big\lVert x - \hat{x}\big\rVert^2 + D_{\mathrm{KL}} + \text{상수} \\ 2s^2 \cdot (-\text{ELBO}) &= \mathbb{E}_{q_\phi}\big\lVert x - \hat{x}\big\rVert^2 + 2s^2\,D_{\mathrm{KL}} + \text{상수}' \end{align}\)
\(\beta = 2s^2\)
디코더가 픽셀 오차를 크게 가정할수록(\(s\) 가 클수록) 재구성을 덜 중요하게, KL 을 더 중요하게 본다. MSE 를 픽셀 평균으로 쓰느냐 픽셀 합으로 쓰느냐만 바꿔도 사실상 \(\beta\) 가 4096배 바뀐다.
사후 붕괴와 대처법
KL 항이 너무 강하거나 디코더가 너무 강하면 인코더가 모든 그림에 대해 \(q_\phi(z \mid x) = \mathcal{N}(0, I)\) 를 내고(KL = 0) 디코더는 \(z\) 를 무시한 채 평균적인 그림만 내는 상태에 빠질 수 있다. 이것이 사후 붕괴(posterior collapse)다. 이 장에서 꺼진 25개 차원은 차원 단위의 부분적인 붕괴이고 정보가 필요 없어서 꺼진 것이므로 문제가 아니다. 문제는 모든 차원이 꺼질 때다.
- KL 가중치 서서히 올리기(KL annealing)
- 처음 몇 천 스텝은 \(\beta\) 를 0 에서 1 로 천천히 올려 먼저 재구성을 배우게 한다.
- 자유 비트(free bits), KL 허용치
- KL 이 정해진 값 \(c\) 보다 작으면 벌점을 주지 않는다. 손실에 \(\max(D_{\mathrm{KL}}, c)\) 를 쓴다. \(D_{\mathrm{KL}} \lt c\) 인 구간에서는 이 항의 기울기가 0 이라 KL 을 0 까지 짜내려는 압력이 사라진다. 11장의 자유 내트(free nats)와 같은 기법이다. Ha & Schmidhuber 의 공개 코드는 차원당 0.5 내트, 32차원 합계 16 내트의 허용치를 KL 합계에 걸었고(
kl_tolerance. 논문 본문에는 나오지 않는다), 12장의 DreamerV3 는 1 내트의 자유 비트를 쓴다. - 차원별 KL 지켜보기
- 차원별 KL 막대그래프를 학습 중에 찍으면 정보를 담은 차원 수가 0 으로 무너지는지 바로 알 수 있다.
9장을 위한 준비물
코드는 실행이 끝나면 두 파일을 남기고 9·10장은 여기서 출발한다.
| 파일 | 내용 | 쓰는 곳 |
| | 학습한 VAE ( | 9장: 에피소드를 \(z\) 시퀀스로 바꾸기, 꿈 그림 그리기. 10장: 진짜 환경의 그림을 \(z\) 로 |
| | 200 에피소드의 그림·행동·보상·(확인용) 정답 상태 | 9장: MDN-RNN 학습 데이터 |
그림 한 장을 32개의 숫자로 요약할 수 있게 됐지만 그림 한 장으로는 진자가 얼마나 빨리 도는지 알 수 없다. 9장은 지나간 장면을 기억하며 다음 \(z\) 를 예측하는 기억(MDN-RNN)을 만든다.
정리
- 그림(4096차원)은 실제로는 훨씬 낮은 차원에 놓여 있다. World Model 은 그림을 작은 잠재 벡터 \(z\) 로 압축해 그 공간에서 미래를 예측한다.
- 오토인코더는 재구성은 잘하지만 잠재 공간이 어디에 어떤 모양으로 있는지 몰라 새 \(z\) 를 뽑아 쓸 수 없다.
- VAE 는 생성 과정 \(z \sim \mathcal{N}(0, I),\ x \sim p_\theta(x \mid z)\) 를 가정하고, 계산할 수 없는 \(\log p_\theta(x)\) 대신 ELBO 를 최대화한다.
- \(\log p_\theta(x) = \text{ELBO} + D_{\mathrm{KL}}(q_\phi(z\mid x)\,\Vert\,p_\theta(z\mid x))\) 이고, ELBO = 재구성 항 − \(D_{\mathrm{KL}}(q_\phi(z\mid x)\,\Vert\,\mathcal{N}(0,I))\) 이다.
- KL 항의 닫힌 꼴은 \(\tfrac{1}{2}\sum_j(\mu_j^2 + \sigma_j^2 - 1 - \log\sigma_j^2)\) 이다. 베르누이 디코더는 BCE, 고정 분산 가우시안 디코더는 MSE 가 된다.
- 재매개변수화 \(z = \mu + \sigma\odot\epsilon\) 으로 무작위 표본을 거쳐서도 기울기를 흘린다.
- 진자 VAE 는 각도를 닫힌 고리로 찾아냈고, 32차원 중 7개 안팎만 썼으며, \(\mathcal{N}(0, I)\) 에서 뽑은 \(z\) 로 그럴듯한 그림을 만든다.
확인 문제
- 1. KL 계산
- \(q = \mathcal{N}(1, 0.25)\) (\(\mu = 1\), \(\sigma = 0.5\))일 때 \(D_{\mathrm{KL}}(q\,\Vert\,\mathcal{N}(0,1))\) 은 \(\tfrac{1}{2}(1 + 0.25 - 1 + 1.386) = \tfrac{1}{2}(1.636) \approx 0.818\) 내트다.
- 2. ELBO 와 간격
- \(\log p_\theta(x) = -90\), ELBO 가 \(-95\) 이면 \(D_{\mathrm{KL}}(q_\phi(z\mid x)\,\Vert\,p_\theta(z\mid x)) = -90 - (-95) = 5\) 다. 인코더만 학습해 ELBO 를 \(-92\) 로 올리면 \(\log p_\theta(x)\) 는 그대로이므로 KL 이 \(5 \to 2\) 로 줄어든다.
- 3. 재매개변수화
- \(f(z) = 3z + 1\) 이면 \(\mathbb{E}[f(z)] = 3\mu + 1\) 이므로 \(\partial/\partial\mu = 3\), \(\partial/\partial\sigma = 0\) 이다. 공식으로도 \(f'(z) = 3\) 에서 \(\mathbb{E}[3] = 3\), \(\mathbb{E}[3\epsilon] = 0\) 으로 같다. 선형 함수의 기댓값은 분산과 무관하다.
- 4. 출력 크기
- 입력이 96×96 이면 인코더를 거쳐 \(96 \to 47 \to 22 \to 10 \to 4\) 가 되고 펼친 길이는 256 × 4 × 4 = 4096 이다.
fc_mu와fc_logvar의 입력 크기를 1024 에서 4096 으로 바꿔야 한다. 디코더는 그대로 두면 여전히 64×64 를 내므로 96×96 을 되살리려면 전치 합성곱도 고쳐야 한다. - 5. 손실 크기의 함정
- 재구성 손실을 픽셀 합 대신 픽셀 평균으로 바꾸면(KL 은 그대로) 손실 전체에 4096 을 곱해 볼 때 "재구성(합) + 4096 × KL" 과 같다. \(\beta = 4096\) 인 β-VAE 가 되어 대부분의 차원이 꺼지고 그림이 크게 흐려진다.
vae_loss에서reduction="mean"으로만 바꾸면 배치 크기로도 한 번 더 나뉘므로 뒤의/ batch를 함께 지워야 이 계산과 같아진다. - 6. β 바꿔 보기
-
python ch08_vae.py --beta 4와--beta 0.25로 차원별 KL 과 사전 분포 표본을 비교한다. \(\beta\) 가 클수록 살아 있는 차원 수가 줄고 표본이 흐려지며, 작을수록 차원이 늘고 이상한 표본이 많아질 것으로 원문은 예상한다.
See also
- World Models:Tutorial
- World Models
- VAE
- Autoencoder
- Recurrent World Models Facilitate Policy Evolution
- Maximum likelihood estimation
- Bayes' theorem
- Cross entropy
- Normal distribution
- Convolution arithmetic
Favorite site
- WorldModels:Tutorial
- WorldModels:Tutorial:01-WhatIsWorldModel
- WorldModels:Tutorial:02-Probability
- WorldModels:Tutorial:03-InformationTheory
- WorldModels:Tutorial:05-ReinforcementLearning
- WorldModels:Tutorial:06-FirstWorldModel
- WorldModels:Tutorial:07-PlanningMPC
- WorldModels:Tutorial:09-MDN-RNN
- WorldModels:Tutorial:10-HaWorldModels
- WorldModels:Tutorial:11-RSSM-PlaNet