확산 언어 모델 (Diffusion Language Models): NVIDIA Nemotron-Labs Diffusion이 어떻게 자기회귀

Meta Description: 확산 언어 모델 (DLMs)이 LLM 추론 (Inference) 방식을 재정의하고 있습니다. NVIDIA의 Nemotron-Labs Diffusion을 심층 분석합니다 — 블록 단위 어텐션 (Block-wise attention), AR-to-DLM 변환, 그리고 자기 추론 (Self-speculation) 모드가 어떻게 자기회귀 (Autoregressive) 모델보다 더 높은 정확도를 유지하면서 6.4배의 처리량 (Throughput) 이득을 달성하는지 확인해 보세요. 확산 언어 모델 (Diffusion Language Models): NVIDIA의 Nemotron-Labs Diffusion이 어떻게 자기회귀 (Autoregressive) 속도의 한계를 깨뜨리는가 발행일: 2026년 5월 23일 | 핵심 키워드: diffusion language models | 예상 읽기 시간: 14분 목차 토큰 단위의 세금 (The Token-by-Token Tax): 왜 당신의 LLM이 GPU 성능을 낭비하고 있는가 배경: 자기회귀 (Autoregressive)의 벽 확산 언어 모델 (Diffusion Language Models)이란 무엇인가? 전체적인 개념 모델 (Mental Model) AR-to-DLM 변환의 돌파구 Nemotron-Labs Diffusion: 아키텍처 및 세 가지 생성 모드 성능 심층 분석: 벤치마크와 실제 의미 실습: Nemotron-Labs Diffusion 로드 및 실행 실무 엔지니어링 고려 사항 더 큰 그림: DLM이 LLM 생태계에 의미하는 바 결론: 행동할 가치가 있는 패러다임의 전환 1. 토큰 단위의 세금 (The Token-by-Token Tax) 세계에서 가장 빠른 타이피스트를 고용했다고 상상해 보십시오. 하지만 그들에게 매 글자를 입력할 때마다 다음 글자를 치기 전 전체 문서를 다시 읽도록 강제한다고 가정해 봅시다. 본질적으로, 그것이 현재 당신의 GPU에서 자기회귀 (Autoregressive) LLM이 하고 있는 일입니다. 표준 트랜스포머 (Transformer) LLM에 의해 생성되는 모든 토큰은 모든 모델 가중치 (Weights)를 통과하는 전체 순전파 (Forward pass)를 필요로 합니다. 단 하나의 곱셈-누산 (Multiply-accumulate) 연산이 일어나기 전에 모든 가중치는 GPU HBM (고대역폭 메모리)에서 연산 코어로 로드되어야 합니다. 대화형 애플리케이션, 코드 어시스턴트, 실시간 에이전트의 영역인 배치 크기 (Batch size) 1 환경에서, 당신의 수십억 파라미터 모델은 거의 100% 메모리 대역폭 제한 (Memory-bandwidth bound) 상태에 놓입니다. 메모리 읽기를 기다리는 동안 유휴 상태로 있는 수천 개의 CUDA 코어는 모든 LLM 배포가 지불해야 하는 소리 없는 세금입니다. 이것은 새로운 관찰이 아닙니다. 이는 GPT-2 이후 LLM 서빙 (Serving)의 결정적인 병목 현상 (Bottleneck)이었습니다.

하드웨어 제조사들은 HBM3, NVLink, 그리고 점점 더 넓어지는 메모리 버스 (Memory Bus)를 통해 이 문제에 대응해 왔지만, 근본적인 제약은 여전히 남아 있습니다. 즉, 자기회귀 (Autoregressive) 디코딩은 현대의 병렬 하드웨어 (Parallel Hardware)를 근본적으로 제대로 활용하지 못하는 방식으로 연산을 직렬화 (Serialize)합니다. 2026년 5월 23일, NVIDIA는 아키텍처 수준에서 이 문제에 정면으로 도전하는 확산 언어 모델 (Diffusion Language Models, DLMs) 제품군인 Nemotron-Labs Diffusion을 출시했습니다. 이 모델들은 한 번에 하나의 토큰을 결정하는 대신, 토큰의 전체 블록을 병렬로 생성한 다음 이를 반복적으로 정제 (Refine)합니다. 그 결과, 유사한 자기회귀 (AR) 베이스라인 모델보다 최대 6.4배 높은 처리량 (Throughput)을 달성하면서도, 대등한 AR 모델을 능가하는 정확도를 보여줍니다. 본 포스트는 확산 언어 모델 (DLMs)이 어떻게 작동하는지, NVIDIA의 접근 방식이 무엇이 다른지, 그리고 오늘 바로 어떻게 사용할 수 있는지에 대한 심도 있는 기술적 분석을 다룹니다.

2. 배경: 자기회귀의 벽 (The Autoregressive Wall)
   확산 언어 모델 (DLMs)이 왜 중요한지 이해하려면, 자기회귀 (Autoregressive) 모델이 왜 한계에 부딪히는지 정확히 이해해야 합니다. 병목 현상 (Bottleneck)이 많은 엔지니어들이 추측하는 지점이 아니기 때문에 구체적으로 짚고 넘어갈 가치가 있습니다.

메모리 대역폭 문제 (The Memory Bandwidth Problem)
현대의 LLM은 추론 (Inference) 엔지니어들이 낮은 배치 크기 (Batch Size)에서 '메모리 대역폭 제한 (Memory-bandwidth bound)' 상태라고 부르는 특성을 가집니다. BF16 정밀도의 8B 파라미터 모델을 가정해 봅시다. 이는 약 16 GB의 가중치 (Weight) 데이터를 의미합니다. 배치 크기가 1일 때, 단 하나의 토큰을 생성하기 위해서는 메모리 계층 구조 (Memory Hierarchy)를 통해 그 16 GB의 대부분을 읽어 들여야 합니다. H100은 약 3.35 TB/s의 HBM 대역폭을 가지고 있어 매우 빨라 보이지만, 16 GB를 읽는 데는 여전히 순수 메모리 시간만 약 4.8 ms가 소요됩니다. 배치 크기가 1일 경우, 연산 (Compute) 시간을 고려하기 전에도 메모리 대역폭 제한만으로 이론적 상한선은 초당 약 208 토큰입니다. 배치 크기를 늘리면 여러 시퀀스 (Sequence)에 걸쳐 이러한 메모리 읽기 작업을 분산 (Amortize)할 수 있지만, 이는 개별 요청에 대한 지연 시간 (Latency)을 희생하여 처리량 (Throughput)을 얻는 방식이며, 대화형 애플리케이션 (Interactive Applications)에는 적절하지 않은 트레이드오프 (Tradeoff)입니다.

비가역성 문제 (The Irreversibility Problem) 자기회귀 (Autoregressive) 생성에는 두 번째의 더 미묘한 병리적 현상이 있습니다. 토큰은 한 번 생성되면 최종적이라는 점입니다. 만약 모델이 시퀀스 초기에 잘못된 토큰을 내뱉으면, 이후의 모든 토큰은 그 실수를 조건부로 생성하게 됩니다. 유일한 완화 방법은 빔 서치 (Beam Search)나 온도 (Temperature)를 이용한 샘플링뿐인데, 이는 근본 원인을 제거하지 못한 채 연산 오버헤드 (Compute Overhead)만 추가하는 기술들입니다. 이는 특히 중간 채우기 (Fill-in-the-middle, FIM) 작업에서 매우 고통스럽습니다. 함수의 중간 부분에서 코드를 완성하는 작업을 생각해보면, 모델은 앞선 문맥과 뒤따르는 문맥 모두와 동시에 일관성을 유지하는 텍스트를 생성해야 합니다. 자기회귀 모델은 재배열된 시퀀스로 학습하거나 특수 토큰을 통해 FIM을 처리하지만, 여전히 왼쪽에서 오른쪽으로 디코딩 (Decoding)하기 때문에 초기에 잘못 결정된 내용을 자연스럽게 수정할 수 없습니다.

KV 캐시의 한계 (The KV Cache Ceiling) KV 캐시 (KV Cache)는 매 단계마다 이전 토큰들을 다시 계산하는 것을 피하기 위해 키-값 (Key-Value) 쌍을 저장하는 표준적인 최적화 방식입니다. 하지만 이는 자체적인 확장 제약 (Scaling Constraints)을 유발합니다. KV 캐시의 크기는 시퀀스 길이와 배치 크기 (Batch Size)에 따라 선형적으로 증가합니다. 단일 A100-80GB 환경에서 32k 컨텍스트를 가진 70B 모델을 배치 크기 8로 서빙할 경우, KV 캐시만으로도 GPU 메모리가 완전히 고갈될 수 있으며, 이는 배치 크기를 줄이거나 컨텍스트를 잘라내야 하는 상황을 강제합니다. 메모리 대역폭 (Memory Bandwidth), 비가역성 (Irreversibility), 그리고 KV 캐시 압박 (KV Cache Pressure)이라는 이 세 가지 문제는 자기회귀 디코딩의 구조적 특징입니다. 엔지니어링 해킹 (Engineering Hacks, 예: 추측적 디코딩 (Speculative Decoding), Flash Attention, 양자화 (Quantization))으로 이 중 하나를 패치하는 것은 점진적인 완화책만을 제공할 뿐입니다. 확산 언어 모델 (Diffusion Language Models)은 이 세 가지 문제를 아키텍처 수준에서 동시에 해결합니다.

3. 확산 언어 모델이란 무엇인가? 전체적인 개념 모델 (The Full Mental Model) 만약 여러분이 이미지용 확산 모델 (Stable Diffusion, DALL·E, Flux)을 다뤄본 적이 있다면, 텍스트의 이산적 (Discrete) 특성에 맞춘 한 가지 중요한 적응 과정만 거친다면 올바른 개념 모델을 가지고 있는 것입니다. 이미지 확산 (Image Diffusion) 대...

텍스트 확산 (Text Diffusion)

이미지 확산 (Image diffusion) 모델은 다음과 같이 작동합니다:
순방향 과정 (Forward process): 이미지가 순수한 노이즈가 될 때까지 점진적으로 가우시안 노이즈 (Gaussian noise)를 추가합니다.
역방향 과정 (Reverse process): 반복적으로 노이즈를 제거(denoise)하여 단계별로 원래 이미지를 복구하는 법을 학습합니다.

텍스트의 경우, 이산적 토큰 (discrete tokens)에 연속적인 가우시안 노이즈를 추가할 수 없습니다. 대신, 이산 확산 (discrete diffusion) 모델은 마스킹 (masking) 과정을 사용합니다:
순방향 과정 (마스킹, Forward process): 토큰을 특수한 [MASK] 토큰으로 점진적으로 교체합니다.
역방향 과정 (디마스킹, Reverse process): 완전히 마스킹된 시퀀스에서 시작하여, 마스킹된 토큰을 예측하고 채워 넣는 법을 학습합니다.

추론 (Inference) 시에는 완전히 마스킹된 타겟 시퀀스에서 시작합니다. 모델은 전체 시퀀스에 걸쳐 토큰 예측을 동시에 수행하며, 신뢰도가 낮은 예측은 다음 정제 단계를 위해 마스킹된 상태로 남겨둡니다. 정해진 횟수의 노이즈 제거 단계(통상 10~50회)를 거치면, 시퀀스는 완전하고 일관된 출력으로 수렴합니다.

처리량 (Throughput) 측면에서 이것이 자기회귀 (AR) 모델을 압도하는 이유

처리량의 이점은 구조적입니다.
자기회귀 (AR) 디코딩의 경우:
N개 토큰 = N번의 순방향 패스 (forward passes)
각 순방향 패스는 1개의 새로운 토큰을 처리합니다 (문맥을 위한 KV 캐시 포함).

블록 크기가 32인 확산 언어 모델 (DLM) 디코딩의 경우:
32개 토큰 = 1번의 순방향 패스 (첫 번째 패스에서 32개 위치를 동시에 채움)
이후의 패스들은 동일한 블록 내의 불확실한 토큰들을 정제합니다.
모델의 신뢰도가 높으면 매우 적은 단계 내에 수렴이 일어납니다.

총 연산량이 반드시 더 낮은 것은 아닙니다. 32개 토큰 블록에 대한 각 DLM 순방향 패스는 더 많은 토큰을 동시에 처리합니다. 하지만 이 병렬성 (parallelism)은 GPU 하드웨어에 훨씬 더 잘 부합합니다. 메모리 대역폭에 제한을 받는 (memory-bound) 순차적 읽기 대신, 전체 블록에 걸친 연산 대역폭 제한적 (compute-bound) 행렬 곱셈을 수행하게 되는데, 이것이 바로 GPU가 설계된 방식입니다.

양방향 어텐션 (Bidirectional Attention): 비법

AR 모델은 인과적 (causal, 단방향) 어텐션을 사용합니다. 즉, 각 토큰은 자신보다 앞선 토큰들만 참조할 수 있습니다. 이는 아키텍처 수준에서 왼쪽에서 오른쪽으로 생성해야 한다는 제약을 강제합니다.

DLM은 생성되는 각 블록 내에서 양방향 어텐션 (Bidirectional Attention)을 사용합니다. 즉, 마스킹된 모든 토큰이 컨텍스트 윈도우 (Context Window) 내의 다른 모든 토큰(마스킹되었거나 마스킹되지 않은 토큰 모두)을 동시에 참조할 수 있습니다. 이를 통해 DLM은 32개 토큰 블록에서 1, 8, 15, 27번째 토큰을 단 한 번의 패스 (Pass)로 생성할 수 있으며, 각 토큰은 서로의 정보를 바탕으로 생성됩니다. 이는 아키텍처 구조상 자기회귀 (AR) 모델에서는 불가능한 일입니다.

4. AR-to-DLM 변환의 돌파구
   확산 언어 모델 (DLM)의 개념적 매력은 수년 동안 존재해 왔습니다. 하지만 이들이 자기회귀 (AR) 모델을 대체하지 못했던 이유는 매우 까다로운 실질적 장벽 때문이었습니다. 바로 DLM을 처음부터 (from scratch) 학습시키는 비용이 재앙적일 정도로 비싸다는 점입니다. AR 모델은 단일 조건부 분포 $P(\text{token}t | \text{token}{1\dots t-1})$를 학습합니다. 반면 DLM은 가능한 모든 마스킹 패턴으로부터 노이즈를 제거하는 법을 학습해야 하며, 이는 사실상 $P(\text{token} | \text{other tokens의 임의의 부분 집합})$을 학습하는 것과 같습니다. 길이가 $N$인 시퀀스에 대해 가능한 마스킹 패턴의 수는 $2^N$입니다. 이러한 조합 폭발 (Combinatorial Explosion)로 인해, 처음부터 학습된 DLM이 AR 모델과 동일한 정확도에 도달하려면 수십 배 더 많은 데이터와 연산량이 필요합니다.

NVIDIA Efficient-DLM 논문: 핵심 통찰
돌파구는 NVIDIA Research의 Efficient-DLM 논문 (arXiv:2512.14067)에서 마련되었습니다. 핵심 통찰은 다음과 같습니다: DLM을 처음부터 학습시킬 필요가 없다는 것입니다. 기존에 사전 학습된 (Pretrained) AR 모델을 원래 학습 비용의 아주 일부만 사용하여 추가 사전 학습 (Continued Pretraining)을 통해 DLM으로 변환할 수 있습니다. 사전 학습된 AR 모델은 이미 언어 구조, 문법, 사실 관계, 추론 등 모든 어려운 의미론적 작업에 대한 풍부한 표현 (Representations)을 학습한 상태입니다. 이를 확산 스타일의 생성 방식을 지원하도록 변환하는 데 필요한 것은 새로운 언어 지식이 아니라, 새로운 디코딩 메커니즘 (Decoding Mechanism)을 가르치는 것입니다. 이 논문은 경쟁력 있는 정확도를 달성하기 위해 (처음부터 학습할 때 필요한 수조 개의 토큰과 달리) 약 100억 개의 토큰에 대한 추가 사전 학습만으로도 이 변환이 가능하다는 것을 입증했습니다. 약 1,000억 개의 토큰에 대해 학습을 확장하면 더욱 공격적인 병렬 생성이 가능해집니다.

블록 단위 어텐션 (Block-Wise Attention): AR 가중치 분포 보존

첫 번째 핵심 기술적 기여는 블록 단위 어텐션 (block-wise attention) 패턴입니다. 완전히 양방향인 어텐션 (fully bidirectional attention)으로 전환하는 대신(이는 어텐션 구조를 근본적으로 변화시키고 AR 모델이 학습한 가중치 분포를 파괴합니다), 블록 단위 어텐션은 다음과 같은 방식을 취합니다:

• 블록 간에는 인과적 어텐션 (causal attention) 유지 (블록 2는 블록 3의 토큰을 참조할 수 없음)
• 각 블록 내부에서는 양방향 어텐션 (bidirectional attention) 허용 (블록 2 내의 토큰들은 서로 자유롭게 참조 가능)

이는 매우 중요한 미묘한 차이입니다. 변환 과정에서 완전히 양방향인 어텐션을 사용하면 치명적 망각 (catastrophic forgetting)이 발생합니다. 즉, 모델의 사전 학습된 가중치는 인과적 어텐션 패턴을 "기억"하고 있는데, 이를 완전한 양방향성으로 전환하면 불일치가 발생하여 정확도가 저하됩니다. 블록 단위 어텐션은 시퀀스 전체에 걸쳐 인과적 구조를 보존하는 동시에, 처리량 (throughput)을 높이는 블록 내 병렬 생성을 가능하게 합니다.

블록 단위 어텐션 마스크 (block-wise attention mask)의 단순화된 모습은 다음과 같습니다:

import torch

def block_wise_attention_mask ( seq_len : int , block_size : int ) -> torch . Tensor :
    """
    DLM 변환을 위한 블록 단위 어텐션 마스크를 생성합니다.
    - 블록 간 인과성: 블록 i는 j > i 인 블록 j를 참조할 수 없음
    - 각 블록 내 양방향성: 블록 i의 모든 토큰은 서로를 참조함

    Args:
        seq_len: 전체 시퀀스 길이
        block_size: 각 어텐션 블록의 크기

    Returns:
        (seq_len, seq_len) 형태의 불리언 마스크
        True = 해당 위치를 참조함, False = 마스킹됨
    """
    mask = torch . zeros ( seq_len , seq_len , dtype = torch . bool )
    num_blocks = ( seq_len + block_size - 1 ) // block_size

    for block_idx in range ( num_blocks ):
        block_start = block_idx * block_size
        block_end = min ( block_start + block_size , seq_len )

        # 이 블록의 각 토큰은 다음을 참조할 수 있습니다:
        # 1. 모든 이전 블록의 모든 토큰 (블록 간 인과적 참조)
        # 2.

이 블록 내의 모든 토큰 (양방향 블록 내 참조 (bidirectional intra-block))

for pos in range ( block_start , block_end ):
    # 모든 이전 블록에 주의 (Attend to all previous blocks)
    mask [ pos , : block_start ] = True
    # 현재 블록 내의 모든 위치에 주의 (양방향 (bidirectional))
    mask [ pos , block_start : block_end ] = True

return mask

# 예시: 16개 토큰 시퀀스, 블록 크기 4
mask = block_wise_attention_mask ( seq_len = 16 , block_size = 4 )
print ( f " Mask shape: { mask . shape } " )
print ( f " Non-zero fraction: { mask . float (). mean () : . 2 % } " )

# 마스크 구조 시각화
import matplotlib.pyplot as plt
plt . figure ( figsize = ( 8 , 8 ))
plt . imshow ( mask . numpy (), cmap = ' Blues ' , interpolation = ' nearest ' )
plt . title ( ' 블록 단위 주의 마스크 (Block-Wise Attention Mask) (seq=16, block=4) \n 파란색 = 주의 (attended), 흰색 = 마스킹 (masked) ' )
plt . xlabel ( ' 키 위치 (Key position) ' )
plt . ylabel ( ' 쿼리 위치 (Query position) ' )
for i in range ( 0 , 16 , 4 ):
    plt . axhline ( i - 0.5 , color = ' red ' , linewidth = 1.5 )
    plt . axvline ( i - 0.5 , color = ' red ' , linewidth = 1.5 )
plt . tight_layout ()
plt . savefig ( ' /tmp/block_attn_mask.png ' , dpi = 150 )
print ( " 블록 주의 마스크 시각화가 저장되었습니다. " )

위치 의존적 토큰 마스킹 (Position-Dependent Token Masking): 훈련-테스트 격차 해소
두 번째 핵심 기여는