지난 글까지 스키마를 어떻게 적는지를 다뤘다면, 이번에는 그 스키마가 실제로 무슨 일을 하는지를 본다. 「스키마를 넘기면 형태가 보장된다」는 문장은 결과만 말한 것이고, 그 보장이 어디에서 오는지를 알면 왜 어떤 스키마는 느린지, 왜 제약을 걸었더니 답이 더 나빠지는 경우가 있는지가 같이 설명된다. 제약 디코딩(constrained decoding)은 모델이 토큰을 하나 고를 때마다 문법상 올 수 없는 후보를 미리 지워 버리는 생성 방식이다. 이 글은 그 지우는 동작이 샘플링의 어느 자리에 끼어드는지, 무엇이 허용되는지를 누가 정하는지, 그 계산이 어디서 비싸지는지, 그리고 지우는 동작이 모델의 판단에 어떤 흔적을 남기는지를 차례로 다룬다.
로짓 마스킹
마스킹 수식
모델은 매 스텝마다 어휘 전체에 대한 점수, 즉 로짓 벡터를 낸다. 샘플링은 이 벡터를 소프트맥스로 확률로 바꿔 하나를 고르는 일이다. 제약 디코딩은 그 사이에 한 단계를 끼워 넣는다. 지금 문법상 올 수 없는 토큰의 로짓을 음의 무한대로 바꾸는 로짓 마스킹이다.
소프트맥스를 거치면 자리는 정확히 0이 된다. 온도를 아무리 올려도, top-p를 아무리 넓혀도 그 토큰은 안 뽑힌다. 「웬만하면 안 나온다」가 아니라 「나올 수 없다」인 이유가 이것이다. 프롬프트로 「반드시 JSON으로 답하라」고 부탁하는 것과 이것의 차이가 여기서 갈린다. 부탁은 확률을 옮길 뿐이고, 마스킹은 확률을 0으로 만든다.
샘플링 단계와의 순서
실제 생성 루프에는 마스킹 말고도 로짓을 손보는 단계가 여럿 있다. 이미 나온 토큰의 점수를 깎는 반복 페널티, 분포를 납작하게 하거나 뾰족하게 하는 온도, 확률이 높은 쪽부터 누적 p까지만 남기는 top-p가 그렇다. 이 단계들과 마스킹이 어떤 순서로 겹치느냐에 따라 결과가 달라진다.
가장 조심할 것은 top-p다. top-p를 마스킹보다 먼저 적용하면, 확률 상위 몇 개만 남긴 뒤 그중 허용되지 않는 것을 지우게 된다. 모델이 문법을 벗어나는 쪽에 확률을 몰아주고 있었다면 남은 후보가 전부 지워져 고를 것이 없어진다. 마스킹을 먼저 하고 허용된 후보들 안에서 top-p를 적용하면 이런 일이 없다. 그래서 구현체들은 대개 마스크를 다른 처리보다 앞에 두거나, 적어도 top-p·top-k보다는 먼저 건다. 로짓 프로세서를 직접 붙일 때는 자기 프로세서가 목록의 어디에 끼는지를 확인한다.
마스크를 씌운 뒤 소프트맥스를 다시 계산하면 남은 후보들의 확률이 합이 1이 되도록 늘어난다. 이것을 재정규화라 한다. 원래 분포에서 허용 후보들이 차지하던 비중이 작았다면, 재정규화 뒤에는 모델이 별로 원하지 않던 후보가 높은 확률을 받는다. 이 효과가 뒤의 「제약이 지우는 불확실성」 절에서 보는 부작용의 뿌리다.
로그 확률 기록
출력 토큰의 로그 확률을 남겨 두면 신뢰도 추정이나 디버깅에 쓸 수 있다. 제약 디코딩에서는 마스킹 전과 후 중 어느 값을 남길지를 정해야 한다. 마스킹 후의 값은 재정규화된 분포에서 나온 것이라, 모델이 원래 다른 데로 가고 싶어 했어도 높게 찍힌다. 「이 필드를 확신했는가」를 알고 싶다면 마스킹 전 값이 맞다.
두 값을 함께 남기면 쓸모 있는 신호가 하나 생긴다. 마스킹 전 분포에서 허용 후보 전체가 차지한 확률의 합이다. 이 값이 낮은 스텝은 모델이 문법 밖으로 나가려던 자리이고, 제약이 모델의 판단을 강하게 꺾은 자리다. 응답 하나에서 이 값이 낮은 스텝이 몰려 있는 필드는 사람이 한 번 더 볼 후보가 된다.
허용 집합
오토마톤과 스택
허용 집합, 곧 지금 올 수 있는 다음 토큰의 집합을 정하는 것은 파서다. 지금까지 생성된 문자열을 스키마로 만든 상태 기계에 넣으면 현재 상태가 나오고, 그 상태에서 나갈 수 있는 간선이 곧 허용되는 다음 문자다. 스키마를 이런 상태 기계로 바꾸는 일을 컴파일이라 부르고, 그 결과물을 오토마톤이라 한다.
JSON은 괄호가 짝을 이뤄야 하므로 순수한 유한 상태 기계로는 부족하고, 중첩 깊이를 담을 스택이 붙는다. 배열 안의 객체 안의 배열을 처리하려면 지금 어떤 괄호들이 열려 있는지를 기억해야 하기 때문이다. 스택이 붙은 상태 기계를 푸시다운 오토마톤이라 한다. 스키마의 중첩이 정해진 깊이로 끝난다면 유한 상태 기계로 펼칠 수도 있지만, 재귀하는 스키마(트리 구조의 댓글처럼 자기를 다시 담는 타입)는 스택 없이는 표현이 안 된다.
토크나이저 경계
원리만 보면 간단한데 구현이 까다로운 이유는 모델이 문자 단위로 생성하지 않기 때문이다. 어휘는 "ity, ": ", P1"처럼 여러 문자를 묶은 조각이고, 그 조각들은 JSON 문법의 경계와 전혀 맞춰져 있지 않다. 토큰 하나가 문자열을 닫고 쉼표를 찍고 다음 키의 따옴표까지 여는 일이 흔하다.
그래서 「이 상태에서 허용되는 문자」를 아는 것만으로는 마스크를 못 만든다. 어휘의 토큰 하나하나에 대해 「이 토큰을 통째로 붙이면 문법을 어기지 않고 갈 수 있는가」를 물어야 한다. 토큰의 문자를 하나씩 오토마톤에 흘려 끝까지 막히지 않으면 허용이다. 어휘가 15만 개면 상태마다 15만 번을 묻는 셈이고, 이걸 매 스텝에 하면 생성이 눈에 띄게 느려진다.
같은 문자열을 여러 토큰 열로 쪼갤 수 있다는 것도 문제다. "name"은 한 토큰일 수도, "·name·" 세 토큰일 수도 있다. 문법상으로는 둘 다 허용이지만, 모델은 학습 때 토크나이저가 만든 한 가지 쪼개기만 봤다. 제약이 낯선 쪼개기로 가는 길을 열어 두면 모델은 처음 보는 토큰 열 위에서 다음을 예측해야 하고, 그 자리에서 품질이 흔들린다. 그래서 일부 구현은 토크나이저가 실제로 만들 법한 쪼개기만 남기도록 허용 집합을 더 좁힌다.
허용 집합의 자료구조
실무 구현은 이 계산을 미리 해 두는 쪽으로 푼다. 상태별 허용 토큰 집합을 만들어 인덱스로 들고, 생성 중에는 조회만 한다. 가장 단순한 표현은 어휘 크기만큼의 비트 배열인 비트마스크다. 어휘 15만이면 상태 하나에 15만 비트, 약 19KB다. 상태가 수천 개인 스키마라면 이것만으로 수십 MB가 된다.
메모리를 줄이는 흔한 방법은 어휘를 트라이로 묶는 것이다. 공통 접두사를 가진 토큰들을 한 가지에 모아 두면, 오토마톤이 어떤 문자에서 막히는 순간 그 아래 토큰 전부를 한꺼번에 버릴 수 있다. 그리고 대부분의 상태에서는 허용 여부가 스택 내용과 상관없이 정해진다는 점을 이용해, 그런 토큰은 미리 계산해 두고 스택에 따라 달라지는 소수만 생성 중에 검사하는 방식도 쓰인다. Outlines나 XGrammar 같은 라이브러리가 이런 사전 계산을 각자의 방식으로 하고, vLLM 같은 서빙 엔진은 이 라이브러리들을 골라 붙일 수 있게 되어 있다.
정규식 pattern은 이 구조에서 가장 비싼 손님이다. 정규식은 그 자체가 상태 기계라서 스키마 오토마톤과 곱해지는데, .{0,200}처럼 반복 횟수가 큰 패턴이나 여러 선택지가 겹치는 패턴은 상태 수를 폭발시킨다. 컴파일이 수 초씩 걸리거나 메모리가 튀면 스키마의 pattern부터 본다. 길이 제한은 maxLength로 따로 걸고, 패턴은 형식 검사에 필요한 만큼만 남기는 편이 낫다.
컴파일 비용과 캐시
| 단계 | 언제 | 대략의 비용 |
|---|---|---|
| 스키마를 오토마톤으로 컴파일 | 스키마당 1회 | 수 ms ~ 수백 ms |
| 상태별 허용 토큰 인덱스 구축 | 스키마당 1회 | 스키마 복잡도에 비례 |
| 스텝마다 마스크 조회·적용 | 토큰마다 | 어휘 크기의 비트마스크 한 번 |
| 상태 전이 | 토큰마다 | 상수 시간 |
컴파일 시간 측정
토큰마다 드는 비용은 GPU에서 로짓 벡터를 다루는 시간에 비하면 무시할 만하다. 체감 지연은 거의 전부 위의 두 줄, 즉 한 번만 하면 되는 일에서 나온다. 얼마나 걸리는지는 직접 재야 한다. 표의 값은 범위가 넓고, 같은 스키마라도 라이브러리와 어휘 크기에 따라 몇 배씩 달라진다.
재는 방법은 단순하다. 쓰고 있는 스키마들을 모아 캐시를 끈 상태로 하나씩 컴파일하고, 컴파일과 인덱스 구축 시간을 따로 기록한다. 그다음 스키마의 특징 — 필드 수, 중첩 깊이, enum 값의 수, pattern의 유무 — 을 옆에 적어 두면 무엇이 시간을 먹는지가 보인다. 대개 필드 수보다 pattern과 큰 enum이 지배적이다. 이 표가 있으면 새 스키마를 들이기 전에 「이건 느리겠다」를 미리 알 수 있다.
캐시 키
그래서 실무에서 제약 디코딩이 느리다고 느껴지는 상황은 대개 하나다 — 매 요청마다 스키마를 새로 만들어 캐시가 안 맞는 것이다.
# 요청마다 새 dict가 만들어져 캐시 키가 매번 달라진다
def handle(req):
schema = {"type": "object", "properties": build_props(req.fields), ...}
return call_model(req.text, schema)
# 스키마 종류만큼만 만들어 두고 재사용한다
SCHEMAS = {
"ticket": TICKET_SCHEMA,
"invoice": INVOICE_SCHEMA,
}
def handle(req):
return call_model(req.text, SCHEMAS[req.kind])
동적으로 스키마를 조립해야 한다면 최소한 조립 결과를 키로 캐시한다. 이때 키는 객체의 주소가 아니라 구조 해시여야 한다. 스키마를 키 순서를 정렬한 정규 JSON 문자열로 바꾼 뒤 해시하면, 같은 구조를 다른 순서로 조립해도 같은 키가 나온다. 필드 설명(description)처럼 마스크에 영향을 주지 않는 부분을 빼고 해시하면 적중률이 더 오른다. 다만 설명을 모델에게 보여 주는 API라면 설명이 바뀌면 출력도 바뀌므로, 캐시 키에서만 빼고 요청에는 그대로 넣는다. 종류가 수십 개를 넘지 않는다면 이 정도로 첫 토큰 지연이 정리된다. 캐시 적중률은 지표로 남겨 두고, 갑자기 떨어지면 스키마를 조립하는 코드가 바뀌었는지부터 본다.
첫 토큰 지연 진단
운영 중에 첫 토큰 지연이 가끔씩 튀는 사고가 있다. 평균은 멀쩡한데 p99가 수백 ms씩 올라간다. 이 모양이면 캐시 미스를 의심한다. 요청마다 스키마 해시와 캐시 적중 여부, 컴파일 시간을 남겨 두면, 튄 요청들을 모았을 때 거의 전부가 미스였는지 바로 확인된다.
미스가 원인이라면 셋 중 하나다. 스키마 종류가 캐시 크기보다 많아 계속 밀려나거나, 조립 과정에 요청마다 바뀌는 값(타임스탬프, 사용자 이름이 든 설명)이 끼어 있거나, 서버가 여러 대라 캐시가 인스턴스마다 따로 있는 경우다. 마지막 경우는 배포 직후나 확장 직후에 몰려서 튀는 것으로 구별된다. 자주 쓰는 스키마를 기동할 때 미리 컴파일해 두면 이 구간이 사라진다.
빈 허용 집합
구현체별 동작
로컬 모델을 직접 돌린다면 로짓 프로세서로 같은 일을 할 수 있다. 원리를 보기에는 이쪽이 명확하다.
import torch
class SchemaMask:
"""오토마톤 상태를 들고 다니며 매 스텝 마스크를 만든다."""
def __init__(self, automaton, vocab_size: int):
self.automaton = automaton
self.state = automaton.start
self.vocab_size = vocab_size
def __call__(self, input_ids, scores):
allowed = self.automaton.allowed_tokens(self.state) # 미리 만든 인덱스
mask = torch.full((self.vocab_size,), float("-inf"), device=scores.device)
mask[allowed] = 0.0
return scores + mask
def accept(self, token_id: int) -> None:
self.state = self.automaton.step(self.state, token_id)
allowed_tokens가 빈 집합을 돌려주는 순간이 이 구조의 유일한 치명적 실패다. 모든 토큰이 막히면 소프트맥스의 분모가 0이 되어 샘플링할 것이 없다. 구현체마다 이 순간을 다르게 처리한다. 예외를 던져 요청을 실패시키는 쪽, 종료 토큰을 강제로 넣어 그 자리에서 끊는 쪽, 마스크를 무시하고 원래 분포로 한 토큰을 뽑는 쪽이 있다. 첫째는 시끄럽고, 둘째는 잘린 JSON을 남기고, 셋째는 형식 보장을 조용히 깬다. 어느 쪽인지 모르고 쓰면 장애의 모양을 예측할 수 없으니, 쓰는 라이브러리의 동작을 먼저 확인해 둔다.
사전 검사
빈 집합은 스키마와 어휘가 어긋나 있을 때 생긴다. 예를 들어 pattern이 어떤 토큰 조합으로도 만들 수 없는 문자열을 요구할 때, 또는 어휘에 없는 특수 문자를 필수로 요구할 때다. 스키마를 바꿨는데 갑자기 빈 응답이나 잘린 응답이 오기 시작하면 이 자리를 의심한다.
이런 어긋남은 생성 전에 찾을 수 있다. 컴파일한 오토마톤에서 시작 상태부터 도달 가능한 모든 상태를 훑어, 허용 토큰이 하나도 없는데 끝 상태도 아닌 상태가 있는지 본다. 그런 상태가 있으면 언젠가 생성이 그 자리에 들어가 멈춘다. 이 검사는 스키마를 등록하는 시점에 한 번 돌리면 되므로 비용이 문제 되지 않는다.
단위 테스트
로짓 프로세서를 직접 만들 때는 상태 전이를 검증하는 단위 테스트를 둔다. 스키마에 맞는 예시 JSON 몇 개를 토크나이저로 쪼갠 뒤, 토큰을 하나씩 넣으면서 매번 그 토큰이 허용 집합에 들어 있었는지 확인한다. 하나라도 빠지면 마스크가 정상 출력을 막고 있다는 뜻이다. 반대로 스키마를 어기는 예시를 넣으면 어딘가에서 허용 집합 밖의 토큰이 나와야 한다.
이 테스트에서 가장 자주 걸리는 것은 공백과 이스케이프다. JSON은 괄호와 쉼표 사이에 공백을 허용하고 문자열 안에 \"나 \u 이스케이프를 허용하는데, 오토마톤이 이걸 빠뜨리면 모델이 공백을 넣으려는 순간 막힌다. 공백을 허용하되 그 수에 상한을 두는 구현도 많다. 공백을 무한히 허용하면 모델이 공백만 끝없이 내는 고리에 빠질 수 있어서다.
제약이 지우는 불확실성
강제된 값
여기가 이 글에서 가장 실용적인 부분이다. 제약 디코딩은 형태를 보장하지만, 모델이 원래 가려던 경로를 막는 부작용이 있다.
모델이 어떤 입력에 대해 「이 문서에는 해당 정보가 없습니다」라고 답하려 했다고 하자. 스키마가 {"amount": {"type": "number"}}를 필수로 요구하면 그 경로는 통째로 막힌다. 남은 후보는 숫자뿐이고, 재정규화된 분포에서 모델은 숫자를 하나 고른다. 이때 나오는 값은 근거가 아니라 그저 확률이 가장 높았던 숫자다. 겉보기에는 자신 있게 채워진 필드이고, 파싱도 검증도 다 통과한다.
즉 제약은 모델의 불확실성을 지워 버린다. 모르는 상태 그대로 출력될 자리가 없어지고, 대신 그럴듯한 값이 들어간다. 스키마에 널 자리를 만들어 두라는 이야기의 기계 수준 근거가 이것이다. 앞에서 말한 「마스킹 전 허용 확률의 합」을 남겨 두면 이런 자리를 사후에 일부 찾아낼 수 있지만, 처음부터 모를 수 있는 자리를 스키마에 두는 편이 훨씬 싸다.
널 자리와 출처 표시
# 모델에게 "모른다"고 답할 경로를 남긴다
{
"amount": {"type": ["number", "null"]},
"amount_source": {
"type": "string",
"enum": ["문서에 명시", "계산", "찾지 못함"],
},
}
amount_source처럼 확신의 근거를 함께 적게 하면 뒷단에서 걸러 낼 수 있는 신호가 생긴다. "찾지 못함"인데 amount가 채워져 있으면 그 응답은 버린다. 출처 필드를 금액 필드보다 앞에 두는 것도 방법이다. 생성은 앞에서 뒤로 가므로, 근거를 먼저 적게 하면 그 뒤의 값이 근거에 맞춰진다.
이 장치가 실제로 얼마나 듣는지는 실험으로 잰다. 정답을 아는 문서 묶음을 준비하되, 일부러 해당 정보가 없는 문서를 섞는다. 널 자리와 출처 필드가 없는 스키마와 있는 스키마로 같은 문서를 돌려, 정보가 없는 문서에서 값을 지어낸 비율을 견준다. 그리고 모델이 스스로 모순을 적는 비율, 곧 출처는 「찾지 못함」인데 값이 들어 있는 경우가 얼마나 되는지도 센다. 이 비율이 매우 낮다면 출처 필드를 믿고 거르는 규칙을 써도 되고, 높다면 출처 필드 자체를 따로 검증해야 한다.
국소 선택의 막다른 길
두 번째 부작용은 조금 더 미묘하다. 제약은 국소적으로 작동한다. 매 스텝에서 문법을 어기지 않는 토큰만 고를 뿐, 그 선택이 나중에 막다른 골목으로 이어질지는 보지 않는다. 그래서 앞부분에서 문법적으로는 멀쩡하지만 뒤가 궁색해지는 경로로 들어가는 일이 생긴다.
긴 문자열 필드에 상한 길이가 걸려 있을 때 문장이 어색하게 끊기는 것이 대표적이다. 모델은 상한을 의식하지 않고 문장을 시작했다가, 상한에 닿는 순간 닫는 따옴표만 허용되어 문장 중간에서 끝난다. enum 값끼리 앞부분이 겹칠 때도 비슷한 일이 생긴다. "Pro"와 "Professional"이 둘 다 있으면 Pro까지 쓴 시점에서 닫는 따옴표와 f가 모두 허용되는데, 모델이 어느 쪽을 원했는지와 상관없이 그 한 스텝의 확률이 갈래를 정한다. 이 문제를 근본적으로 없애려면 앞을 내다보는 탐색이 필요한데 비용이 크므로, 실무에서는 상한을 넉넉히 두고 enum 값이 서로의 접두사가 되지 않게 짓는 쪽으로 피한다.
스트리밍 부분 파싱
유효한 접두사
제약 디코딩이 주는 덤이 하나 있다. 생성 도중의 부분 문자열이 항상 유효한 접두사, 곧 뒤를 이어 붙이면 스키마에 맞는 JSON이 될 수 있는 앞부분이라는 점이다. 그래서 스트리밍 중에 부분 파싱을 해도 안전하다. {"title": "제안서 초까지 받았을 때, 이 뒤에 무엇이 오든 title이 문자열이라는 사실은 변하지 않는다.
def stream_fields(chunks):
buf = ""
for chunk in chunks:
buf += chunk
# 제약이 걸려 있으므로 buf는 언제나 유효한 JSON 접두사다
partial = parse_partial(buf)
if "title" in partial:
yield ("title", partial["title"])
부분 파서의 규칙
접두사가 유효하다고 해서 아무 값이나 바로 화면에 내보내도 되는 것은 아니다. 부분 파서는 덜 끝난 값을 어떻게 다룰지 규칙을 가져야 한다. 닫히지 않은 문자열은 지금까지의 내용을 보여 줘도 된다 — 뒤에 글자가 더 붙을 뿐 앞이 바뀌지는 않는다. 반면 덜 끝난 숫자는 보여 주면 안 된다. 12까지 받은 값이 다음 토큰에서 125가 될 수도, 12.5가 될 수도 있다. 숫자는 뒤에 쉼표나 닫는 괄호가 와서 끝난 것이 확실할 때만 내보낸다. true·false·null도 마찬가지로 다 받은 뒤에 확정한다.
필드가 완성됐다고 판단하는 시점은 그 값 뒤에 다음 키가 시작되거나 객체가 닫힐 때다. UI에 필드를 하나씩 채워 보여 줄 때는 「쓰는 중」과 「완성」 두 상태를 구별해 그리면, 사용자가 덜 끝난 값을 보고 행동하는 일을 막을 수 있다. 이스케이프도 조심한다. 문자열이 \에서 끊긴 상태라면 그 마지막 글자는 다음 조각이 올 때까지 보여 주지 않는다.
제약 없는 경우
제약 없이 이걸 하면 위험하다. 접두사가 유효하다는 보장이 없으므로 부분 파서가 엉뚱한 구조를 추정하고, 뒤에 오는 토큰이 그 추정을 뒤집는다. 모델이 JSON 앞에 「다음은 결과입니다」 같은 말을 붙이거나, 코드 펜스로 감싸거나, 중간에 키 이름을 잘못 쓰면 이미 화면에 그린 필드를 지우고 다시 그려야 한다. 결국 끝까지 받은 뒤에 파싱하는 것과 다를 바가 없어진다. UI에 필드를 하나씩 채워 보여 주는 화면은 제약 디코딩이 있어야 제대로 만들어진다.
정리하면 제약 디코딩은 허용되지 않는 토큰의 로짓을 로 만들고, 무엇이 허용되는지는 스키마를 컴파일한 오토마톤이 정하며, 무거운 계산은 스키마당 한 번만 하고 스텝마다는 조회만 한다. 그 대가로 모델은 「모르겠다」고 말할 자리를 잃으므로, 그 자리를 스키마 안에 명시적으로 만들어 두는 것이 제약 디코딩을 제대로 쓰는 방법이다. 다음 글에서는 JSON을 넘어 임의의 문법으로 제약을 거는 쪽 — 문법 기반 생성을 본다.
읽어주셔서 감사합니다. 😊

