💡 왼쪽 원문을 읽으면서 오른쪽에 따라 써보세요. Tab 키로 힌트를 받을 수 있습니다.

원문 렌더가 준비되기 전까지 텍스트 가이드로 표시합니다.

들어가며 — 확산 모델이 텍스트로 넘어온 순간

2026년 6월, 구글이 DiffusionGemma를 공개했습니다. 26B 파라미터 MoE 구조, Apache 2.0 라이선스, 그리고 기존 자기회귀(autoregressive) 모델 대비 최대 4배 빠른 텍스트 생성이라는 주장과 함께였습니다. GeekNews에 올라온 소개 글은 빠르게 댓글이 쌓였고, 해커뉴스에서도 "드디어 자기회귀의 대안이 나오는가"라는 논쟁이 벌어졌습니다.

이미지 생성에서는 확산(diffusion) 모델이 이미 표준입니다. 그런데 텍스트는 사정이 달랐습니다. 토큰은 픽셀과 달리 이산적(discrete)이고, 언어는 순서가 의미를 만들기 때문입니다. 그럼에도 텍스트 확산 모델이 지금 주목받는 이유는 명확합니다. 자기회귀 생성의 구조적 한계, 특히 "한 번에 토큰 하나"라는 순차성이 추론 비용과 지연의 근본 원인으로 지목되고 있기 때문입니다.

이 글에서는 자기회귀의 한계부터 텍스트 확산의 작동 원리, DiffusionGemma 분석, 그리고 벤치마크 주장을 어디까지 믿어야 하는지까지 차례로 짚어보겠습니다.

자기회귀 생성의 구조적 한계

현재 거의 모든 LLM은 자기회귀 방식입니다. 다음 토큰의 확률분포를 예측하고, 하나를 샘플링하고, 그것을 입력에 붙여 다시 예측하는 과정을 반복합니다.

자기회귀 생성 (순차적):

입력: "오늘 날씨가"

스텝 1: [오늘 날씨가] -> "참"

스텝 2: [오늘 날씨가 참] -> "좋"

스텝 3: [오늘 날씨가 참 좋] -> "네요"

...

토큰 N개 = 모델 forward N번 (직렬, 병렬화 불가)

이 구조에는 세 가지 본질적 한계가 있습니다.

1. **순차성**: 토큰 N개를 만들려면 forward 패스 N번이 직렬로 필요합니다. 아무리 GPU가 커도 단일 시퀀스의 생성 지연은 줄이기 어렵습니다.

2. **메모리 대역폭 병목**: 디코딩 단계는 배치가 작을 때 연산이 아니라 가중치와 KV cache를 읽어오는 메모리 대역폭에 묶입니다. GPU 연산 유닛은 대부분 놀고 있습니다.

3. **되돌릴 수 없음**: 한 번 뱉은 토큰은 수정할 수 없습니다. 문장 앞부분에서 잘못된 방향을 잡으면 뒤에서 바로잡을 구조적 수단이 없습니다.

투기적 디코딩(speculative decoding)이나 멀티 토큰 예측 같은 보완책이 나왔지만, 모두 자기회귀라는 틀 안의 최적화입니다. 확산 모델은 틀 자체를 바꾸자는 제안입니다.

텍스트 확산 모델의 원리 — 마스킹과 디노이징

이미지 확산 모델은 픽셀에 가우시안 노이즈를 더하고 이를 되돌리는 과정을 학습합니다. 텍스트는 이산적이라 노이즈를 더할 수 없으므로, 대부분의 텍스트 확산 모델은 **마스킹**을 노이즈로 사용합니다. 이를 마스크드 확산(masked diffusion) 또는 이산 확산(discrete diffusion)이라고 부릅니다.

학습 (forward process): 점진적으로 마스킹

"고양이가 소파 위에서 잠을 잔다"

-> "고양이가 [M] 위에서 잠을 [M]"

-> "[M] [M] 위에서 [M] [M]"

-> "[M] [M] [M] [M] [M] [M]"

생성 (reverse process): 점진적으로 복원

"[M] [M] [M] [M] [M] [M]"

-> "[M] [M] 위에서 [M] 잔다" (확신 높은 토큰부터)

-> "고양이가 [M] 위에서 잠을 잔다"

-> "고양이가 소파 위에서 잠을 잔다"

핵심은 생성 단계에서 **여러 토큰을 동시에 복원**할 수 있다는 점입니다. 자기회귀가 N개 토큰에 N번의 forward가 필요하다면, 확산 모델은 디노이징 스텝 수 T번이면 됩니다. T가 N보다 훨씬 작으면 그만큼 빨라집니다.

샘플링 루프의 골격을 의사코드로 표현하면 다음과 같습니다.

def diffusion_generate(model, prompt_ids, gen_len, num_steps):

생성 구간을 전부 마스크 토큰으로 초기화

x = concat(prompt_ids, [MASK] * gen_len)

for step in range(num_steps):

logits = model(x) # 전체 시퀀스를 한 번에 forward

probs = softmax(logits, dim=-1)

conf, pred = probs.max(dim=-1) # 각 위치의 확신도와 예측

아직 마스크인 위치 중 확신도 상위 k개만 확정

k = unmask_schedule(step, num_steps, gen_len)

top_positions = topk_masked_positions(conf, x, k)

x[top_positions] = pred[top_positions]

return x

스텝마다 "지금 가장 확신할 수 있는 토큰"부터 확정하고, 애매한 위치는 다음 스텝으로 미룹니다. 이미 확정한 토큰도 일부 변형(remasking)을 허용하는 변종이 있어, 자기회귀에는 없는 **자기 수정** 능력이 생깁니다.

블록 단위 병렬 생성

긴 텍스트를 한 번에 전부 디노이징하는 것은 품질이 떨어지기 때문에, 실용 시스템은 **블록 단위 생성**을 사용합니다. 시퀀스를 블록으로 나누고, 블록 사이는 자기회귀처럼 순서대로, 블록 안에서는 확산으로 병렬 생성하는 방식입니다.

블록 단위 semi-autoregressive 생성:

[프롬프트] -> [블록 1: 32토큰 병렬 디노이징]

-> [블록 2: 32토큰 병렬 디노이징]

-> [블록 3: 32토큰 병렬 디노이징]

블록 간: 순차 (인과성 유지)

블록 내: 병렬 (확산 디노이징, 예: 8스텝)

-> 토큰당 forward 횟수: 32토큰 / 8스텝 = 토큰 4개당 1번

이 구조 덕분에 임의 길이 생성과 KV cache 재사용이 가능해지고, 자기회귀 대비 확실한 속도 이점을 유지할 수 있습니다.

짧은 계보 — 어떻게 여기까지 왔나

텍스트 확산은 갑자기 튀어나온 것이 아닙니다. 주요 이정표를 따라가면 흐름이 보입니다.

| 시기 | 이정표 | 의의 |

| --- | --- | --- |

| 2021 | D3PM | 이산 데이터에 확산을 정의한 이론적 기초 |

| 2022 | Diffusion-LM | 임베딩 공간에서의 연속 확산 시도 |

| 2023 | SEDD | 스코어 기반 이산 확산으로 perplexity 격차 축소 |

| 2024 | MDLM 계열 | 마스크드 확산의 목적함수 단순화, 학습 안정화 |

| 2025 | LLaDA 8B | 처음부터 학습한 확산 LM이 동급 자기회귀에 근접 |

| 2025 | Mercury, Gemini Diffusion | 상용 수준 속도 시연 (초당 천 토큰대 주장) |

| 2026 | DiffusionGemma | 대형 MoE + 오픈 가중치로 생태계 개방 |

이 계보에서 읽어야 할 것은 두 가지입니다. 첫째, 이론(D3PM)에서 실용(DiffusionGemma)까지 약 5년이 걸렸습니다. 둘째, 결정적 전환점은 "마스킹을 노이즈로 쓰면 목적함수가 단순해진다"는 발견과 "기존 자기회귀 가중치에서 어댑테이션하면 학습 비용이 급감한다"는 발견이었습니다.

학습 목적함수 — 생각보다 단순하다

마스크드 확산의 학습은 BERT의 마스크드 언어 모델링과 닮았지만, 결정적 차이가 있습니다. 마스킹 비율을 0과 1 사이에서 무작위로 샘플링하고, 비율에 따른 가중치를 손실에 곱한다는 점입니다.

def masked_diffusion_loss(model, x0, mask_token_id):

"""단순화된 마스크드 확산 손실 (MDLM 스타일).

x0: 원본 토큰 시퀀스 (B, T)

"""

B, T = x0.shape

1) 마스킹 비율 t를 (0, 1]에서 균등 샘플링

t = torch.rand(B, 1, device=x0.device).clamp(min=1e-3)

2) 각 토큰을 확률 t로 마스크 치환

mask = torch.rand(B, T, device=x0.device) < t

xt = torch.where(mask, mask_token_id, x0)

3) 마스크 위치의 원본 토큰을 예측

logits = model(xt) # (B, T, vocab)

loss_tok = F.cross_entropy(

logits.view(-1, logits.size(-1)),

x0.view(-1),

reduction="none",

).view(B, T)

4) 마스크된 위치만, 1/t 가중치로 집계

(낮은 마스킹 비율일수록 한 토큰의 정보 가치가 큼)

weighted = (loss_tok * mask) / t

return weighted.sum() / mask.sum().clamp(min=1)

자기회귀 손실과 비교하면 차이가 분명합니다.

자기회귀: 위치 i의 정답을 위치 0..i-1 만 보고 예측 (인과 마스크)

모든 위치에서 손실 발생, 한 시퀀스 = 학습 신호 T개

마스크드 확산: 마스크 위치의 정답을 나머지 전체를 보고 예측 (양방향)

마스크 위치에서만 손실 발생, 마스킹 비율을 바꿔가며 학습

학습 신호의 밀도는 자기회귀가 높습니다. 같은 데이터로 같은 손실 수준에 도달하려면 확산 쪽이 더 많은 연산을 쓰는 경향이 보고되어 있고, 이것이 확산 LM의 숨은 비용 중 하나입니다. 어댑테이션 전략이 각광받는 이유도 여기에 있습니다. 프리트레이닝의 무거운 비용은 자기회귀로 치르고, 확산은 그 위에 얹는 것입니다.

토이 구현 — 동작하는 최소 예제

원리를 코드로 굳히기 위해, 문자 수준의 미니 확산 LM 골격을 만들어 보겠습니다. 백본은 인과 마스크를 뺀 트랜스포머면 충분합니다.

class TinyDenoiser(nn.Module):

"""양방향 어텐션 트랜스포머 = 확산 LM의 백본."""

def __init__(self, vocab_size, d_model=256, n_head=4, n_layer=4, max_len=256):

super().__init__()

self.tok = nn.Embedding(vocab_size + 1, d_model) # +1: mask 토큰

self.pos = nn.Embedding(max_len, d_model)

layer = nn.TransformerEncoderLayer(

d_model, n_head, dim_feedforward=4 * d_model,

batch_first=True, norm_first=True,

)

핵심: 인과 마스크 없는 TransformerEncoder (양방향)

self.blocks = nn.TransformerEncoder(layer, n_layer)

self.head = nn.Linear(d_model, vocab_size)

def forward(self, x):

T = x.size(1)

pos = torch.arange(T, device=x.device)

h = self.tok(x) + self.pos(pos)

h = self.blocks(h)

return self.head(h)

학습 루프는 위의 손실 함수를 그대로 쓰면 되고, 생성은 confidence 기반 언마스킹으로 구현합니다.

@torch.no_grad()

def generate(model, prompt, gen_len, num_steps, mask_id):

device = prompt.device

x = torch.cat([

prompt,

torch.full((1, gen_len), mask_id, device=device),

], dim=1)

prompt_len = prompt.size(1)

for step in range(num_steps):

logits = model(x)

probs = logits.softmax(dim=-1)

conf, pred = probs.max(dim=-1)

still_masked = (x == mask_id)

still_masked[:, :prompt_len] = False

n_masked = int(still_masked.sum())

if n_masked == 0:

break

남은 스텝에 균등 배분하여 이번에 확정할 개수 결정

k = max(1, n_masked // (num_steps - step))

conf = conf.masked_fill(~still_masked, -1.0)

top = conf.view(-1).topk(k).indices

flat = x.view(-1)

flat[top] = pred.view(-1)[top]

return x

이 100줄 남짓한 골격으로 셰익스피어 데이터셋 정도는 충분히 실험할 수 있습니다. num_steps를 gen_len과 같게 두면 거의 순차 생성처럼 동작하고, 8분의 1로 줄이면 품질 저하를 눈으로 확인할 수 있습니다. 품질-속도 다이얼을 직접 돌려보는 경험이 이 주제 이해의 절반입니다.

이미지 확산과 무엇이 다른가

같은 "확산"이라는 이름을 쓰지만 차이가 큽니다.

| 항목 | 이미지 확산 | 텍스트 확산 (마스크드) |

| --- | --- | --- |

| 데이터 공간 | 연속 (픽셀, 잠재 벡터) | 이산 (토큰) |

| 노이즈 | 가우시안 노이즈 추가 | 토큰을 마스크로 치환 |

| 복원 목표 | 노이즈 예측 또는 원본 예측 | 마스크 위치의 토큰 예측 |

| 스텝 수 | 수십 스텝이 일반적 | 수 스텝에서 수십 스텝 |

| 백본 | U-Net 또는 DiT | 양방향 어텐션 트랜스포머 |

| 평가 | 사람 눈에 그럴듯하면 OK | 문법, 사실성, 일관성 모두 필요 |

특히 마지막 줄이 중요합니다. 이미지는 픽셀 몇 개가 어긋나도 티가 안 나지만, 텍스트는 토큰 하나가 틀리면 문장이 무너집니다. 텍스트 확산이 이미지보다 어려웠던 근본 이유입니다. 또 하나, 텍스트 확산 모델의 백본은 인과 마스크가 없는 **양방향 어텐션**을 씁니다. BERT처럼 앞뒤 문맥을 모두 보고 마스크를 채우는 구조가 확산 생성과 자연스럽게 맞물립니다.

DiffusionGemma 분석 — 무엇이 공개되었나

2026년 6월 공개된 DiffusionGemma의 공식 발표 내용을 정리하면 다음과 같습니다.

- **규모**: 26B 파라미터 MoE(Mixture of Experts). 토큰당 활성 파라미터는 그보다 훨씬 작아 추론 효율을 확보

- **라이선스**: Apache 2.0. 연구는 물론 상용 활용까지 열려 있음

- **속도 주장**: 동급 자기회귀 모델 대비 최대 4배 빠른 생성. 특히 코드 생성과 편집 워크로드에서 격차가 크다고 주장

- **방식**: 마스크드 확산 + 블록 단위 생성. 기존 Gemma 계열에서 어댑테이션(adaptation)한 것으로 알려짐

주목할 포인트는 세 가지입니다.

첫째, **MoE와 확산의 결합**입니다. 확산 모델은 스텝마다 전체 시퀀스를 forward하므로 스텝당 연산량이 자기회귀보다 큽니다. MoE로 토큰당 활성 연산을 줄여 이 비용을 상쇄하는 설계로 읽힙니다.

둘째, **어댑테이션 전략**입니다. 처음부터 확산 모델을 프리트레이닝하는 대신, 기존 자기회귀 모델의 가중치에서 출발해 확산 목적함수로 추가 학습하는 접근은 학습 비용을 크게 줄입니다. 자기회귀 모델이 쌓은 지식을 물려받을 수 있다는 것이 최근 연구들의 공통된 발견입니다.

셋째, **Apache 2.0 공개**라는 결정입니다. 확산 LM은 아직 서빙 생태계(vLLM 류의 최적화 엔진)가 미성숙한데, 가중치를 완전히 열어 커뮤니티가 인프라를 만들도록 유도하는 전략으로 보입니다.

품질 vs 속도 — 진짜 트레이드오프

확산 LM의 속도는 공짜가 아닙니다. 핵심 트레이드오프는 디노이징 스텝 수에 있습니다.

| 디노이징 스텝 | 속도 | 품질 경향 |

| --- | --- | --- |

| 토큰 수와 동일 | 자기회귀와 비슷 | 자기회귀급 품질 가능 |

| 토큰 수의 4분의 1 | 약 4배 빠름 | 다수 벤치마크에서 근접 |

| 토큰 수의 16분의 1 | 약 16배 빠름 | 일관성 저하 뚜렷, 반복/모순 증가 |

즉 "4배 빠르다"는 주장은 "품질 저하를 감수 가능한 수준으로 억누른 스텝 수 설정에서 4배"라는 의미로 읽어야 합니다. 스텝 수라는 다이얼을 돌려 품질과 속도를 교환하는 구조 자체가 확산 LM의 본질입니다. 이는 단점이기도 하지만, 워크로드에 따라 다이얼을 조절할 수 있다는 운영상의 유연성이기도 합니다.

또 하나의 비용은 **KV cache 활용의 제약**입니다. 양방향 어텐션은 토큰이 확정될 때마다 문맥이 바뀌므로 자기회귀처럼 단순한 캐시 재사용이 어렵습니다. 블록 단위 생성과 근사 캐싱으로 완화하지만, 자기회귀 진영이 십 년 가까이 쌓아온 서빙 최적화 자산을 그대로 쓸 수 없다는 점은 현실적 핸디캡입니다.

추론 비용 관점 — 어디서 이득이 나는가

GPU 관점에서 보면 이야기가 더 명확해집니다.

자기회귀 디코딩 (배치 1):

forward 1번 = 토큰 1개

병목: 메모리 대역폭 (가중치 로딩)

GPU 연산 유닛 활용률: 낮음

확산 디노이징 (배치 1):

forward 1번 = 블록 전체 (예: 토큰 32개) 갱신

병목: 연산 (시퀀스 전체 어텐션)

GPU 연산 유닛 활용률: 높음

자기회귀 디코딩은 "메모리에서 가중치를 읽는 시간"이 지배하는 작업이라 GPU의 연산 능력이 남아돕니다. 확산은 그 남는 연산을 여러 토큰의 동시 갱신에 투입합니다. 다시 말해 확산 LM의 속도 이점은 **낭비되던 연산 자원을 지연 단축으로 전환**하는 데서 나옵니다.

따라서 이득이 가장 큰 조건은 배치가 작고 지연이 중요한 상황(대화형, 코드 자동완성)입니다. 반대로 대규모 배치 처리로 GPU를 이미 꽉 채워 쓰는 서빙(오프라인 배치 추론)에서는 확산의 상대적 이점이 줄어듭니다. 처리량 기준으로는 자기회귀 + 연속 배칭(continuous batching) 조합이 이미 매우 효율적이기 때문입니다.

적합한 워크로드 — 어디에 쓰면 좋은가

구조적 특성상 확산 LM이 특히 잘 맞는 작업이 있습니다.

| 워크로드 | 적합도 | 이유 |

| --- | --- | --- |

| 초안 드래프팅 | 높음 | 빠른 대량 생성 후 사람이 다듬는 흐름과 잘 맞음 |

| 텍스트 편집/리라이팅 | 높음 | 양방향 문맥으로 중간 부분만 자연스럽게 수정 가능 |

| 코드 인필링 (FIM) | 매우 높음 | 앞뒤 코드를 모두 보고 빈칸을 채우는 작업이 본질적으로 일치 |

| 구조화 출력 (JSON 등) | 높음 | 스키마 골격을 고정하고 값만 디노이징하는 제약 생성 |

| 장문 추론 (chain of thought) | 낮음 | 단계적 인과 전개가 필요한 작업은 순차 생성이 유리 |

| 정밀한 장문 문서 | 중간 | 스텝 수를 늘리면 가능하나 속도 이점 소멸 |

반대로 적합도가 낮은 영역도 분명합니다. 수학 증명이나 다단계 추론처럼 앞 단계의 결과가 뒤 단계의 전제가 되는 작업은, 토큰을 병렬로 확정하는 확산의 생성 방식과 근본적으로 긴장 관계에 있습니다. 추론 특화 모델들이 여전히 자기회귀를 고수하는 데는 이유가 있습니다.

특히 코드 채움(fill-in-the-middle)은 자기회귀 모델이 특수 토큰으로 어색하게 흉내 내던 작업입니다. 양방향 어텐션을 가진 확산 모델에게는 본질적으로 자연스러운 작업이라, 코드 도구 영역에서 확산 LM의 첫 킬러 유스케이스가 나올 것이라는 전망이 많습니다.

실무 적용 가이드 — 평가 파이프라인에 올리는 법

확산 LM을 검토한다면 다음 순서를 권합니다.

1. **자기 워크로드의 프로파일 파악**: 평균 출력 길이, 지연 요구치, 배치 크기 분포를 먼저 수치화합니다. 짧은 출력 + 낮은 배치 + 엄격한 지연이면 확산이 유리한 지형입니다.

2. **베이스라인을 제대로 세우기**: 비교 대상 자기회귀 모델에 투기적 디코딩과 양자화까지 적용한 상태를 기준선으로 삼아야 공정한 비교가 됩니다.

3. **품질 게이트 먼저, 속도 측정은 그다음**: 자기 도메인의 평가셋으로 품질 하한선을 통과하는 최소 스텝 수를 찾고, 그 설정에서의 지연을 측정합니다.

4. **블록 크기와 스텝 수 그리드 탐색**: 두 하이퍼파라미터가 품질-속도 곡선을 결정합니다. 곡선 전체를 그려야 운영 지점을 고를 수 있습니다.

지연 측정의 골격은 다음과 같습니다.

def benchmark_generation(generate_fn, prompts, n_warmup=3, n_runs=10):

워밍업 (커널 컴파일, 캐시 효과 제거)

for p in prompts[:n_warmup]:

generate_fn(p)

records = []

for p in prompts[:n_runs]:

torch.cuda.synchronize()

t0 = time.perf_counter()

out = generate_fn(p)

torch.cuda.synchronize()

dt = time.perf_counter() - t0

n_new = out.size(1) - p.size(1)

records.append((dt, n_new / dt))

lat = sorted(r[0] for r in records)

tps = sorted(r[1] for r in records)

mid = len(records) // 2

print(f"median latency: {lat[mid]*1000:.1f} ms")

print(f"median tokens/sec: {tps[mid]:.1f}")

측정 시 흔한 실수 두 가지를 피해야 합니다. 첫째, 워밍업 없이 첫 호출을 측정에 포함하면 컴파일 오버헤드가 섞입니다. 둘째, 토큰 수 기준 비교 시 두 모델의 토크나이저가 다르면 같은 텍스트라도 토큰 수가 달라지므로, 토큰/초 대신 문자/초 또는 작업 완료 시간으로 비교하는 편이 안전합니다.

도입 판단 체크리스트

- 출력 길이가 짧거나 중간 길이인가 (수백 토큰 이내)

- 편집, 채움, 구조화 출력 비중이 높은가

- p95 지연이 비즈니스 지표에 직결되는가

- 품질 평가셋과 게이트가 이미 갖춰져 있는가

- 서빙 스택을 직접 수정할 역량이 있는가 (생태계 미성숙 보완)

다섯 항목 중 셋 이상에 그렇다고 답할 수 있다면 파일럿 가치가 충분합니다.

하이브리드 전망 — 자기회귀와 확산의 결합

업계의 중론은 "확산이 자기회귀를 대체한다"가 아니라 "둘이 결합된다"입니다. 이미 여러 방향이 실험되고 있습니다.

1. **블록 자기회귀 + 블록 내 확산**: 위에서 본 semi-autoregressive 구조. 인과성과 병렬성의 절충안으로 사실상 표준이 되어가는 중입니다.

2. **확산 드래프터 + 자기회귀 검증자**: 투기적 디코딩의 드래프트 모델을 확산 모델로 교체. 확산이 빠르게 초안을 깔고 자기회귀 모델이 검증/수정하는 구조입니다.

3. **추론은 자기회귀, 본문은 확산**: 사고 과정(reasoning)은 순차 생성으로 정확하게, 최종 답변의 장문 출력은 확산으로 빠르게 만드는 역할 분담입니다.

4. **어댑테이션 양방향 전환**: 하나의 가중치에서 자기회귀 모드와 확산 모드를 모두 지원하는 모델. 워크로드에 따라 생성 모드를 런타임에 선택합니다.

DiffusionGemma 역시 순수 확산이라기보다 블록 단위 하이브리드에 가깝다는 점이 이 흐름을 뒷받침합니다.

비판적 시각 — 벤치마크를 그대로 믿지 말 것

마지막으로 견제구를 몇 개 던져야 공정합니다.

- **속도 비교의 기준선 문제**: "4배 빠르다"의 비교 대상이 무엇인지 항상 확인해야 합니다. 투기적 디코딩, 양자화, 최적화 커널을 모두 적용한 자기회귀 모델과 비교한 것인지, 순정 구현과 비교한 것인지에 따라 결론이 완전히 달라집니다.

- **품질 벤치마크의 선택 편향**: 확산 LM 발표는 병렬 생성에 유리한 벤치마크(짧은 응답, 코드 채움)를 전면에 내세우는 경향이 있습니다. 장문 일관성, 멀티턴 대화, 정밀 지시 이행 같은 약점 영역의 수치는 종종 부록에 있습니다.

- **likelihood 평가의 어려움**: 확산 LM은 정확한 우도 계산이 어려워 perplexity 비교가 근사치(ELBO 경계)에 의존합니다. 자기회귀와의 직접 비교에는 항상 주의가 필요합니다.

- **생태계 격차**: 자기회귀에는 vLLM, 투기적 디코딩, 프리픽스 캐싱 등 거대한 최적화 생태계가 있습니다. 확산 LM의 이론적 속도 이점이 실서비스 격차로 이어지려면 동급의 서빙 인프라가 먼저 갖춰져야 합니다.

- **스케일 검증 부족**: 확산 LM이 프런티어급 규모에서도 자기회귀와 같은 스케일링 곡선을 타는지는 아직 공개된 증거가 제한적입니다. 26B MoE는 의미 있는 규모지만 결론을 내리기엔 이릅니다.

마치며

텍스트 확산 모델은 "자기회귀의 대체재"라기보다 "추론 비용 구조를 바꾸는 새로운 다이얼"로 보는 것이 정확합니다. 스텝 수로 품질과 속도를 교환할 수 있고, 양방향 문맥으로 편집과 채움에 강하며, 낭비되던 GPU 연산을 지연 단축으로 전환합니다. DiffusionGemma의 Apache 2.0 공개는 이 방향의 생태계 형성을 크게 앞당길 것입니다.

기술의 역사에서 "느리지만 확실한 방식"과 "빠르지만 새로운 방식"이 경쟁할 때, 승자는 대개 두 방식의 장점을 합친 절충안이었습니다. 텍스트 생성에서도 같은 패턴이 반복될 가능성이 높습니다.

다만 벤치마크의 화려한 숫자는 항상 조건과 함께 읽어야 합니다. 자기회귀 진영도 멈춰 있지 않으며, 가장 가능성 높은 미래는 한쪽의 승리가 아니라 워크로드별 역할 분담과 하이브리드입니다. 코드 자동완성이나 문서 편집 도구를 만들고 있다면, 지금이 확산 LM을 실험 파이프라인에 올려볼 적기입니다.

참고 자료

- DiffusionGemma 공식 발표: https://blog.google/innovation-and-ai/technology/developers-tools/diffusion-gemma-faster-text-generation/

- GeekNews의 DiffusionGemma 소개: https://news.hada.io/topic?id=30386

- Gemini Diffusion 소개 페이지: https://deepmind.google/models/gemini-diffusion/

- LLaDA (Large Language Diffusion Models) 논문: https://arxiv.org/abs/2502.09992

- D3PM (이산 확산의 기초) 논문: https://arxiv.org/abs/2107.03006

- Masked Diffusion 단순화 연구 (MDLM): https://arxiv.org/abs/2406.07524

- Block Diffusion 논문: https://arxiv.org/abs/2503.09573

- Dream 7B (확산 LM 어댑테이션 사례): https://arxiv.org/abs/2508.15487

- Hacker News의 확산 LM 토론: https://news.ycombinator.com/

- vLLM 공식 문서 (자기회귀 서빙 최적화 비교 기준): https://docs.vllm.ai/