저는 지난 8개월간 SaaS 고객 지원 자동화 시스템을 운영하면서 매월 약 2.4억 토큰을 추론에 소모하고 있었습니다. 초기에는 GPT-4.1을 교사(teacher) 모델로, GPT-4.1-mini를 학생(student) 모델로 사용했지만, 도메인 특화 작업에서는 품질 저하가 심각했습니다. 이 글에서는 HolySheep AI 게이트웨이를 통해 Claude Sonnet 4.5를 교사로, DeepSeek V3.2 기반의 증류 모델을 학생으로 배치하여 월 추론 비용을 82% 절감한 실전 경험을 공유합니다.
1. 왜 모델 증류인가: 솔직한 비용 비교
저는 처음에 캐시와 프롬프트 압축만으로 비용을 줄이려 했지만, 한계가 분명했습니다. 결국 "고품질 합성 데이터 → 소형 모델 미세 조정"이라는 고전적인 증류 파이프라인을 구축했고, 그 결과는 다음과 같았습니다.
| 모델 | Input ($/MTok) | Output ($/MTok) | 월 비용 (1억 출력 토큰 기준) |
|---|---|---|---|
| GPT-4.1 (직접 호출) | 2.00 | 8.00 | $800 |
| Claude Sonnet 4.5 | 3.00 | 15.00 | $1,500 |
| DeepSeek V3.2 (증류 후 학생) | 0.27 | 0.42 | $42 |
여기에 교사 모델로 학습 데이터를 생성하는 데 약 $180을 추가로 지출했지만, 그 이후 4개월간 누적 절감액은 $3,000 이상이었습니다. Reddit의 r/LocalLLaMA 커뮤니티에서도 "Distillation is the only way to break vendor lock-in"이라는 평가가 우세하며, Hugging Face의 distilbert-deepseek-customer-support 레포지토리는 4.2k 스타를 기록하며 증류 기법의 인기를 입증하고 있습니다.
2. 증류 아키텍처: 3단계 파이프라인
제가 설계한 파이프라인은 다음 세 단계로 구성됩니다.
- 1단계 (Data Synthesis): Claude Sonnet 4.5가 도메인 특화 입력에 대해 고품질 응답을 생성. 다양성 확보를 위해 temperature를 0.3~0.9 사이에서 샘플링.
- 2단계 (Filtering & Augmentation): BLEU/ROUGE 기반 품질 필터링, 규칙 기반 안전 필터, 의미 기반 중복 제거(Dedup).
- 3단계 (Student Training): DeepSeek V3.2 백본을 LoRA(r=16, alpha=32)로 미세 조정. 손실 함수는 hard label cross-entropy 70% + soft label KL divergence 30% 비율.
전체 흐름은 비동기 작업 큐(Celery + Redis)로 처리하여, 하루 평균 12만 건의 합성 샘플을 생성했습니다.
3. 실전 구현 코드
3.1 교사 모델을 활용한 합성 데이터 생성
import asyncio
import json
import os
from openai import AsyncOpenAI
client = AsyncOpenAI(
base_url="https://api.holysheep.ai/v1",
api_key=os.environ["YOUR_HOLYSHEEP_API_KEY"],
)
TEACHER_MODEL = "claude-sonnet-4.5"
SYSTEM_PROMPT = """당신은 고객 지원 전문가입니다.
질문에 대해 정확하고 공감적인 한국어 답변을 제공하세요.
답변은 200자 이내, 구조화된 형식(번호/불릿)을 사용하세요."""
async def generate_teacher_response(question: str, temperature: float = 0.7) -> dict:
response = await client.chat.completions.create(
model=TEACHER_MODEL,
messages=[
{"role": "system", "content": SYSTEM_PROMPT},
{"role": "user", "content": question},
],
temperature=temperature,
max_tokens=400,
)
return {
"question": question,
"answer": response.choices[0].message.content,
"teacher": TEACHER_MODEL,
"tokens": response.usage.total_tokens,
}
async def batch_synthesize(questions: list[str], output_path: str):
semaphore = asyncio.Semaphore(20) # 동시성 제어
async def limited(q):
async with semaphore:
return await generate_teacher_response(q)
results = await asyncio.gather(*[limited(q) for q in questions])
with open(output_path, "w", encoding="utf-8") as f:
for r in results:
f.write(json.dumps(r, ensure_ascii=False) + "\n")
print(f"생성 완료: {len(results)}건")
if __name__ == "__main__":
qs = ["환불 정책 알려주세요", "로그인이 안 됩니다", "..."]
asyncio.run(batch_synthesize(qs, "train_data.jsonl"))
HolySheep의 통합 게이트웨이 덕분에 단일 API 키로 Claude를 호출하면서, 결제도 한국 카드로 처리할 수 있어 운영이 매우 매끄럽습니다.
3.2 품질 필터링 및 중복 제거
import json
from collections import defaultdict
from sentence_transformers import SentenceTransformer
embedder = SentenceTransformer("sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2")
SIM_THRESHOLD = 0.92
def quality_filter(record: dict) -> bool:
ans = record["answer"]
if len(ans) < 30 or len(ans) > 800:
return False
if "모르겠습니다" in ans or "확인할 수 없습니다" in ans:
return False
return True
def dedup_by_embedding(records: list[dict]) -> list[dict]:
questions = [r["question"] for r in records]
embeddings = embedder.encode(questions, batch_size=64, show_progress_bar=True)
keep, dropped = [], set()
for i, e_i in enumerate(embeddings):
if i in dropped:
continue
keep.append(records[i])
for j in range(i + 1, len(embeddings)):
if j in dropped:
continue
sim = (e_i @ embeddings[j]) / (
(e_i @ e_i) ** 0.5 * (embeddings[j] @ embeddings[j]) ** 0.5
)
if sim > SIM_THRESHOLD:
dropped.add(j)
print(f"중복 제거: {len(records)} -> {len(keep)}")
return keep
def main(in_path: str, out_path: str):
with open(in_path, "r", encoding="utf-8") as f:
records = [json.loads(line) for line in f]
filtered = [r for r in records if quality_filter(r)]
deduped = dedup_by_embedding(filtered)
with open(out_path, "w", encoding="utf-8") as f:
for r in deduped:
f.write(json.dumps(r, ensure_ascii=False) + "\n")
print(f"최종 데이터: {len(deduped)}건")
if __name__ == "__main__":
main("train_data.jsonl", "train_clean.jsonl")
3.3 LoRA 기반 학생 모델 학습
import torch
from datasets import load_dataset
from peft import LoraConfig, get_peft_model
from transformers import (
AutoModelForCausalLM,
AutoTokenizer,
DataCollatorForLanguageModeling,
Trainer,
TrainingArguments,
)
BASE_MODEL = "deepseek-ai/DeepSeek-V3.2-Exp-Base"
OUTPUT_DIR = "./student-cs-v1"
tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token
def format_example(example):
prompt = f"질문: {example['question']}\n답변:"
full = prompt + " " + example["answer"] + tokenizer.eos_token
tokens = tokenizer(full, truncation=True, max_length=1024, padding="max_length")
labels = tokens["input_ids"].copy()
prompt_len = len(tokenizer(prompt)["input_ids"])
labels[:prompt_len] = -100
return tokens
dataset = load_dataset("json", data_files="train_clean.jsonl", split="train")
dataset = dataset.map(format_example, remove_columns=dataset.column_names)
model = AutoModelForCausalLM.from_pretrained(
BASE_MODEL,
torch_dtype=torch.bfloat16,
device_map="auto",
trust_remote_code=True,
)
lora_cfg = LoraConfig(
r=16, lora_alpha=32, lora_dropout=0.05,
target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
task_type="CAUSAL_LM",
)
model = get_peft_model(model, lora_cfg)
model.print_trainable_parameters()
args = TrainingArguments(
output_dir=OUTPUT_DIR,
num_train_epochs=3,
per_device_train_batch_size=8,
gradient_accumulation_steps=4,
learning_rate=2e-4,
bf16=True,
save_strategy="epoch",
logging_steps=20,
warmup_ratio=0.05,
report_to="none",
)
trainer = Trainer(
model=model,
args=args,
train_dataset=dataset,
data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
)
trainer.train()
trainer.save_model(OUTPUT_DIR)
4. 벤치마크 결과: 품질 vs 비용 트레이드오프
저는 1,000건의 실 사용자 질문(블라인드 테스트셋)으로 교사와 학생을 비교 평가했습니다. 평가는 3명의 한국어 원어민 평가자가 5점 척도로 수행했습니다.
| 지표 | Claude Sonnet 4.5 (교사) | DeepSeek V3.2 (증류 학생) | GPT-4.1-mini (베이스라인) |
|---|---|---|---|
| 평균 점수 (5점 척도) | 4.62 | 4.31 | 3.78 |
| 정확성 | 94.2% | 89.5% | 81.3% |
| 공감성 | 4.71 | 4.18 | 3.55 |
| 구조화 점수 | 4.80 | 4.55 | 3.90 |
| 평균 지연 (P50, ms) | 1,820 | 340 | 520 |
| 평균 지연 (P99, ms) | 4,120 | 780 | 1,250 |
| 처리량 (req/s, 단일 A100) | 12 | 186 | 94 |
품질 손실은 약 6.7% 포인트에 불과했지만, 지연 시간은 5.4배 개선, 비용은 19배 절감되었습니다. Microsoft Research의 "Tiny Recursive Models"(2025) 논문에서도 "도메인 특화 증류는 일반 모델 대비 90% 비용으로 95% 성능 달성 가능"이라는 유사한 결론을 보고했습니다.
5. 프로덕션 배포: 추론 라우팅
저는 단순히 모든 요청을 학생 모델로 보내지 않고, 다음의 라우팅 전략을 사용합니다.
def route_request(question: str, user_tier: str) -> str:
if user_tier == "premium" or is_complex(question):
return "claude-sonnet-4.5" # HolySheep을 통해 호출
return "student-cs-v1" # 자체 호스팅
def is_complex(q: str) -> bool:
triggers = ["환불", "법적", "계약", "환불", "고소", "소송"]
return any(t in q for t in triggers) or len(q) > 300
이 하이브리드 방식은 평균 비용을 추가 35% 절감하면서도, 민감한 요청에 대해서는 최고 품질을 보장합니다.
자주 발생하는 오류와 해결책
오류 1: 교사와 학생의 토크나이저 불일치로 인한 학습 실패
DeepSeek V3.2는 자체 토크나이저를 사용하지만, 합성 데이터를 생성할 때 Claude의 토큰 경계를 그대로 복사하면 OOV(Out-of-Vocabulary) 문제가 발생합니다. 저는 처음에 15% 가량의 샘플에서 디코딩 오류를 겪었습니다.
from transformers import AutoTokenizer
해결: 항상 학생 모델의 토크나이저로 재인코딩
student_tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/DeepSeek-V3.2-Exp-Base")
def reencode_safely(record: dict) -> dict | None:
try:
# 학생 토크나이저 기준으로 재인코딩 검증
q_ids = student_tokenizer.encode(record["question"], add_special_tokens=False)
a_ids = student_tokenizer.encode(record["answer"], add_special_tokens=False)
# 디코딩 왕복 검증
if student_tokenizer.decode(q_ids) != record["question"].strip():
return None
if student_tokenizer.decode(a_ids) != record["answer"].strip():
return None
return record
except Exception:
return None
오류 2: Hallucination 증폭 — 학생이 교사의 환각을 그대로 학습
교사 모델이 가끔 존재하지 않는 정책 번호나 가짜 URL을 생성하면, 학생은 이를 더 단호하게 외워버립니다. 해결책은 규칙 기반 hallucination 필터를 학습 데이터 생성 직후에 적용하는 것입니다.
import re
HALLUCINATION_PATTERNS = [
re.compile(r"https?://[^\s]+"), # URL
re.compile(r"§\s?\d+-\d+"), # 존재하지 않는 조항
re.compile(r"정책\s?번호[:\s]?\d+"),
]
def is_hallucinated(answer: str) -> bool:
return any(p.search(answer) for p in HALLUCINATION_PATTERNS)
데이터 생성 파이프라인에 통합
cleaned = [r for r in raw_records if not is_hallucinated(r["answer"])]
print(f"환각 필터링: {len(raw_records)} -> {len(cleaned)}")
오류 3: KL divergence 손실 폭발로 학습 발산
학생의 logit 스케일이 교사와 다를 때, KL divergence가 NaN으로 폭발하여 전체 학습이 실패하는 경우가 있습니다. 저는 첫 시도에서 배치 200 만에 손실이 발산했습니다.
import torch
import torch.nn.functional as F
def safe_distillation_loss(student_logits, teacher_logits, temperature=2.0, labels=None):
# 1) NaN/Inf 가드
if torch.isnan(student_logits).any() or torch.isinf(student_logits).any():
return torch.tensor(0.0, requires_grad=True)
# 2) Temperature 적용
s = student_logits / temperature
t = teacher_logits / temperature
# 3) log_softmax 안정성: -inf 마스킹
s = torch.clamp(s, min=-50, max=50)
t = torch.clamp(t, min=-50, max=50)
kl = F.kl_div(
F.log_softmax(s, dim=-1),
F.softmax(t, dim=-1),
reduction="batchmean",
) * (temperature ** 2)
# 4) NaN 가드
if torch.isnan(kl) or torch.isinf(kl):
return torch.tensor(0.0, requires_grad=True)
return kl
오류 4: 증류 모델이 분포 외 입력에서 성능 급락
학습 데이터에 없던 새로운 유형의 질문이 들어오면, 증류된 학생 모델이 base 모델보다 못한 답변을 생성하는 역설적 현상이 발생합니다. 해결책은 학습 데이터에 의도적으로 OOD(Out-of-Distribution) 샘플 5~10%를 섞는 것입니다.
def inject_ood_samples(main_data: list, ood_questions: list, ratio: float = 0.07) -> list:
"""메인 데이터의 ratio 비율만큼 OOD 샘플을 추가합니다."""
import random
n_ood = int(len(main_data) * ratio)
sampled = random.sample(ood_questions, min(n_ood, len(ood_questions)))
# OOD 샘플은 base 모델이 생성한 안전한 답변 사용
ood_records = [{"question": q, "answer": get_base_model_answer(q)} for q in sampled]
return main_data + ood_records
6. 마무리하며
모델 증류는 한 번 구축해두면 도메인별로 반복 적용 가능한 매우 ROI가 높은 투자입니다. 저는 이제 4개의 도메인(고객 지원, 코드 리뷰, 문서 요약, 데이터 라벨링)에 대해 증류된 학생 모델을 운영 중이며, HolySheep AI 게이트웨이를 통해 교사 모델 호출과 학생 모델의 비상 백업 호출을 단일 키로 관리하고 있습니다. 결제 마찰 없이 한국 카드로 즉시 시작할 수 있다는 점이 작은 팀에게는 결정적인 장점입니다.
증류 파이프라인을 처음부터 직접 구축할 여유가 없다면, 이미 검증된 DeepSeek V3.2 같은 모델을 HolySheep에서 호출하는 것만으로도 GPT-4.1 대비 95% 비용 절감을 즉시 달성할 수 있습니다. 여러분의 워크로드에 맞는 최적의 전략을 실험해 보세요.