TRENDSHIFT 딥다이브 · 2026-06-29

deepseek-ai/DeepSpec 딥다이브
— 큰 모델을 2~3배 빠르게: "추측 디코딩" 드래프트 모델 풀스택

DeepSeek이 공개한, 추측 디코딩(speculative decoding)용 "드래프트 모델"을 데이터 준비 → 학습 → 평가까지 한 코드베이스에서 다루는 풀스택 레퍼런스. 세 가지 알고리즘(DSpark·DFlash·Eagle3)을 똑같은 틀에서 학습·비교할 수 있고, DSpark는 이 레포에 자체 논문(DSpark_paper.pdf)까지 함께 들어 있다. (저장소: deepseek-ai/DeepSpec · 언어: Python / PyTorch · MIT 라이선스 · TrendShift Daily 3위 · ※ 연구용 레퍼런스 구현 — 다중 GPU·대용량 디스크 전제)
목차
  1. 프로젝트 한줄 요약
  2. 왜 주목받는가
  3. 기술 스택 전체 지도
  4. 아키텍처 심화 분석
  5. 디렉토리 구조 해부
  6. 학습 포인트 (기술별)
  7. 시스템 요구사항 · 실행
  8. 직접 해볼 수 있는 실습 과제
  9. 관련 기술 심화 학습 로드맵
  10. 핵심 키워드 사전
  11. 참고 링크

1프로젝트 한줄 요약

이 레포가 무엇을 하는 물건인가.

핵심 메시지

"빠른 인턴이 문장을 먼저 받아쓰고,
꼼꼼한 상사는 '검토 도장'만 한 번에 찍는다."
큰 모델은 그대로 두고, 작은 모델로 속도만 훔쳐온다.

DeepSpec은 추측 디코딩(speculative decoding)에 쓰는 드래프트(초안) 모델을 만드는 도구 모음이다. 큰 모델(타깃)이 토큰을 한 개씩 느리게 뱉는 대신, 작고 빠른 드래프트 모델이 여러 토큰을 미리 추측해 두면, 큰 모델은 그 추측을 한 번의 계산으로 검증만 한다. 맞은 만큼은 공짜로 건너뛰니 전체 속도가 2~3배 빨라진다.

중요한 건 출력이 바뀌지 않는다는 점이다. 검증 단계가 수학적으로 "큰 모델 혼자 돌렸을 때와 똑같은 확률분포"를 보장한다(거절 샘플링). 즉 품질 손실 0으로 속도만 얻는다.

이 레포는 단순히 "드래프트 모델 하나"를 주는 게 아니라, 드래프트 모델을 밑바닥부터 만들어 쓰는 전 과정을 담은 풀스택이다: ① 학습 데이터 준비(프롬프트 다운로드 → 타깃 모델로 정답 재생성 → 은닉상태 캐시), ② 드래프트 모델 학습(지식 증류), ③ 9개 벤치마크로 "토큰을 평균 몇 개나 한 번에 통과시키는지(가속비)" 평가. 같은 틀 안에서 DSpark·DFlash·Eagle3 세 알고리즘을 갈아끼우며 비교한다.

용어 카드
추측 디코딩 (Speculative Decoding)
작은 "드래프트 모델"이 다음 토큰 여러 개를 미리 제안하고, 큰 "타깃 모델"이 그 제안을 한 번의 forward로 검증해 맞은 만큼 한꺼번에 채택하는 추론 가속 기법. 틀린 토큰부터는 버리고 타깃이 직접 다시 뽑는다.
용어 카드
드래프트 모델 / 타깃 모델 (Draft / Target)
타깃 = 우리가 진짜 쓰고 싶은 크고 똑똑한 모델(예: Qwen3-4B/8B/14B, Gemma). 드래프트 = 타깃의 다음 토큰을 빠르게 흉내 내도록 학습시킨 작은 보조 모델. 드래프트가 타깃과 비슷할수록 더 많이 통과돼 더 빨라진다.
용어 카드
가속비 / 채택 길이 (Acceptance Length, τ)
타깃 한 번 호출당 평균 몇 개의 토큰이 확정되는가. 드래프트가 K개를 제안해 평균 τ개가 통과되면 대략 τ배 빨라진다. DeepSpec 평가의 핵심 지표가 바로 이 값이다.

2왜 주목받는가

트렌딩 이유, 경쟁 구현 대비 장점.

첫째, "DeepSeek"이라는 이름이다. 프론티어급 오픈 모델을 내놓는 연구소가 추론 가속 코드를 공개하면 자연히 시선이 쏠린다. 둘째, 추론 비용이 곧 돈인 시대에 품질 손실 없이 2~3배 가속은 모두가 원하는 것이다. 셋째, 이 레포는 드래프트 모델 분야의 최신 알고리즘 세 가지를 하나의 공정한 비교 틀에 모아놓았다는 점에서 연구자에게 특히 매력적이다.

특히 DSpark는 DeepSeek이 이 레포와 함께 공개한 자체 알고리즘(논문 PDF 동봉)으로, 기존 Eagle 계열이 토큰을 한 개씩 사슬처럼(autoregressive) 뽑던 방식을 깨고 블록을 한 번에 병렬로 제안한다. 거기에 "Markov head"와 "Confidence head"라는 두 개의 작은 보조 장치로 병렬화의 약점을 메운다(아래 4번에서 자세히).

세 알고리즘 한눈에

알고리즘드래프트 방식특징 / 출처
Eagle3자기회귀(토큰 1개씩 사슬)가장 검증된 표준. 외부 SpecForge 코드를 차용·적응. 타깃의 여러 층 특징을 합쳐 씀
DFlash경량 드래프트 레시피외부 z-lab/dflash의 설계·학습법을 반영. 더 가벼운 구성
DSpark블록 병렬(여러 토큰 동시)DeepSeek 자체 신작. Markov+Confidence head로 병렬 드래프트의 의존성·조기중단 보완
차별점
"손실 없는(lossless)" 가속을 수학으로 보장

드래프트가 틀려도 결과 품질은 떨어지지 않는다. 검증 단계의 거절 샘플링이 "타깃 모델 혼자 돌렸을 때와 정확히 같은 출력 분포"를 보장하기 때문이다. 빨라지지만 답이 달라지지 않는다 — 이게 추측 디코딩이 안전하게 쓰이는 이유다.

차별점
공정한 비교를 위한 "한 지붕 세 알고리즘"

데이터 파이프라인·학습 루프·평가 벤치마크를 공유하므로, 세 알고리즘의 차이가 알고리즘 자체에서만 나온다. 논문 표(Table 1) 재현용 사전학습 체크포인트도 Hugging Face로 함께 공개해, "말로만 빠르다"가 아니라 숫자로 검증 가능하다.

함정 주의
"가벼운 추론 도구"가 아니라 "무거운 연구 파이프라인"

이름만 보면 inference 라이브러리 같지만, 본질은 드래프트 모델을 처음부터 학습시키는 코드다. 기본 설정의 학습 데이터 캐시(타깃 은닉상태 저장)는 약 38TB의 디스크를 먹고, 기본 스크립트는 8×GPU 단일 노드를 가정한다. "내 노트북에서 바로 돌리는 가속기"가 아니다.

3기술 스택 전체 지도

백엔드(학습/추론)·도구·데이터 파이프라인.

순수 Python + PyTorch 생태계다. 프론트엔드(웹 UI)는 없다 — 전부 학습/평가 스크립트와 모델 코드다. 핵심은 PyTorch의 분산학습(FSDP)·컴파일(torch.compile)·FlexAttention을 적극 활용한다는 점이다.

레이어기술 / 버전역할
딥러닝 코어PyTorch 2.9.1모델·학습·분산·컴파일 전부의 토대. flex_attention으로 커스텀 어텐션 마스크 사용
모델 허브transformers 5.10.2타깃 모델(Qwen3·Gemma) 로드, AutoConfig/DynamicCache(KV 캐시) 활용
분산 학습FSDP (PyTorch 내장)여러 GPU에 파라미터/그래디언트 분산. no_shard~hybrid_shard 전략 선택 가능
가속 커널triton 3.5.1융합 손실 커널 등 저수준 GPU 커널(SpecForge에서 적응)
정밀도bf16 + torch.compilebfloat16 혼합정밀 + 그래프 컴파일로 학습 속도/메모리 최적화. 자체 BF16Optimizer
저장 포맷safetensors 0.7.0체크포인트 안전 직렬화
로깅/시각화tensorboard 2.20.0 · matplotlib학습 메트릭, 캘리브레이션 신뢰도 다이어그램(reliability diagram) 그림 출력
데이터 준비datasets 4.8.5 · openai 2.6.1open-perfectblend 데이터 로드 + OpenAI 호환 API로 타깃 답변 재생성
추론 서버(외부)SGLang / vLLM (선택)데이터 준비 때 타깃 모델을 OpenAI 호환 /v1로 서빙. requirements 밖, 별도 설치
설정 시스템순수 Python .py configYAML 대신 파이썬 파일로 설정. --opts "key.path=value"로 개별 필드 오버라이드
용어 카드
FSDP (Fully Sharded Data Parallel)
모델의 파라미터·그래디언트·옵티마이저 상태를 여러 GPU에 잘게 쪼개(shard) 나눠 갖는 분산학습 방식. 한 GPU에 안 들어가는 큰 모델도 여러 장을 합쳐 학습할 수 있다. DeepSpec은 드래프트 모델 크기에 맞춰 샤딩 전략을 고를 수 있게 했다.
용어 카드
FlexAttention
PyTorch 2.5+에서 들어온, 어텐션의 "누가 누구를 볼 수 있는지(마스크)"를 함수로 자유롭게 정의하고도 빠른 커널로 돌려주는 기능. DeepSpec은 블록 드래프트 특유의 복잡한 마스크(앵커 문맥 + 블록 내부만 보기)를 이걸로 구현한다.

4아키텍처 심화 분석

먼저 전체 그림 → 그다음 흐름 한 줄기를 끝까지 추적.

① 전체 그림 — 3단계 파이프라인

DeepSpec은 "데이터 준비 → 학습 → 평가" 세 단계가 일렬로 이어진다. 각 단계의 출력이 다음 단계의 입력이 된다.

┌──────────────────────── 1. 데이터 준비 (scripts/data) ────────────────────────┐ │ │ │ open-perfectblend 타깃 모델(Qwen3-4B)을 타깃의 은닉상태를 │ │ 프롬프트 데이터 → SGLang 서버로 띄워 → 미리 계산해 디스크에 │ │ 다운로드·분할 답변 재생성(regenerate) 캐시 (≈ 38TB!) │ │ download_and_split generate_train_data prepare_target_cache │ └───────────────────────────────────────────┬──────────────────────────────────┘ │ target_cache (은닉상태 모음) ▼ ┌──────────────────────── 2. 학습 (train.py · trainer/) ────────────────────────┐ │ 캐시를 읽어 "드래프트가 타깃을 흉내 내도록" 증류 학습 │ │ GPU마다 워커 1개(spawn) · FSDP 분산 · bf16 · torch.compile │ │ 손실 = CE(토큰) + L1(분포) + BCE(confidence) │ │ → ~/checkpoints/<project>/<exp>/step_* 에 체크포인트 저장 │ └───────────────────────────────────────────┬──────────────────────────────────┘ │ 학습된 드래프트 체크포인트 ▼ ┌──────────────────────── 3. 평가 (eval.py · eval/) ────────────────────────────┐ │ 드래프트+타깃을 붙여 실제 추측 디코딩을 돌리고 │ │ 9개 벤치마크에서 "평균 채택 길이 τ(=가속비)" 측정 │ │ gsm8k · math500 · aime25 · humaneval · mbpp · livecodebench · ... │ └──────────────────────────────────────────────────────────────────────────────┘

② 흐름 한 줄기 추적 — "토큰을 한 묶음 생성하는 한 스텝"

평가/추론에서 실제로 토큰이 어떻게 빨리 나오는지, 대표 흐름 하나를 손으로 따라가 보자. 핵심은 제안 → 검증 → 거절샘플링 → 커밋 네 박자다.

[현재까지 확정된 문장] …"오늘 날씨가" │ │ ① 드래프트가 블록(예: 7토큰)을 한 번에 제안 (deepspec/eval/dspark/draft_ops.py) ▼ draft: ["참", "맑고", "따뜻", "해서", "산책", "을", "갔다"] + 각 토큰의 확률 p_draft │ │ ② 타깃이 이 블록을 "단 한 번의 forward"로 검증 (verify_draft_tokens) ▼ 타깃 확률 p_target 획득 비교: 각 자리에서 accept_prob = min(1, p_target / p_draft) │ │ ③ 왼쪽부터 차례로 채택, 처음 틀린 자리에서 멈춘다 ▼ 채택: "참" "맑고" "따뜻" "해서" ✓✓✓✓ → "산책"에서 거절 ✗ │ │ ④ 거절된 자리는 "잔차분포"에서 타깃이 직접 1개 샘플 (sample_residual) ▼ 확정: …"오늘 날씨가 참 맑고 따뜻해서" + (타깃이 뽑은 새 토큰) └─ 타깃 1번 호출로 5토큰 확정 → 그만큼 가속!

여기서 마법은 ②~④다. 타깃을 토큰마다 부르지 않고 블록 전체를 한 번에 검증한다(트랜스포머는 여러 토큰을 한 번에 처리하는 게 한 개씩 처리하는 것과 비용이 비슷하다 — 그게 GPU가 잘하는 일이다). 그리고 ④의 잔차 샘플링이 "손실 없음"을 보장한다.

왜 품질이 안 떨어지나
거절 샘플링 = 출력 분포 보존의 수학

"채택 확률 min(1, p_target/p_draft)로 받고, 거절되면 max(0, p_target − p_draft)를 정규화한 분포에서 다시 뽑는다"는 절차는, 최종적으로 토큰이 정확히 p_target에서 뽑힌 것과 동일함이 증명돼 있다(Leviathan 2023, Chen 2023). 그래서 드래프트가 아무리 엉터리여도 답의 품질은 타깃 단독과 같다 — 단지 적게 맞히면 덜 빨라질 뿐.

# deepspec/utils/sampling.py — 손실 없는 가속의 핵심 한 토막
# 채택 판정 (verify_draft_tokens 내부)
accept_prob = clamp(p_target(x) / p_draft(x), max=1.0)   # x = 드래프트가 제안한 토큰
accepted    = (rand() < accept_prob)                      # 동전 던지기

# 거절된 자리: 잔차분포에서 타깃이 직접 뽑음 → 분포 보존
residual = clamp(p_target - p_draft, min=0.0)
residual = residual / residual.sum()                      # 정규화
next_token = sample(residual)

③ DSpark는 무엇이 다른가 — "블록 병렬"의 약점 메우기

Eagle3는 토큰을 한 개씩 사슬로 뽑는다(정확하지만 드래프트도 그만큼 여러 번 돈다). DSpark는 한 블록을 동시에 뽑아 드래프트 호출 수를 줄인다. 문제는, 동시에 뽑으면 "앞 토큰이 뭐가 나왔는지"를 못 보고 뽑으니 서로 어긋나기 쉽다는 점. DSpark는 작은 보조 장치 두 개로 이걸 보완한다.

설계 패턴
앵커 + 블록 + 마스크 토큰 (Block Drafting)
문장 속 여러 "앵커(기준 위치)"를 잡고, 각 앵커 뒤에 block_size개의 빈 자리(mask 토큰)를 놓아 한 번에 채운다. 마치 빈칸 채우기 시험지를 동시에 푸는 것. 어텐션 마스크는 "내 블록 안 + 앵커 이전 문맥"만 보도록 FlexAttention으로 제한한다.
설계 패턴
Markov head (마르코프 헤드)
블록을 동시에 뽑으면 "바로 앞 토큰"의 정보가 빠진다. Markov head는 "직전 토큰 → 다음 토큰" 편향을 저랭크(low-rank) 행렬로 싸게 더해, 병렬로 뽑으면서도 인접 토큰 의존성을 살린다. vanilla(단순)·gated(게이트)·rnn(상태 유지) 세 종류가 있다.
설계 패턴
Confidence head (신뢰도 헤드)
"이 자리의 추측이 타깃에 채택될 확률"을 드래프트가 스스로 예측하는 작은 머리. 추론 때 신뢰도가 낮으면 블록을 일찍 끊어(early-stop) 헛수고를 줄인다. 평가에서는 이 예측이 실제 채택률과 얼마나 잘 맞는지 ECE·AUROC·Brier로 검증한다(캘리브레이션).
설계 패턴
다층 특징 융합 (target_layer_ids)
드래프트는 타깃의 마지막 층만이 아니라 여러 중간층(예: [1,9,17,25,33])의 은닉상태를 이어붙여 입력으로 쓴다. 모델의 "생각 과정" 여러 단면을 보면 다음 토큰을 더 잘 흉내 낼 수 있다. Eagle3에서 온 아이디어로, 그래서 타깃 캐시가 그렇게 커진다(층마다 저장).

5디렉토리 구조 해부

어디에 무엇이 있나 (약 9천 줄 Python).

DeepSpec/ ├── train.py ← 학습 진입점 (GPU마다 워커 spawn) ├── eval.py ← 평가 진입점 (드래프트 아키텍처 보고 평가기 선택) ├── DSpark_paper.pdf ← DSpark 알고리즘 논문 (자체 공개) ├── requirements.txt ← torch 2.9 / transformers 5.10 / triton ... │ ├── config/ ← 설정 = 파이썬 파일 (알고리즘 × 타깃모델) │ ├── dspark/ dspark_qwen3_4b.py · _8b · _14b · gemma4_12b │ ├── dflash/ dflash_qwen3_4b.py · ... │ └── eagle3/ eagle3_qwen3_4b.py · ... │ ├── deepspec/ ← 핵심 패키지 │ ├── data/ ← 캐시 데이터셋·프리페처·파서 │ ├── modeling/ ← 모델 정의 (알고리즘별 × 타깃별) │ │ ├── dspark/ ← common·loss·markov_head + qwen3/ gemma4/ │ │ └── eagle3/ ← common·loss + qwen3/ gemma4/ │ ├── trainer/ ← 학습 루프 (base + dspark + eagle3 + 체크포인트) │ ├── eval/ ← 추측 디코딩 평가 루프 + confidence 캘리브레이션 │ └── utils/ ← 분산·옵티마이저·샘플링·메트릭·설정 로더 │ ├── scripts/ │ ├── data/ download_and_split · generate_train_data · prepare_target_cache │ ├── train/ train.sh │ └── eval/ eval.sh │ └── eval_datasets/ ← 9개 벤치마크 (jsonl) + 변환 스크립트
경로역할
train.py설정 로드 → torch.multiprocessing.spawn으로 GPU당 워커 1개 → trainer.train(). git 상태/diff도 찍어 재현성 확보
eval.py드래프트 체크포인트의 아키텍처 이름을 읽어 알맞은 Evaluator 선택(Qwen3/Gemma4 × DSpark/Eagle3), 9개 태스크 실행
modeling/dspark/loss.pyDSpark 손실 = CE + L1 + confidence BCE. 위치 감쇠 가중치·분산 all-reduce 처리
modeling/dspark/markov_head.pyVanilla / Gated / RNN 세 가지 Markov head 구현 + build_markov_head 팩토리
modeling/dspark/common.py앵커 샘플링·블록 어텐션 마스크(FlexAttention)·noise 임베딩 등 블록 드래프트 핵심 유틸
trainer/base_trainer.pyFSDP 셋업·학습 스케줄·그래디언트 누적·체크포인트·재개(resume) 공통 로직
eval/base_evaluator.pyverify_draft_tokens(채택/거절)·생성 루프·가속비 집계 — 추측 디코딩의 심장
eval/dspark/confidence_head.py신뢰도 예측의 캘리브레이션 측정(ECE·AUROC·Brier) + 신뢰도 다이어그램 PNG 출력
utils/sampling.pysample_residual 등 — 거절 샘플링의 잔차 분포 처리
config/*/*.py알고리즘×타깃 조합별 하이퍼파라미터. --opts "key=value"로 즉석 오버라이드

6학습 포인트 (기술별)

이 레포로 무엇을 배울 수 있나 + 실습 아이디어.

학습 포인트 ①

추측 디코딩의 진짜 작동 원리

교과서 설명만 읽으면 "왜 손실이 없지?"가 안 와닿는다. 이 레포의 verify_draft_tokens를 따라 읽으면 채택 확률·잔차 샘플링·EOS 처리·KV 캐시 되감기(crop)까지 한 함수에 다 들어 있어 한눈에 잡힌다.

실습: 200줄짜리 미니 추측 디코딩을 직접 짜보기 — GPT-2 small을 드래프트, GPT-2 large를 타깃으로 두고 채택 길이를 출력해보면 가속이 체감된다.
학습 포인트 ②

지식 증류(distillation) 손실 설계

드래프트는 "정답 토큰"만 따라하면 안 되고 "타깃의 확률분포"까지 닮아야 한다(그래야 채택률이 오른다). DSpark 손실이 그 균형을 보여준다.

# modeling/dspark/loss.py (개념 요약)
loss = α_ce · CE(draft_logits, target_id)            # 어떤 토큰인지 (분류)
     + α_l1 · L1(softmax(draft), softmax(target))     # 분포가 닮았는지
     + α_cf · BCE(confidence, accept_rate)            # 채택률 자기예측
# 블록 뒤쪽 자리일수록 가중치 ↓  (decay = exp(-k / γ))
실습: config에서 l1_loss_alpha를 0으로 두고(=CE만) 학습해, 분포 매칭을 끄면 채택 길이 τ가 얼마나 떨어지는지 비교.
학습 포인트 ③

PyTorch 분산학습(FSDP) 실전 코드

장난감 예제가 아니라 실제로 도는 FSDP 셋업을 볼 수 있다. no_shard / shard_grad_op / full_shard / hybrid_shard 전략, 혼합정밀(bf16), 그래디언트 누적, 글로벌/로컬 배치 계산식이 base_trainer.py에 정리돼 있다.

실습: global_batch_size = world_size × local_batch_size × grad_accum 관계를 코드에서 찾아, GPU 4장·local 2일 때 grad_accum이 몇이 되는지 손으로 맞춰보기.
학습 포인트 ④

FlexAttention으로 커스텀 마스크 만들기

"블록 안 토큰끼리 + 앵커 이전 문맥만 보기"라는 특이한 어텐션 규칙을 create_dspark_attention_maskmask_mod 함수 하나로 표현한다. 어텐션을 손으로 다뤄보고 싶은 사람에게 좋은 실전 예제.

실습: mask_mod의 조건을 종이에 그려보고, block_size를 1로 줄이면 일반 인과(causal) 어텐션과 같아지는지 확인.
학습 포인트 ⑤

"예측이 잘 맞나" 캘리브레이션 측정

Confidence head가 내놓는 채택 확률이 실제와 얼마나 일치하는지를 ECE·AUROC·Brier·신뢰도 다이어그램으로 잰다. 분류 모델의 신뢰도 평가 기법을 통째로 배울 수 있는 드문 실전 코드(eval/dspark/confidence_head.py).

실습: ECE(기대 캘리브레이션 오차)가 무엇인지 정의를 찾고, reliability diagram에서 점들이 대각선에 가까울수록 왜 "잘 보정됨"인지 설명해보기.

7시스템 요구사항 · 실행

순수 소프트웨어지만 "연구급" 자원을 전제한다.

항목요구사항 / 권장
GPU기본 설정은 단일 노드 8×GPU 가정(80GB급). 적으면 CUDA_VISIBLE_DEVICES로 줄이고 local_batch_size 조정
디스크타깃 캐시 ≈ 38TB(Qwen3-4B 기본). 데이터 양·시퀀스 길이·캡처 층 수에 비례. 줄이려면 target_layer_ids를 줄이거나 데이터 축소
Python/런타임PyTorch 2.9.1 + CUDA 빌드(자기 환경에 맞는 휠 설치). pip install -r requirements.txt
데이터 준비용SGLang(또는 vLLM/TGI 등 OpenAI 호환 엔진) 별도 설치 — pip install "sglang[all]". requirements 밖
타깃 모델Qwen3-4B / 8B / 14B, google/gemma-4-12B-it 지원. 드래프트는 이 타깃에 맞춰 학습
출력 위치체크포인트 ~/checkpoints/<project>/<exp>/step_*, 텐서보드 ~/tensorboard/...

3단계 실행은 스크립트 한 줄씩이다(순서 중요):

# 1) 데이터 준비 (프롬프트→타깃답변 재생성→캐시)  ※ 디스크 38TB 주의
bash scripts/data/prepare_data.sh

# 2) 드래프트 모델 학습 (config로 알고리즘·타깃 선택)
bash scripts/train/train.sh
#   내부: python train.py --config config/dspark/dspark_qwen3_4b.py \
#                         --opts "data.target_cache_path=..."

# 3) 평가 (9개 벤치마크에서 가속비 τ 측정)
bash scripts/eval/eval.sh
함정 주의
"공개 체크포인트로 평가만" 하는 길도 있다

38TB 캐시 + 8GPU 학습이 부담되면, README의 Released Checkpoints(Hugging Face의 deepseek-ai/dspark_qwen3_4b_block7 등)를 draft_name_or_path에 넣어 평가만 돌려볼 수 있다. 단, 그래도 타깃 모델을 GPU에 올려야 하므로 추론용 GPU는 필요하다.

8직접 해볼 수 있는 실습 과제

난이도순으로. 작은 것부터 손에 익히자.

1. 추측 디코딩 "한 스텝"을 종이에 그려보기 난이도 ★☆☆ 입문

드래프트가 5토큰을 제안하고 그중 3개가 통과, 4번째에서 거절되는 상황을 직접 그려보자. 채택 확률 min(1, p_target/p_draft)와 잔차 샘플링이 각 자리에서 어떻게 작동하는지 손으로 계산. 코드 한 줄 없이 개념을 잡는 단계.

2. config 읽고 하이퍼파라미터 의미 해독 난이도 ★☆☆ 입문

config/dspark/dspark_qwen3_4b.py를 열어 block_size=7, num_draft_layers=5, markov_rank=256, 손실 가중치(ce/l1/confidence alpha)가 각각 무엇을 조절하는지 주석으로 정리. 이 레포의 "조절판"을 파악하는 단계.

3. 미니 추측 디코딩 직접 구현 난이도 ★★☆ 중급

transformers만으로 200줄 이내 추측 디코딩을 짠다. 드래프트=작은 모델, 타깃=큰 모델. sample_residual 로직을 그대로 옮기고, "그냥 타깃 단독"과 출력이 같은지 + 평균 채택 길이 τ를 출력. 손실 없음을 눈으로 확인하는 단계.

4. 공개 체크포인트로 벤치마크 재현 난이도 ★★☆ 중급

HF의 dspark_qwen3_4b_block7을 받아 eval.sh로 gsm8k·humaneval에서 τ를 측정하고, README/논문 Table 1 수치와 비교. (GPU 필요) 평가 파이프라인을 실제로 굴려보는 단계.

5. Markov head 종류 바꿔 채택률 비교 난이도 ★★★ 고급

작은 데이터로 markov_head_typevanilla → gated → rnn으로 바꿔가며 학습하고, 셋의 채택 길이·학습 비용을 비교. "더 똑똑한 head가 항상 이득인가?"를 실험으로 답하는 단계(자원 소요 큼 — 축소 데이터 권장).

9관련 기술 심화 학습 로드맵

추측 디코딩을 제대로 파고드는 4주 코스.

주차주제학습 자료 / 행동
1주차추측 디코딩 기초Leviathan(2023)·Chen(2023) 논문 읽기 → 손실 없음 증명 이해 → 미니 구현(실습 3)
2주차드래프트 모델 계열Medusa·Eagle·Eagle3 비교 → "다층 특징 융합"이 왜 채택률을 올리는지 → DeepSpec eagle3 코드 정독
3주차병렬 드래프트 + DSparkDSpark_paper.pdf 정독 → 블록 드래프트·Markov/Confidence head → modeling/dspark 코드와 대조
4주차분산학습 · 캘리브레이션FSDP 공식 문서 → base_trainer 정독 → ECE/AUROC/Brier 개념 → confidence_head.py로 신뢰도 평가

10핵심 키워드 사전

레포에 등장하는 용어 빠른 참조.

용어의미
Speculative Decoding작은 드래프트가 여러 토큰을 미리 제안하고 큰 타깃이 한 번에 검증해 가속하는 기법. 출력 분포는 보존
Draft / Target드래프트=빠른 보조 모델, 타깃=실제로 쓰는 큰 모델
Acceptance Length (τ)타깃 1회 호출당 평균 확정 토큰 수. 클수록 가속이 큼. DeepSpec 평가의 주 지표
Rejection Sampling채택 min(1,p_t/p_d) + 거절 시 잔차분포 재샘플 → 손실 없음 보장
Block Drafting한 블록(여러 토큰)을 동시에 제안하는 DSpark 방식. 드래프트 호출 수 절감
Markov head직전 토큰 의존성을 저랭크로 싸게 더해 병렬 드래프트의 어긋남을 보정
Confidence head각 자리 채택 확률을 자기예측 → 조기중단. 캘리브레이션으로 신뢰도 검증
Target Cache타깃의 은닉상태를 미리 계산해 디스크에 저장(≈38TB). 학습 때 타깃 재실행을 피함
FSDP파라미터/그래디언트를 여러 GPU에 분산하는 학습 방식
FlexAttention커스텀 어텐션 마스크를 함수로 정의하고 빠르게 도는 PyTorch 기능
ECE / AUROC / Brier예측 확률이 실제와 얼마나 맞는지 재는 캘리브레이션 지표들
open-perfectblend학습 프롬프트로 쓰는 공개 혼합 데이터셋(mlabonne)

11참고 링크

원문·논문·연관 프로젝트.