생성 모델: VAE, GAN, 확산 모델
그림을 만드는 AI의 세 갈래인 VAE, GAN, 확산 모델을 PyTorch로 직접 만들어 같은 데이터에서 겨뤄요. 압축했다 풀어내는 VAE가 왜 흐릿한지, 위조범과 감별사의 게임인 GAN이 아담 설정 하나에 무더기 절반을 놓치는 모습, 잡음을 한 걸음씩 걷어 내는 확산 모델이 평범한 회귀만으로 안정적으로 배우는 원리를 수식과 숫자로 확인하고, 글로 그림을 그리는 실제 모델의 구조와 생성 AI의 책임까지 정리해요.
GPT는 다음 토큰을 하나씩 예측하며 글을 생성했어요. 그림도 같은 방식으로 픽셀을 하나씩 만들 수 있지만, 512×512 그림이면 숫자가 78만 개가 넘어서 너무 느려요. 그래서 그림 생성에는 다른 아이디어들이 발전했어요. 이번 강의에서는 그 세 갈래인 VAE, GAN, 확산 모델을 직접 만들어 같은 데이터에서 겨뤄 봐요.
생성 모델이 하는 일
지금까지의 분류 모델은 그림을 보고 "고양이"라고 답했어요. 생성 모델은 반대로, 고양이 그림 수만 장을 보고 고양이 그림들이 따르는 분포 를 배운 뒤, 그 분포에서 새 그림을 뽑아요. 학습 데이터를 베끼는 게 아니라, 학습 데이터와 같은 분포에서 나왔을 법한 새로운 표본을 만드는 거예요.
생성 모델을 평가할 때는 두 가지를 함께 봐야 해요.
- 품질: 만든 것이 진짜 같은가?
- 다양성: 진짜 데이터의 여러 종류를 골고루 만드는가? 고양이만 잘 그리고 강아지는 못 그리면 안 되죠.
실제 그림 생성 모델은 진짜 그림과 생성 그림의 특징 통계를 비교하는 FID 같은 지표로 재요. 여기서는 결과를 정확한 숫자로 재기 위해 그림 대신 2차원 점으로 연습해요. 반지름 2인 원 위에 점 8무더기가 있는 데이터예요. 품질은 "무더기 근처에 떨어진 점의 비율", 다양성은 "덮은 무더기 수"로 잴게요.
import math
import torch
from torch import nn
import torch.nn.functional as F
CENTERS = torch.tensor([[2 * math.cos(2 * math.pi * k / 8), 2 * math.sin(2 * math.pi * k / 8)] for k in range(8)])
def sample_data(n, g): # 반지름 2인 원 위의 점 8무더기
k = torch.randint(0, 8, (n,), generator=g)
return CENTERS[k] + 0.1 * torch.randn(n, 2, generator=g)
def evaluate(x):
dist, idx = torch.cdist(x, CENTERS).min(1) # 가장 가까운 무더기 중심까지 거리
good = dist < 0.3 # 표준편차의 3배 안이면 "진짜 같은 점"
counts = torch.bincount(idx[good], minlength=8)
covered = int((counts >= 0.25 * len(x) / 8).sum()) # 제 몫의 1/4 이상 받은 무더기 수
return f"무더기 근처 {good.float().mean().item():.1%}, 덮은 무더기 {covered}/8"
def mlp(i, o, h=128, depth=2, act=nn.ReLU):
layers, d = [], i
for _ in range(depth):
layers += [nn.Linear(d, h), act()]
d = h
return nn.Sequential(*layers, nn.Linear(d, o))
g = torch.Generator().manual_seed(0)
print("진짜 데이터:", evaluate(sample_data(2000, g)))
print("그냥 잡음:", evaluate(1.5 * torch.randn(2000, 2, generator=g)))
진짜 데이터: 무더기 근처 98.8%, 덮은 무더기 8/8
그냥 잡음: 무더기 근처 7.1%, 덮은 무더기 0/8
진짜 데이터도 100%가 아니에요. 2차원 정규분포에서 표준편차 3배 안에 들 확률이 라서, 98.8%가 우리가 바랄 수 있는 최고 점수예요. 아무렇게나 뿌린 잡음은 7.1%예요.
VAE: 압축했다가 풀어내기
VAE(변분 오토인코더, 2013)는 두 부분으로 이뤄져요. 인코더는 데이터 를 작은 잠재 변수 로 압축하고, 디코더는 에서 를 복원해요. 여기까지는 평범한 압축기인데, VAE에는 한 가지 장치가 더 있어요. 들이 표준 정규분포 모양으로 퍼지도록 강제해요. 그러면 나중에 정규분포에서 아무 나 뽑아 디코더에 넣기만 하면 새 데이터가 나와요.
인코더는 하나가 아니라 분포(평균 와 분산 )를 내요. 학습 목표는 데이터의 로그 가능도의 아래 경계(ELBO)를 최대로 하는 거예요.
정보 이론 강의의 KL 발산이 여기 나와요. 두 정규분포 사이의 KL은 공식으로 바로 계산돼요.
남은 문제는 "분포에서 뽑기"가 미분이 안 된다는 거예요. 그래서 (은 표준 정규분포에서 뽑음)으로 바꿔 써요. 무작위성은 이 맡고, 와 로는 기울기가 흘러요. 이것을 재매개변수화 기법이라고 해요.
torch.manual_seed(0)
enc, dec = mlp(2, 4), mlp(2, 2) # 인코더는 평균 2개와 로그 분산 2개를 내요
opt = torch.optim.Adam([*enc.parameters(), *dec.parameters()], lr=1e-3)
g = torch.Generator().manual_seed(1)
for step in range(4000):
x = sample_data(256, g)
mu, logvar = enc(x).chunk(2, dim=1)
z = mu + torch.exp(0.5 * logvar) * torch.randn_like(mu) # 재매개변수화
recon = ((dec(z) - x) ** 2).sum(1).mean() / (2 * 0.1 ** 2) # 복원 오차
kl = 0.5 * (mu ** 2 + logvar.exp() - logvar - 1).sum(1).mean() # 사전 분포와의 KL
loss = recon + kl
opt.zero_grad()
loss.backward()
opt.step()
with torch.no_grad():
vae_samples = dec(torch.randn(2000, 2, generator=torch.Generator().manual_seed(9)))
print(round(recon.item(), 2), round(kl.item(), 2), evaluate(vae_samples))
1.06 3.48 무더기 근처 56.1%, 덮은 무더기 8/8
복원 오차를 표준편차 0.1의 정규분포 가능도로 계산했어요(제곱 오차를 로 나눈 것). 결과는 8무더기를 모두 덮었지만, 무더기 근처는 56%뿐이에요. 나머지는 무더기 사이에 흩어졌어요. VAE의 대표적인 약점인 흐릿함이에요. 이유는 두 가지예요.
- 잠재 공간의 정규분포는 매끄럽게 이어져 있는데, 데이터는 8개로 뚝뚝 떨어져 있어요. 잠재 공간에서 두 무더기 사이에 있는 는 디코더를 거쳐 무더기 사이의 점이 돼요.
- 제곱 오차로 학습한 디코더는 확실하지 않을 때 평균을 내요. 그림이라면 여러 그럴듯한 그림의 평균, 즉 흐릿한 그림이 돼요.
대신 VAE는 학습이 안정적이고, 생성이 한 번에 끝나고, 잠재 공간이 매끄러워서 두 데이터 사이를 자연스럽게 이어 가는 데 좋아요. 뒤에서 볼 최신 그림 생성 모델에서도 압축기로 쓰여요.
GAN: 위조범과 감별사의 게임
GAN(생성적 적대 신경망, 2014)은 두 신경망을 겨루게 해요. 생성자 는 잡음 를 받아 가짜를 만들고, 판별자 는 진짜와 가짜를 가려내요. 위조범과 감별사가 서로를 이기려고 실력을 키우는 구조예요.
생성자를 고정하면 가장 좋은 판별자는 이렇게 정해져요.
생성자가 완벽해져서 가 되면, 판별자는 어디서나 , 즉 동전 던지기밖에 못 해요. 이때 판별자의 손실(진짜와 가짜에 대한 이진 교차 엔트로피의 합)은 , 생성자의 손실은 이에요. 이 숫자를 기억하고 실험해 볼게요. 아담 옵티마이저의 첫 번째 모멘텀 계수 만 0.5와 0.9(기본값)로 바꿔 두 번 학습해요.
def train_gan(beta1, steps=4000):
torch.manual_seed(0)
G = mlp(2, 2) # 생성자: 잡음 → 점
D = mlp(2, 1, act=lambda: nn.LeakyReLU(0.2)) # 판별자: 점 → 진짜일 점수
optG = torch.optim.Adam(G.parameters(), lr=1e-3, betas=(beta1, 0.999))
optD = torch.optim.Adam(D.parameters(), lr=1e-3, betas=(beta1, 0.999))
g = torch.Generator().manual_seed(1)
ones, zeros = torch.ones(256, 1), torch.zeros(256, 1)
for step in range(1, steps + 1):
real = sample_data(256, g)
fake = G(torch.randn(256, 2, generator=g))
d_loss = (F.binary_cross_entropy_with_logits(D(real), ones)
+ F.binary_cross_entropy_with_logits(D(fake.detach()), zeros))
optD.zero_grad()
d_loss.backward()
optD.step()
g_loss = F.binary_cross_entropy_with_logits(D(fake), ones) # 판별자를 속이면 낮아져요
optG.zero_grad()
g_loss.backward()
optG.step()
if step % 1000 == 0:
with torch.no_grad():
s = G(torch.randn(2000, 2, generator=torch.Generator().manual_seed(9)))
print(f" {step}걸음: 판별자 손실 {d_loss.item():.3f}, 생성자 손실 {g_loss.item():.3f}, {evaluate(s)}")
return G
print("beta1 = 0.5")
G = train_gan(0.5)
print("beta1 = 0.9 (아담 기본값)")
_ = train_gan(0.9)
beta1 = 0.5
1000걸음: 판별자 손실 1.297, 생성자 손실 0.809, 무더기 근처 75.2%, 덮은 무더기 8/8
2000걸음: 판별자 손실 1.355, 생성자 손실 0.797, 무더기 근처 88.7%, 덮은 무더기 8/8
3000걸음: 판별자 손실 1.383, 생성자 손실 0.727, 무더기 근처 94.0%, 덮은 무더기 8/8
4000걸음: 판별자 손실 1.392, 생성자 손실 0.685, 무더기 근처 91.5%, 덮은 무더기 8/8
beta1 = 0.9 (아담 기본값)
1000걸음: 판별자 손실 0.961, 생성자 손실 1.262, 무더기 근처 6.2%, 덮은 무더기 0/8
2000걸음: 판별자 손실 0.910, 생성자 손실 1.441, 무더기 근처 56.7%, 덮은 무더기 5/8
3000걸음: 판별자 손실 0.883, 생성자 손실 1.440, 무더기 근처 75.5%, 덮은 무더기 5/8
4000걸음: 판별자 손실 0.924, 생성자 손실 1.475, 무더기 근처 80.7%, 덮은 무더기 4/8
에서는 판별자 손실이 이론의 균형값 1.386으로, 생성자 손실이 0.693으로 다가가며 8무더기를 모두 선명하게(91.5%) 만들었어요. VAE보다 훨씬 선명해요.
그런데 아담의 기본값 0.9로 바꾸기만 했는데 결과가 무너졌어요. 판별자 손실이 0.9 근처에 머문 건 판별자가 계속 이기고 있다는 뜻이고, 4,000걸음 뒤에도 8무더기 중 4개만 만들어요. 생성자가 판별자를 속이기 쉬운 몇 가지 출력에만 매달리고 나머지 종류를 포기하는 이 현상을 모드 붕괴라고 해요. 남은 무더기 근처 비율 80.7%만 보면 괜찮아 보이지만, 다양성을 함께 재야 문제가 보여요. 2015년의 DCGAN 논문도 에서는 학습이 흔들려서 0.5로 낮췄다고 보고했어요.
GAN은 이렇게 선명하지만 까다로워요. 두 신경망의 균형이 조금만 어긋나도 진동하거나 무너지고, 손실 값만 보고는 품질을 판단하기 어려워서 결과물을 직접 재 봐야 해요. 학습을 안정시키는 기법(손실 함수 변형, 판별자의 기울기 제한 등)이 수없이 연구된 이유예요.
확산 모델: 잡음을 한 걸음씩 걷어 내기
확산 모델(2015년 제안, 2020년 DDPM으로 실용화)의 아이디어는 거꾸로 생각하기예요. 데이터에 잡음을 조금씩 더하는 건 쉬워요. 충분히 더하면 결국 순수한 잡음이 돼요. 그렇다면 잡음을 조금씩 걷어 내는 법을 배우면, 순수한 잡음에서 출발해 데이터를 만들 수 있지 않을까요?
앞으로: 잡음 더하기
걸음 마다 만큼 잡음을 섞어요. 좋은 성질이 있어서, 중간 걸음을 거치지 않고 원래 데이터에서 바로 번째 걸음의 모습을 만들 수 있어요.
T = 100
betas = torch.linspace(1e-4, 0.2, T) # 걸음마다 더할 잡음의 양
alphas = 1 - betas
abar = torch.cumprod(alphas, 0) # 원래 신호가 남은 비율의 제곱
g = torch.Generator().manual_seed(3)
x0 = sample_data(2000, g)
for t in (1, 11, 31, 61, 100):
xt = abar[t - 1].sqrt() * x0 + (1 - abar[t - 1]).sqrt() * torch.randn(2000, 2, generator=g)
print(t, f"신호 비율 {abar[t - 1].sqrt().item():.3f},", evaluate(xt))
1 신호 비율 1.000, 무더기 근처 98.7%, 덮은 무더기 8/8
11 신호 비율 0.945, 무더기 근처 31.8%, 덮은 무더기 8/8
31 신호 비율 0.618, 무더기 근처 7.1%, 덮은 무더기 0/8
61 신호 비율 0.145, 무더기 근처 6.5%, 덮은 무더기 0/8
100 신호 비율 0.005, 무더기 근처 4.6%, 덮은 무더기 0/8
31걸음이면 이미 그냥 잡음(7.1%)과 구별이 안 되고, 100걸음에서는 원래 신호가 0.5%만 남은 거의 순수한 정규분포 잡음이에요.
거꾸로: 잡음 걷어 내기
이제 신경망 에게 "이 점에 섞인 잡음이 무엇이었는지" 맞히게 해요. 학습 데이터는 무한히 만들 수 있어요. 진짜 점 를 뽑고, 걸음 와 잡음 을 뽑아 위 공식으로 를 만들면, 정답 을 이미 알고 있으니까요. 손실은 평범한 제곱 오차 회귀예요.
생성할 때는 순수한 잡음 에서 출발해, 예측한 잡음을 조금 빼고 약간의 무작위성을 다시 더하는 걸음을 번 반복해요.
def t_embed(t): # 몇 번째 걸음인지 여러 주파수의 사인·코사인으로
freqs = torch.exp(torch.linspace(0, math.log(100), 8))
a = t[:, None].float() / T * freqs[None]
return torch.cat([a.sin(), a.cos()], 1)
torch.manual_seed(0)
eps_net = mlp(2 + 16, 2, depth=3, act=nn.SiLU) # (잡음 섞인 점, 걸음) → 섞인 잡음 예측
opt = torch.optim.Adam(eps_net.parameters(), lr=2e-3) # 아담 기본값 그대로
sched = torch.optim.lr_scheduler.CosineAnnealingLR(opt, 6000)
g = torch.Generator().manual_seed(1)
for step in range(6000):
x0 = sample_data(512, g)
t = torch.randint(0, T, (512,), generator=g)
noise = torch.randn(512, 2, generator=g)
xt = abar[t].sqrt()[:, None] * x0 + (1 - abar[t]).sqrt()[:, None] * noise
loss = ((eps_net(torch.cat([xt, t_embed(t)], 1)) - noise) ** 2).mean() # 그냥 회귀
opt.zero_grad()
loss.backward()
opt.step()
sched.step()
@torch.no_grad()
def diffusion_sample(n, seed=9):
g = torch.Generator().manual_seed(seed)
x = torch.randn(n, 2, generator=g) # 순수한 잡음에서 출발
for i in reversed(range(T)):
eps = eps_net(torch.cat([x, t_embed(torch.full((n,), i))], 1))
x = (x - betas[i] / (1 - abar[i]).sqrt() * eps) / alphas[i].sqrt() # 잡음을 조금 걷어 내고
if i > 0:
x = x + betas[i].sqrt() * torch.randn(n, 2, generator=g) # 약간의 무작위성을 다시
return x
print(round(loss.item(), 3), evaluate(diffusion_sample(2000)))
0.247 무더기 근처 91.4%, 덮은 무더기 8/8
8무더기를 모두, GAN만큼 선명하게(91.4%) 만들었어요. 그것도 GAN을 무너뜨렸던 아담 기본값 그대로요. 적대적인 게임이 없고 정답이 있는 회귀라서 학습이 안정적이에요. 손실이 0이 되지 않는 건 정상이에요. 같은 가 서로 다른 여러 에서 나올 수 있어서, 신경망은 그 평균을 맞힐 수밖에 없거든요.
잡음 예측에는 깊은 의미가 있어요. 예측한 잡음의 반대 방향은 데이터가 더 그럴듯해지는 방향, 즉 로그 확률 밀도의 기울기(스코어)에 비례해요. 확산 모델은 미적분 트랙의 경사 하강법처럼, 잡음 속에서 "더 그럴듯한 쪽"으로 조금씩 걸어가며 데이터를 찾아내는 셈이에요.
대가는 속도예요. VAE와 GAN은 신경망을 한 번 통과하면 끝이지만, 확산 모델은 점 하나를 만드는 데 신경망을 번 불렀어요.
셋을 나란히 놓으면
| 모델 | 무더기 근처 (품질) | 덮은 무더기 (다양성) | 생성할 때 신경망 호출 | 학습 |
|---|---|---|---|---|
| 진짜 데이터 | 98.8% | 8/8 | ||
| VAE | 56.1% | 8/8 | 1번 | 안정적 |
| GAN () | 91.5% | 8/8 | 1번 | 설정에 민감 |
| GAN () | 80.7% | 4/8 | 1번 | 모드 붕괴 |
| 확산 | 91.4% | 8/8 | 100번 | 안정적 |
장난감 예제라 순위를 일반화하면 안 되지만, 각자의 성격은 실제 그림에서도 같아요. 2021년에는 "확산 모델이 그림 생성에서 GAN을 이긴다"는 제목의 논문이 나왔고, 그 뒤 글로 그림을 그리는 모델 대부분이 확산 모델 계열이 됐어요.
실제 그림 생성 모델은 무엇이 다를까
- 압축한 공간에서 확산하기: 512×512×3 그림의 78만여 개 숫자에 바로 확산을 하면 너무 무거워요. 2022년에 나온 잠재 확산 모델은 먼저 VAE로 그림을 64×64×4 크기(48배 적은 숫자)로 압축하고, 그 잠재 공간에서 확산을 한 뒤, 마지막에 디코더로 그림을 복원해요. VAE와 확산이 손을 잡은 구조예요.
- 글로 조건 걸기: 글을 임베딩으로 바꿔 어텐션으로 신경망에 넣어서, "무엇을 그릴지" 알려 줘요. 여기에 분류기 없는 안내라는 기법을 더해요(아래에서 설명해요).
- 신경망 구조: 초기에는 그림 처리에 강한 U-Net을 썼고, 요즘은 그림 조각을 토큰처럼 다루는 트랜스포머를 많이 써요. LLM 트랙의 트랜스포머가 그림에도 쓰이는 거예요.
- 빠른 생성: 수십에서 천 번에 이르던 걸음 수를 줄이는 샘플링 방법과, 많은 걸음을 몇 걸음으로 압축하는 증류 기법이 계속 나오고 있어요. 확산과 가까운 흐름 맞추기(flow matching) 방식도 최근 모델들에 널리 쓰여요.
- 그림 너머로: 같은 원리가 영상, 음성, 음악, 3차원 모양, 단백질 구조 생성에도 쓰여요.
- VAE와 GAN의 쓰임: VAE는 잠재 확산의 압축기로, GAN은 속도가 중요한 곳(실시간 변환, 해상도 높이기)과 디코더를 선명하게 다듬는 보조 손실로 여전히 쓰여요.
분류기 없는 안내는 글 조건이 있을 때와 없을 때의 잡음 예측을 둘 다 구해서, 그 차이를 배 키워요.
이면 글 조건만 쓴 예측 그대로이고, 를 키우면 글을 더 충실히 따르는 대신 다양성이 줄어요. 품질과 다양성의 줄타기가 여기서도 나와요.
생성 모델과 책임
생성 모델은 진짜와 구별하기 어려운 결과를 만들어서, 책임 있게 쓰는 일이 특히 중요해요.
- 딥페이크: 실제 사람의 얼굴과 목소리를 동의 없이 합성하는 것은 사생활 침해, 사기, 허위 정보로 이어져요. 많은 나라가 법으로 규제하고 있어요.
- 학습 데이터의 권리: 인터넷의 그림과 글을 학습에 쓰는 것이 저작권과 창작자의 동의 측면에서 괜찮은지는 여러 나라에서 소송과 논의가 이어지는 문제예요. 직접 모델을 학습시킨다면 데이터의 이용 조건을 확인해요.
- 출처 표시: 생성물에 보이지 않는 워터마크를 넣거나, 콘텐츠가 어떻게 만들어졌는지 기록하는 표준(C2PA 같은 것)을 쓰는 움직임이 있어요. 다만 생성물을 완벽하게 가려내는 탐지기는 아직 없어요.
- 편향: 앞 강의에서 본 편향은 그림에서도 나타나요. "의사"를 그리라고 하면 특정 성별이나 인종으로 쏠리는 식이에요.
실습
- VAE의 복원 오차에서 0.1을 0.05와 0.3으로 바꿔 보세요. 품질과 다양성이 어떻게 바뀌나요? 왜 그럴까요?
- GAN의 학습률을 1e-4와 3e-3으로 바꿔 보세요( 그대로). 어느 쪽이 빨리, 어느 쪽이 안정적으로 수렴하나요?
- 확산 모델의 걸음 수
T를 20으로 줄이면 품질이 어떻게 되나요? 이때betas의 최댓값도 함께 키워야 하는 이유는? diffusion_sample에서 무작위성을 다시 더하는 줄을 빼면 어떤 점들이 나오나요?- 학습 데이터에서 무더기 하나를 빼고 세 모델을 학습시켜 보세요. 빠진 무더기를 만들어 내는 모델이 있나요?
자주 하는 실수
- 품질만 보고 다양성을 안 보기. 모드 붕괴는 품질 숫자만으로는 안 보여요.
- GAN의 손실 값을 품질로 읽기. 손실은 두 신경망의 균형을 보여 줄 뿐이에요. 결과물을 재요.
- 몇 장만 골라 보고 판단하기. 잘 나온 그림만 골라 보여 주면 실력이 부풀려져요. 많이 뽑아 숫자로 재요.
- 확산 모델의 생성 비용을 잊기. 걸음 수만큼 신경망을 불러서, 실시간 서비스라면 걸음 줄이기와 증류를 고려해요.
- 데이터와 생성물의 권리를 확인하지 않기. 학습 데이터의 이용 조건과 생성물 사용 규정을 먼저 봐요.
점검 문제
- 생성 모델을 평가할 때 함께 봐야 하는 두 가지는?
- VAE에서 재매개변수화 기법이 필요한 이유는?
- 실험에서 VAE의 점들이 무더기 사이에 흩어진 이유는?
- GAN의 생성자가 완벽해지면 판별자의 출력과 손실은 어떻게 되나요?
- 모드 붕괴란 무엇이고, 실험의 어떤 숫자에서 드러났나요?
- 확산 모델의 신경망은 무엇을 맞히도록 학습하나요? 손실 함수는?
- 확산 모델의 생성이 GAN보다 느린 이유는?
- 잠재 확산 모델이 그림을 압축한 공간에서 확산을 하는 이유는?
정답
- 품질(진짜 같은가)과 다양성(여러 종류를 골고루 만드는가)이에요.
- 분포에서 뽑는 과정은 미분할 수 없어서예요. 으로 바꾸면 무작위성은 이 맡고 , 로 기울기가 흘러 학습할 수 있어요.
- 매끄러운 정규분포 잠재 공간에서 무더기 사이의 가 무더기 사이의 점으로 복원되고, 제곱 오차로 학습한 디코더가 불확실할 때 평균을 내기 때문이에요.
- 판별자는 어디서나 을 출력하고, 판별자 손실은 , 생성자 손실은 이 돼요.
- 생성자가 판별자를 속이기 쉬운 일부 종류만 만들고 나머지를 포기하는 현상이에요. 로 학습한 GAN이 8무더기 중 4개만 덮은 것에서 드러났어요.
- 에 섞인 잡음 을 맞혀요. 손실은 예측한 잡음과 실제 잡음의 제곱 오차예요.
- 점 하나(그림 한 장)를 만들 때 잡음을 걷어 내는 걸음 수만큼, 여기서는 100번 신경망을 불러야 하기 때문이에요.
- 다뤄야 할 숫자가 수십 배 줄어 계산이 훨씬 가벼워지기 때문이에요. 세밀한 픽셀 복원은 VAE 디코더에게 맡겨요.
다음 강의
이것으로 LLM과 생성형 AI 트랙을 마쳐요. 프롬프트에서 시작해 토큰, 트랜스포머, 정렬, RAG, 파인튜닝, 에이전트, 평가, 그리고 그림 생성까지 왔어요. 다음 AI 엔지니어링 트랙에서는 이 모델들을 실제 서비스로 만드는 법을 다뤄요. 첫 강의에서는 LLM API로 자동화를 만들면서 비용을 계산하고, 실패와 재시도를 처리하는 법을 배워요.