여기서 google-genai는 Gemini API용 Google의 Python SDK입니다. Decisions API와 Interactions API에 요청을 보내는 client.decisions.create 및 client.interactions.create 메서드를 제공합니다. pandas로 데이터셋을 로드하고 결과를 정리하며, matplotlib로 도표를 그립니다.
다음으로 클라이언트를 생성합니다. Decisions API에는 v1beta API 버전이 필요합니다.
import os, time, json
import numpy as np
import pandas as pd
from google import genai
client = genai.Client(
api_key=os.environ["GEMINI_API_KEY"],
http_options={"api_version":"v1beta"},)
DECISION_MODEL ="gemini-decision-1"
GEN_MODEL ="gemini-3.5-flash-lite"제공
genai.Client()는 Colab의 secrets 또는 환경 변수로 설정한 GEMINI_API_KEY에서 API 키를 읽고, http_options로 Decisions API가 있는 v1beta API를 지정합니다.
그다음 Banking77 데이터셋을 로드하고 12개 의도를 정의합니다. 각 의도에는 두 모델이 모두 볼 수 있는 한 문장 설명을 부여합니다.
BANKING77_URL =("https://raw.githubusercontent.com/PolyAI-LDN/task-specific-datasets/master/banking_data/test.csv")
INTENTS ={"card_arrival":"The customer is asking where their new card is or why it has not arrived yet.","card_delivery_estimate":"The customer wants to know how long card delivery usually takes.","lost_or_stolen_card":"The customer's card was lost or stolen.",# ... 9 more intents}
LABELS =list(INTENTS)
df = pd.read_csv(BANKING77_URL)
df = df[df["category"].isin(LABELS)].reset_index(drop=True)
sample =(
df.groupby("category").sample(n=15, random_state=42).sample(frac=1, random_state=42).reset_index(drop=True))제공
위 코드는 Banking77 테스트 분할을 CSV로 다운로드한 뒤, 12개 의도 중 하나로 라벨링된 행만 남깁니다. 그런 다음 고정 시드로 의도별 15개 메시지를 샘플링해 실행마다 동일한 샘플을 얻습니다. 마지막 .sample(frac=1)로 행을 섞어 의도가 뒤섞이게 합니다.
이로써 의도별 15개, 총 180개 메시지를 얻습니다.
Step 2: Decisions API로 분류
choice 질문은 각 옵션 ID를 설명에 매핑하는 딕셔너리를 받습니다. 메시지를 input으로 전달하고, intent 키로 질문 하나를 보냅니다.
defdecide_intent(text):
start = time.perf_counter()
result = client.decisions.create(
model=DECISION_MODEL,input=text,
questions={"intent":{"type":"choice","instructions":"Which intent best describes this banking customer message?","criteria": INTENTS,}},)
latency = time.perf_counter()- start
ans = result.answers["intent"]return{"pred": ans.choice,"confidence":float(ans.confidence),"probabilities":dict(ans.probabilities),"latency_s": latency,"input_tokens": result.usage.total_input_tokens,"output_tokens": result.usage.total_output_tokens,}제공
decide_intent()는 하나의 메시지를 input으로 보내고, 12개 의도를 선택지로 둔 choice 질문 하나를 보냅니다. time.perf_counter()로 호출 시간을 재고, 응답에서 최상위 선택, 신뢰도, 모든 선택지 확률, 토큰 수를 읽습니다.
각 답변에는 세 가지 필드가 있습니다.
choice: 확률이 가장 높은 선택지
probabilities: 각 선택지의 확률(합계 1)
confidence: 최상위 답이 맞을 확률의 추정치
usage 객체는 입력 토큰을 보고하며, total_output_tokens는 항상 0입니다.
샘플의 첫 번째 메시지 결과는 다음과 같습니다.
모델은 유사한 두 의도를 혼동했지만, 0.846의 신뢰도는 다소 불확실함을 보여줍니다. 긍정적인 점은 정답 card_arrival이 나머지 확률 대부분(약 0.15)로 2위를 했다는 것입니다. 다른 선택지는 거의 0에 가까웠습니다.
Step 3: Flash-Lite로 분류
생성 베이스라인으로는 같은 12개 라벨의 enum을 갖는 구조화된 출력을 사용해 Flash-Lite가 유효한 라벨만 반환하도록 합니다. 또한 0과 1 사이의 신뢰도를 요청합니다. 이는 대부분의 앱이 생성 모델에서 신뢰도를 얻는 방식입니다.
LABEL_LIST ="\n".join(f"- {k}: {v}"for k, v in INTENTS.items())
GEN_SCHEMA ={"type":"object","properties":{"intent":{"type":"string","enum": LABELS},"confidence":{"type":"number"},},"required":["intent","confidence"],}defgenerate_intent(text):
prompt =("Which intent best describes this banking customer message?\n\n"f"Intents:\n{LABEL_LIST}\n\n"f"Message: {text}\n\n""Return the intent and your confidence from 0 to 1.")
start = time.perf_counter()
interaction = client.interactions.create(
model=GEN_MODEL,input=prompt,
response_format={"type":"text","mime_type":"application/json","schema": GEN_SCHEMA,},
generation_config={"temperature":0.0,"thinking_level":"minimal"},
store=False,)
latency = time.perf_counter()- start
parsed = json.loads(interaction.output_text)return{"pred": parsed["intent"],"confidence":float(parsed["confidence"]),"latency_s": latency,"input_tokens": interaction.usage.total_input_tokens,"output_tokens": interaction.usage.total_output_tokens,"thought_tokens": interaction.usage.total_thought_tokens,}제공
generate_intent()는 12개 의도와 설명을 담은 프롬프트를 구성합니다. response_format을 JSON 스키마로 설정해 출력이 12개 중 하나의 라벨을 담은 유효한 JSON이 되도록 합니다. temperature는 0, thinking level은 minimal로 설정해 답변을 안정적이고 짧게 유지합니다. 이후 interaction.output_text를 json.loads()로 파싱하고, interaction.usage에서 토큰 수를 읽습니다.
같은 메시지를 Flash-Lite로 테스트한 결과, 같은 실수를 더 높은 신뢰도로 했습니다.
minimal 설정으로 사고 토큰이 0이며, Flash-Lite가 답만 작성했음을 확인합니다. Decisions API는 질문 안의 선택지 설명도 입력으로 계산하기 때문에, Flash-Lite가 Decision 1보다 적은 입력 토큰(277 vs 337)을 사용했습니다.
Step 4: 요청당 한 메시지 분류
이제 두 모델에 웜업 2회씩 후, 180개 메시지를 모두 한 번에 하나씩 보냅니다.
rows =[]for i, r in sample.iterrows():for model_name, fn in(("decision", decide_intent),("generative", generate_intent)):
out = fn(r["text"])
rows.append({"model": model_name,"gold": r["category"],"pred": out["pred"],"confidence": out["confidence"],"latency_s": out["latency_s"],"input_tokens": out["input_tokens"],"output_tokens": out["output_tokens"],})
exp1 = pd.DataFrame(rows)
exp1["correct"]= exp1["pred"]== exp1["gold"]제공
이 루프는 각 메시지를 두 함수에 보내고, 예측, 신뢰도, 지연 시간, 토큰 수를 한 행으로 저장합니다. 그런 다음 DataFrame으로 만들고, 예측이 정답 라벨과 일치하는지 표시하는 correct 열을 추가합니다.
결과는 다음과 같습니다:
지표
Gemini Decision 1
Gemini 3.5 Flash-Lite
정확도
84.4%
83.9%
중앙값 지연 시간
325 ms
1,068 ms
p90 지연 시간
412 ms
6,483 ms
가장 느린 요청
1.0 s
101.6 s
5초 초과 요청
0 / 180
33 / 180
평균 입력 토큰
339
279
평균 출력 토큰
0
25
이 지표에서 배운 세 가지는 다음과 같습니다.
정확도: 두 모델의 정확도는 거의 동일했습니다.
지연 시간: Decision 1은 중앙값 기준 약 3배 빠르고 일관성이 높았으며, Flash-Lite는 느린 요청의 롱테일이 있었습니다.
토큰: Decision 1은 선택지 설명이 입력으로 계산되어 입력 토큰을 더 사용했지만, 출력 토큰은 생성하지 않았습니다.
참고: 타이밍에는 Colab에서의 네트워크 왕복이 포함되므로, 해당 차이는 환경에 따라 달라질 수 있습니다.
Step 5: 보정(calibration) 확인
정확도는 모델이 얼마나 자주 맞는지를 알려주지만, 보정은 신뢰도 점수가 의미가 있는지 알려줍니다. 모델의 신뢰도가 정확도와 일치할 때(예: 0.8이라고 하면 그 그룹의 약 80%가 정답) 잘 보정되었다고 합니다.
이를 측정하기 위해 예측을 10개의 신뢰도 구간으로 묶고, 각 구간의 평균 신뢰도와 정확도를 비교합니다. 기대 보정 오차(ECE)는 구간별 격차의 평균이며, 각 구간의 예측 비율로 가중합니다. 낮을수록 좋습니다.
defece(conf, correct, n_bins=10):
conf = np.asarray(conf, dtype=float)
correct = np.asarray(correct, dtype=float)
edges = np.linspace(0,1, n_bins +1)
ids = np.clip(np.digitize(conf, edges[1:-1]),0, n_bins -1)
total =0.0for b inrange(n_bins):
mask = ids == b
if mask.sum():
total += mask.mean()*abs(conf[mask].mean()- correct[mask].mean())return total제공
ece() 함수는 신뢰도에 따라 각 예측을 10개 구간(0~0.1, 0.1~0.2 등) 중 하나에 배치합니다. 각 구간에서 평균 신뢰도와 정확도의 차이를 구하고, 해당 구간의 예측 비율로 가중해 합산합니다.
두 모델의 비교 결과는 다음과 같습니다.
지표
Gemini Decision 1
Gemini 3.5 Flash-Lite
정확도
84.4%
83.9%
평균 신뢰도
0.867
0.957
ECE
0.050
0.124
정답일 때 평균 신뢰도
0.901
0.966
오답일 때 평균 신뢰도
0.686
0.912
그림: 두 모델의 신뢰도 다이어그램
Decision 1의 신뢰도는 정확도와 가깝고, ECE는 0.050입니다. 또한 오답일 때(0.686)보다 정답일 때(0.901) 명확히 더 높습니다.
Flash-Lite는 과도하게 확신합니다. 평균 0.957을 보고했지만 실제 정답률은 83.9%였습니다. 180개 답 중 독립적인 신뢰도 값은 9개뿐이었고, 이 중 158개가 0.95 이상이었습니다. 오답의 평균도 0.912였습니다. 숫자는 확률처럼 보이지만, 모델이 텍스트로 쓴 자신에 대한 추정치입니다.
보정은 점수에 따라 행동할 때 중요합니다. 흔한 패턴은 신뢰도 임계값 이상 답은 수락하고, 나머지는 폴백 모델이나 사람에게 보내는 것입니다.
임계값
Decision 1: 유지 비율
Decision 1: 유지 샘플 정확도
Flash-Lite: 유지 비율
Flash-Lite: 유지 샘플 정확도
0.50
94.4%
85.9%
99.4%
84.4%
0.70
78.3%
92.2%
98.9%
84.3%
0.80
74.4%
93.3%
98.9%
84.3%
0.90
63.3%
95.6%
88.9%
87.5%
0.95
53.9%
96.9%
87.8%
87.3%
Decision 1에서는 더 높은 임계값이 기대대로 동작합니다. 0.9에서 메시지의 63%를 유지하며 정확도 95.6%를 달성합니다. Flash-Lite에서는 임계값이 거의 도움이 되지 않습니다. 대부분의 오답도 높은 신뢰도를 갖기 때문입니다. 공식 문서는 자체 트래픽의 라벨링된 예시에서 임계값을 정할 것을 권장합니다.
Step 6: 요청 하나로 100개 메시지 분류
Decisions API는 단일 요청에서 공용 입력 하나에 대해 최대 1,000개의 질문에 답할 수 있습니다. 이를 테스트하기 위해 N개의 고객 메시지를 하나의 입력으로 넣고, 메시지당 질문 하나씩을 둡니다.
Decision 1의 경우, m1부터 mN까지 키를 둔 N개의 choice 질문을 뜻합니다.
defbuild_batch(n):
msgs = pool.iloc[:n]
shared ="Banking customer messages:\n"+"".join(f"Message {i +1}: {t}\n"for i, t inenumerate(msgs["text"]))return shared,list(msgs["category"])defdecide_batch(n):
shared, gold = build_batch(n)
questions ={f"m{i +1}":{"type":"choice","instructions":f"Which intent best describes Message {i +1}?","criteria": INTENTS,}for i inrange(n)}
result = client.decisions.create(
model=DECISION_MODEL,input=shared, questions=questions
)
preds =[result.answers[f"m{i +1}"].choice for i inrange(n)]return preds, gold, result.usage제공
여기서 build_batch()는 처음 N개의 메시지에 번호를 매겨 하나의 공용 입력으로 합칩니다. 이어서 decide_batch()는 메시지마다 m1부터 mN까지 키를 둔 choice 질문을 만들고, 한 요청으로 모두 전송한 뒤 키별로 답을 읽습니다.
Flash-Lite의 경우에도 같은 공용 입력을 보내되, 12개 라벨로 제한된 N개의 필드 대신 N개 값을 담는 리스트 형태의 JSON 스키마를 사용합니다. 각 N에 대해 두 모델 모두 같은 메시지를 사용하며, 각 설정은 3회 실행합니다.
요청당 질문 수
Decision 1: 중앙값 지연
Flash-Lite: 중앙값 지연
Decision 1: 입력 토큰
Flash-Lite: 입력 / 출력 토큰
1
318 ms
888 ms
344
291 / 14
5
353 ms
858 ms
1,554
369 / 64
10
398 ms
1,063 ms
3,056
456 / 129
25
546 ms
2,753 ms
7,570
710 / 350
50
592 ms
Failed
15,100
Failed
100
59,095 ms
Failed
30,309
Failed
25개 질문까지 Decision 1의 중앙값 지연은 550 ms 미만을 유지했습니다. Flash-Lite의 중앙값은 N에 따라 증가했으며, 1~5개에서는 1초 미만이었지만 25개에서는 2.75초였습니다. 이는 매 답을 출력 토큰으로 작성해야 하기 때문입니다. 50개에서도 Decision 1의 중앙값은 592 ms였으나, 세 번 중 한 번은 70초가 걸렸습니다.
고려할 두 가지 핵심 포인트는 다음과 같습니다.
Flash-Lite는 50개와 100개에서 실패: 위 표의 "Failed" 행은 모두 같은 400 오류입니다. 서빙에 "상태가 너무 많은" 스키마라는 메시지입니다. 12개 라벨로 제한된 50개 이상 필드의 스키마는 API 허용 범위를 초과합니다.
Decision 1은 100개에서 속도가 저하: 각 질문이 12개 선택지 설명(질문당 약 300 토큰)을 반복하므로 요청이 30,309 토큰에 도달했습니다. Google의 평탄한 지연 시간 주장은 16K 토큰까지의 컨텍스트에 해당합니다.
Step 7: 요청 다이어트
이제 당연한 질문이 떠오릅니다. 속도 저하와 실패를 고칠 수 있을까요? Decision 1에는 빈 선택지 설명("")을 사용합니다. Flash-Lite에는 N개의 개별 필드 대신 N개 라벨의 리스트 하나를 요청합니다.
# Decision 1: option IDs only, no descriptions"criteria":{k:""for k in LABELS}# Flash-Lite: one list field instead of N fields
schema ={"type":"object","properties":{"intents":{"type":"array","items":{"type":"string","enum": LABELS},"minItems": n,"maxItems": n,}},"required":["intents"],}제공
빈 설명에서 Decision 1의 성능은 다음과 같았습니다.
요청당 질문 수
중앙값 지연
정확도
입력 토큰
25
357 ms
84.0%
3,995
50
649 ms
78.0%
7,950
100
1,603 ms
83.0%
16,009
설명을 제거하자 입력 토큰이 대략 절반으로 줄었습니다. 100개 질문에서 요청은 약 16K 토큰까지 내려갔고, 중앙값 지연은 59초에서 1.6초로 감소했습니다. 25개와 50개에서는 정확도가 약간 하락했으므로, 특히 유사한 의도에서는 짧은 설명이 없는 것보다 나은 절충안입니다.
리스트 스키마는 Flash-Lite 모델에 도움이 되지 않았습니다. 25개에서는 동작했지만, 50개와 100개에서는 여전히 실패했습니다.
cost_per_request()는 토큰 수에 100만 토큰당 가격을 곱합니다. Decision 1은 입력 토큰만 계산합니다. Flash-Lite는 thinking 토큰이 출력 가격으로 과금되므로 출력 토큰에 합산합니다.
각 설정의 1,000건당 비용은 다음과 같습니다.
설정
Gemini Decision 1
Gemini 3.5 Flash-Lite
Flash-Lite / Decision 1
요청당 1개 메시지
$0.034
$0.147
4.3배
요청당 5개 질문
$0.155
$0.271
1.7배
요청당 10개 질문
$0.306
$0.459
1.5배
요청당 25개 질문
$0.757
$1.088
1.4배
25개 질문, 다이어트 설정(Step 7)
$0.400
$0.831
2.1배
요청당 50개 질문
$1.510
Failed
해당 없음
100개 질문, 빈 설명
$1.601
Failed
해당 없음
단일 메시지에서는 Decision 1이 4.3배 저렴했지만, 한 요청에 더 많은 질문을 배치할수록 격차가 줄어듭니다. 공용 입력은 두 API 모두에서 한 번만 과금됩니다. 하지만 Decision 1에서는 각 질문이 자체 지시문과 12개 선택지 설명을 포함하는 반면, Flash-Lite는 라벨 목록을 한 번만 보고 답마다 짧은 출력을 지불합니다. 25개 질문에서 Decision 1은 7,570개의 입력 토큰을, Flash-Lite는 710개의 입력과 350개의 출력 토큰을 사용했습니다.
참고: Decisions API는 컨텍스트 캐싱이나 배치 API를 지원하지 않습니다. 동일한 입력을 여러 요청에 보낸다면 매번 전체가 과금됩니다. 따라서 동일한 입력에 대해 질문이 많다면 여러 호출로 나누지 말고 한 요청에 모으세요.
접근 방식별 사용 시점
위 실험을 바탕으로, 다음과 같은 경우 결정 모델이 더 적합합니다.
의도, 라우트, 도구, 정책 라벨처럼 답이 고정된 선택지에서 나오는 경우
요청 경로 상에 있어 모든 사용자가 결정을 기다리는 경우
신뢰도에 따라 행동하고 싶은 경우(불명확한 사례는 폴백이나 사람에게 전달)
동일한 입력에 대한 독립적인 질문을 한 요청에서 많이 해야 하는 경우
다음과 같은 경우에는 생성 모델이 여전히 더 적합합니다.
설명, 추출값, 그 밖의 자유 텍스트가 필요한 경우
가능한 답의 집합이 개방형이거나 요청마다 달라지는 경우
이미 해당 입력에 대한 생성 호출을 했고, 그 호출에 분류를 추가할 수 있는 경우
다음이 필요하다면 Decisions API 사용
다음이 필요하다면 Interactions API 사용
예/아니오 확률, 고정 세트에서 하나의 선택, 고정 척도의 평점
생성 텍스트, 요약, 설명
임계값을 적용할 수 있는 보정된 확률
자체 JSON 스키마를 따르는 값/객체 추출
하나의 호출에서 동일 입력에 대한 다수의 독립 점검
인자와 함께하는 도구 호출
낮은 지연 시간과 0의 출력 토큰 비용
다단계 추론
마무리
이 튜토리얼에서 우리는 Gemini Decision 1과 Gemini 3.5 Flash-Lite로 은행 의도 분류기를 만들고, 두 모델의 정확도, 지연 시간, 보정, 비용을 비교했습니다. 핵심 요약 네 가지는 다음과 같습니다.
정확도는 무승부: Decision 1은 84.4%, Flash-Lite는 83.9%였고, 180개 중 163개 메시지에서 같은 판정을 내렸습니다.
Decision 1이 더 빠르고 예측 가능: 중앙값 325 ms 대 1,068 ms였고, 가장 느린 요청은 1.0초 대 101.6초였습니다.
Decision 1의 신뢰도는 활용 가능: ECE가 0.050(Flash-Lite 0.124)였고, 임계값을 0.9로 높이면 유지 샘플 정확도가 84.4%에서 95.6%로 상승했습니다. Flash-Lite의 자체 보고 신뢰도는 정답과 오답을 잘 구분하지 못했습니다.
비용과 스케일링은 질문 작성 방식에 좌우: 단일 메시지에서는 Decision 1이 4.3배 저렴했지만, 각 질문이 선택지 설명 비용을 지불합니다. 따라서 총 입력을 약 16K 토큰 이하로 유지하고, 선택지 설명은 짧게 유지하세요.
이 결과는 하나의 작업, 하나의 데이터셋, Colab 노트북에서의 소수 실행으로 나온 것입니다. 일반적 성능 주장이 아닌 데모 관찰로 받아들이면 좋겠습니다.
FAQs
Decisions API와 생성 API의 차이는 무엇인가요?⌄
생성 API는 답을 토큰 단위로 작성하며 각 출력 토큰이 과금됩니다. Decisions API는 고정된 선택지 세트를 한 번의 포워드 패스로 스코어링해 각 선택지의 확률을 반환합니다. 출력 토큰을 생성하지 않으므로 입력에 대해서만 비용을 지불합니다.
Gemini Decision 1이 Gemini 3.5 Flash-Lite보다 더 정확한가요?⌄
저희 테스트에서는 아니었습니다. 180개의 은행 메시지에서 Decision 1의 정확도는 84.4%, Flash-Lite는 83.9%였습니다. 차이는 지연 시간, 보정, 비용에서 나타났습니다.
왜 Decision 1이 Flash-Lite보다 입력 토큰을 더 많이 사용하나요?⌄
각 질문의 지시문과 선택지 설명이 입력으로 계산됩니다. 12개의 설명이 있는 선택지로, 테스트에서는 질문당 약 300 토큰이 추가되었습니다. 짧거나 빈 선택지 설명을 사용하면 줄일 수 있습니다.
질문을 늘려도 지연 시간이 평탄하게 유지되나요?⌄
저희 실행에서는 50개 질문까지 중앙값이 650 ms 미만을 유지했습니다. 선택지 전체 설명을 포함한 100개 질문에서는 약 3만 토큰에 도달해 48~59초가 걸렸습니다. 빈 설명을 사용하면 같은 100개가 약 1.6만 토큰으로 줄어 1.6초가 걸렸습니다.
Decisions API는 어떤 질문 유형을 지원하나요?⌄
Decisions API는 세 가지 질문 유형을 지원합니다. 예/아니오 점검용 noul, 2~255개 중 하나를 고르는 choice, 순서형 루브릭으로 점수를 매기는 score입니다. 한 요청에서 세 가지를 혼합해 사용할 수 있습니다.
Analyze data smarter with Gemini in Google Sheets. Use AI-powered insights, formula suggestions, and automation to simplify spreadsheets and boost productivity.
대부분의 LLM 앱에는 작은 결정이 가득합니다. 어떤 도구를 호출할까요? 어떤 모델이 이 쿼리를 처리해야 할까요? 이 메시지는 정책을 위반하나요?
오늘날 많은 팀은 생성 모델에게 텍스트로 답을 쓰게 한 뒤, 그 텍스트를 파싱해 결정을 내립니다.
Google의 Gemini Decisions API는 다른 접근을 택합니다. Gemini Decision 1 모델을 사용해 단일 포워드 패스에서 고정된 선택지 세트를 스코어링하고, 각 선택지에 대한 확률을 반환합니다. 출력 토큰은 0으로 과금되지 않습니다.
이 튜토리얼에서는 동일한 의도 분류 작업을 두 가지 설정에서 실행해 보겠습니다.
정확도, 지연 시간, 토큰 사용량, 비용, 보정(calibration)을 비교한 뒤, 단일 요청에서 1개 질문에서 100개 질문으로 늘려 보겠습니다.
이 튜토리얼을 마치면 다음을 할 수 있습니다.
Decisions API를
choice질문으로 호출하고, 그 확률과 confidence 점수를 읽는 방법Interactions API와 JSON 스키마로 생성 기반 베이스라인 구축
두 접근 방식의 지연 시간, 토큰 사용량, 비용 측정
신뢰도 다이어그램과 기대 보정 오차(ECE)로 모델의 신뢰도를 검증
생성 모델보다 결정 모델이 앱에 더 잘 맞는 시점 판단
전체 코드는 Google Colab에서 실행할 수 있습니다.
결정 모델 vs. 생성 모델
각 모델의 동작을 보기 전에, 두 용어를 정의해 보겠습니다.
예시를 보겠습니다.
고객이 은행에 이렇게 씁니다: "카드가 아직 도착하지 않았어요. 언제 오나요?"
만약 생성 모델에게 "이 고객은 무엇을 원하나요?"라고 물으면, 이렇게 답할 수 있습니다:
“고객은 새 카드를 기다리고 있으며 언제 도착할지 알고 싶어합니다.”
사람이 읽기에는 좋은 답입니다. 하지만 앱이 메시지를 적절한 팀으로 라우팅해야 한다면, 이제 코드가 그 문장을 라벨로 바꿔야 합니다. JSON 스키마로 라벨 출력을 강제할 수 있지만, 모델은 여전히 토큰 단위로 글을 씁니다.
반면, 같은 질문을 결정 모델에 하면, 먼저
card_arrival,lost_or_stolen_card,exchange_rate같은 선택지를 줍니다. 그러면 각 항목의 확률을 반환합니다:이제 코드는
card_arrival이 임계값을 넘으면 카드팀으로 바로 라우팅하고, 아니면 사람에게 보내는 등 확률에 직접 기반해 행동할 수 있습니다. 요약하면:생성 모델
결정 모델
반환값
모델이 작성한 텍스트
정의한 각 선택지의 확률
가능한 답
개방형
고정 세트
적합한 용도
답변, 요약, 설명, 추출
라우팅, 도구 선택, 정책 점검, 채점
실무에서는 많은 앱이 두 역할 모두에 생성 모델을 사용합니다. 다음 섹션에서는 결정 모델이 생성 모델보다 분류 작업을 더 잘하는지 테스트하겠습니다.
생성 모델을 분류기로 쓰면, 답을 토큰 단위로 작성합니다. 우리의 JSON 답처럼, 생성 중 출력은 다음과 같이 보입니다:
각 토큰은 별도의 디코딩 단계이며, 각 출력 토큰이 과금됩니다. 신뢰도 점수가 필요하면 그 숫자 또한 모델이 써야 합니다. 그 숫자는 모델 내부에서 측정된 확률이 아니라, 모델이 스스로에 대해 추정해 쓴 값입니다.
반면 결정 모델은 이 작성 단계를 건너뜁니다. 선택지를 미리 주면, 입력에 대해 모든 선택지를 한 번의 포워드 패스로 스코어링합니다. 결과는 각 선택지의 확률입니다:
이는 측정 가능한 세 가지를 바꿉니다.
대신의 트레이드오프는 폐쇄형 질문만 할 수 있다는 점입니다. 결정 모델은 답을 설명하거나 값을 추출하거나 자유 텍스트를 작성할 수 없습니다.
데모: 은행 의도 분류기 만들기
이 데모에서는 은행 의도 분류기를 만듭니다. 77개 의도로 라벨링된 고객 메시지 공개 데이터셋인 Banking77의 테스트 분할을 사용하고, 서로 혼동하기 쉬운 12개 의도만 남깁니다.
card_arrival과card_delivery_estimatepending_card_payment,declined_card_payment,card_payment_fee_chargedpending_transfer,transfer_not_received_by_recipient,balance_not_updated_after_bank_transferlost_or_stolen_card,card_not_working,exchange_rate,top_up_failed유사한 의도일수록 작업이 어려워지고, 신뢰도 점수를 분석하기에 더 흥미로워집니다.
두 모델 모두에서 분류기를 두 방식으로 실행합니다.
두 모델 모두에 동일하게 유지한 설정은 다음과 같습니다s:
설정
사용 값
이유
결정 모델
gemini-decision-1테스트 대상 모델
생성 모델
gemini-3.5-flash-lite런치 포스트 비교에서 사용한 비용 효율적 생성 베이스라인
Flash-Lite temperature
0.0
베이스라인의 샘플링 노이즈 제거
Flash-Lite thinking level
minimal비교를 추론이 아닌 디코딩에 초점
출력 형식
12개 라벨의
enum을 갖는 JSON 스키마Flash-Lite는 유효한 라벨만 반환
선택지 설명
의도별 한 문장 요약
두 모델이 동일한 라벨 정의를 봄
웜업 호출
모델당 2회
연결 설정 시간을 측정에서 제외
반복(요청당 여러 질문)
설정당 3회
단일 실행이 아닌 중앙값 보고
참고: 이는 데모를 위한 동작 설정이며, 어느 모델에도 튜닝된 설정이 아닙니다.
Step 1: 사전 준비 및 설정
따라 하려면 다음이 필요합니다.
다음에서 발급한 Gemini API 키: Google AI Studio
Colab 노트북(또는 임의의 Python 3 환경)
google-genai3.2 이상 버전Decisions API는 프로토타이핑을 위한 Google AI Studio 무과금 티어가 있어, 비용을 내기 전에 시험해 볼 수 있습니다. 저는 이 데모를 Colab에서 실행했지만, 어떤 Python 3 환경이든 사용하셔도 됩니다.
먼저 패키지를 설치하겠습니다.
여기서
google-genai는 Gemini API용 Google의 Python SDK입니다. Decisions API와 Interactions API에 요청을 보내는client.decisions.create및client.interactions.create메서드를 제공합니다.pandas로 데이터셋을 로드하고 결과를 정리하며,matplotlib로 도표를 그립니다.다음으로 클라이언트를 생성합니다. Decisions API에는 v1beta API 버전이 필요합니다.
genai.Client()는 Colab의 secrets 또는 환경 변수로 설정한GEMINI_API_KEY에서 API 키를 읽고,http_options로 Decisions API가 있는 v1beta API를 지정합니다.그다음 Banking77 데이터셋을 로드하고 12개 의도를 정의합니다. 각 의도에는 두 모델이 모두 볼 수 있는 한 문장 설명을 부여합니다.
위 코드는 Banking77 테스트 분할을 CSV로 다운로드한 뒤, 12개 의도 중 하나로 라벨링된 행만 남깁니다. 그런 다음 고정 시드로 의도별 15개 메시지를 샘플링해 실행마다 동일한 샘플을 얻습니다. 마지막
.sample(frac=1)로 행을 섞어 의도가 뒤섞이게 합니다.이로써 의도별 15개, 총 180개 메시지를 얻습니다.
Step 2: Decisions API로 분류
choice질문은 각 옵션 ID를 설명에 매핑하는 딕셔너리를 받습니다. 메시지를input으로 전달하고,intent키로 질문 하나를 보냅니다.decide_intent()는 하나의 메시지를input으로 보내고, 12개 의도를 선택지로 둔choice질문 하나를 보냅니다.time.perf_counter()로 호출 시간을 재고, 응답에서 최상위 선택, 신뢰도, 모든 선택지 확률, 토큰 수를 읽습니다.각 답변에는 세 가지 필드가 있습니다.
choice: 확률이 가장 높은 선택지probabilities: 각 선택지의 확률(합계 1)confidence: 최상위 답이 맞을 확률의 추정치usage객체는 입력 토큰을 보고하며,total_output_tokens는 항상 0입니다.샘플의 첫 번째 메시지 결과는 다음과 같습니다.
모델은 유사한 두 의도를 혼동했지만, 0.846의 신뢰도는 다소 불확실함을 보여줍니다. 긍정적인 점은 정답
card_arrival이 나머지 확률 대부분(약 0.15)로 2위를 했다는 것입니다. 다른 선택지는 거의 0에 가까웠습니다.Step 3: Flash-Lite로 분류
생성 베이스라인으로는 같은 12개 라벨의
enum을 갖는 구조화된 출력을 사용해 Flash-Lite가 유효한 라벨만 반환하도록 합니다. 또한 0과 1 사이의 신뢰도를 요청합니다. 이는 대부분의 앱이 생성 모델에서 신뢰도를 얻는 방식입니다.generate_intent()는 12개 의도와 설명을 담은 프롬프트를 구성합니다.response_format을 JSON 스키마로 설정해 출력이 12개 중 하나의 라벨을 담은 유효한 JSON이 되도록 합니다. temperature는0, thinking level은minimal로 설정해 답변을 안정적이고 짧게 유지합니다. 이후interaction.output_text를json.loads()로 파싱하고,interaction.usage에서 토큰 수를 읽습니다.같은 메시지를 Flash-Lite로 테스트한 결과, 같은 실수를 더 높은 신뢰도로 했습니다.
minimal설정으로 사고 토큰이 0이며, Flash-Lite가 답만 작성했음을 확인합니다. Decisions API는 질문 안의 선택지 설명도 입력으로 계산하기 때문에, Flash-Lite가 Decision 1보다 적은 입력 토큰(277 vs 337)을 사용했습니다.Step 4: 요청당 한 메시지 분류
이제 두 모델에 웜업 2회씩 후, 180개 메시지를 모두 한 번에 하나씩 보냅니다.
이 루프는 각 메시지를 두 함수에 보내고, 예측, 신뢰도, 지연 시간, 토큰 수를 한 행으로 저장합니다. 그런 다음 DataFrame으로 만들고, 예측이 정답 라벨과 일치하는지 표시하는 correct 열을 추가합니다.
결과는 다음과 같습니다:
지표
Gemini Decision 1
Gemini 3.5 Flash-Lite
정확도
84.4%
83.9%
중앙값 지연 시간
325 ms
1,068 ms
p90 지연 시간
412 ms
6,483 ms
가장 느린 요청
1.0 s
101.6 s
5초 초과 요청
0 / 180
33 / 180
평균 입력 토큰
339
279
평균 출력 토큰
0
25
이 지표에서 배운 세 가지는 다음과 같습니다.
참고: 타이밍에는 Colab에서의 네트워크 왕복이 포함되므로, 해당 차이는 환경에 따라 달라질 수 있습니다.
Step 5: 보정(calibration) 확인
정확도는 모델이 얼마나 자주 맞는지를 알려주지만, 보정은 신뢰도 점수가 의미가 있는지 알려줍니다. 모델의 신뢰도가 정확도와 일치할 때(예: 0.8이라고 하면 그 그룹의 약 80%가 정답) 잘 보정되었다고 합니다.
이를 측정하기 위해 예측을 10개의 신뢰도 구간으로 묶고, 각 구간의 평균 신뢰도와 정확도를 비교합니다. 기대 보정 오차(ECE)는 구간별 격차의 평균이며, 각 구간의 예측 비율로 가중합니다. 낮을수록 좋습니다.
ece()함수는 신뢰도에 따라 각 예측을 10개 구간(0~0.1, 0.1~0.2 등) 중 하나에 배치합니다. 각 구간에서 평균 신뢰도와 정확도의 차이를 구하고, 해당 구간의 예측 비율로 가중해 합산합니다.두 모델의 비교 결과는 다음과 같습니다.
지표
Gemini Decision 1
Gemini 3.5 Flash-Lite
정확도
84.4%
83.9%
평균 신뢰도
0.867
0.957
ECE
0.050
0.124
정답일 때 평균 신뢰도
0.901
0.966
오답일 때 평균 신뢰도
0.686
0.912
그림: 두 모델의 신뢰도 다이어그램
Decision 1의 신뢰도는 정확도와 가깝고, ECE는 0.050입니다. 또한 오답일 때(0.686)보다 정답일 때(0.901) 명확히 더 높습니다.
Flash-Lite는 과도하게 확신합니다. 평균 0.957을 보고했지만 실제 정답률은 83.9%였습니다. 180개 답 중 독립적인 신뢰도 값은 9개뿐이었고, 이 중 158개가 0.95 이상이었습니다. 오답의 평균도 0.912였습니다. 숫자는 확률처럼 보이지만, 모델이 텍스트로 쓴 자신에 대한 추정치입니다.
보정은 점수에 따라 행동할 때 중요합니다. 흔한 패턴은 신뢰도 임계값 이상 답은 수락하고, 나머지는 폴백 모델이나 사람에게 보내는 것입니다.
임계값
Decision 1: 유지 비율
Decision 1: 유지 샘플 정확도
Flash-Lite: 유지 비율
Flash-Lite: 유지 샘플 정확도
0.50
94.4%
85.9%
99.4%
84.4%
0.70
78.3%
92.2%
98.9%
84.3%
0.80
74.4%
93.3%
98.9%
84.3%
0.90
63.3%
95.6%
88.9%
87.5%
0.95
53.9%
96.9%
87.8%
87.3%
Decision 1에서는 더 높은 임계값이 기대대로 동작합니다. 0.9에서 메시지의 63%를 유지하며 정확도 95.6%를 달성합니다. Flash-Lite에서는 임계값이 거의 도움이 되지 않습니다. 대부분의 오답도 높은 신뢰도를 갖기 때문입니다. 공식 문서는 자체 트래픽의 라벨링된 예시에서 임계값을 정할 것을 권장합니다.
Step 6: 요청 하나로 100개 메시지 분류
Decisions API는 단일 요청에서 공용 입력 하나에 대해 최대 1,000개의 질문에 답할 수 있습니다. 이를 테스트하기 위해 N개의 고객 메시지를 하나의 입력으로 넣고, 메시지당 질문 하나씩을 둡니다.
Decision 1의 경우,
m1부터mN까지 키를 둔 N개의choice질문을 뜻합니다.여기서
build_batch()는 처음 N개의 메시지에 번호를 매겨 하나의 공용 입력으로 합칩니다. 이어서decide_batch()는 메시지마다m1부터mN까지 키를 둔choice질문을 만들고, 한 요청으로 모두 전송한 뒤 키별로 답을 읽습니다.Flash-Lite의 경우에도 같은 공용 입력을 보내되, 12개 라벨로 제한된 N개의 필드 대신 N개 값을 담는 리스트 형태의 JSON 스키마를 사용합니다. 각 N에 대해 두 모델 모두 같은 메시지를 사용하며, 각 설정은 3회 실행합니다.
요청당 질문 수
Decision 1: 중앙값 지연
Flash-Lite: 중앙값 지연
Decision 1: 입력 토큰
Flash-Lite: 입력 / 출력 토큰
1
318 ms
888 ms
344
291 / 14
5
353 ms
858 ms
1,554
369 / 64
10
398 ms
1,063 ms
3,056
456 / 129
25
546 ms
2,753 ms
7,570
710 / 350
50
592 ms
Failed
15,100
Failed
100
59,095 ms
Failed
30,309
Failed
25개 질문까지 Decision 1의 중앙값 지연은 550 ms 미만을 유지했습니다. Flash-Lite의 중앙값은 N에 따라 증가했으며, 1~5개에서는 1초 미만이었지만 25개에서는 2.75초였습니다. 이는 매 답을 출력 토큰으로 작성해야 하기 때문입니다. 50개에서도 Decision 1의 중앙값은 592 ms였으나, 세 번 중 한 번은 70초가 걸렸습니다.
고려할 두 가지 핵심 포인트는 다음과 같습니다.
Step 7: 요청 다이어트
이제 당연한 질문이 떠오릅니다. 속도 저하와 실패를 고칠 수 있을까요? Decision 1에는 빈 선택지 설명("")을 사용합니다. Flash-Lite에는 N개의 개별 필드 대신 N개 라벨의 리스트 하나를 요청합니다.
빈 설명에서 Decision 1의 성능은 다음과 같았습니다.
요청당 질문 수
중앙값 지연
정확도
입력 토큰
25
357 ms
84.0%
3,995
50
649 ms
78.0%
7,950
100
1,603 ms
83.0%
16,009
설명을 제거하자 입력 토큰이 대략 절반으로 줄었습니다. 100개 질문에서 요청은 약 16K 토큰까지 내려갔고, 중앙값 지연은 59초에서 1.6초로 감소했습니다. 25개와 50개에서는 정확도가 약간 하락했으므로, 특히 유사한 의도에서는 짧은 설명이 없는 것보다 나은 절충안입니다.
리스트 스키마는 Flash-Lite 모델에 도움이 되지 않았습니다. 25개에서는 동작했지만, 50개와 100개에서는 여전히 실패했습니다.
Step 8: 비용 비교
마지막으로 각 API가 반환한 토큰 수로, 유료 티어 가격을 적용해 비용을 계산합니다.
모델
입력 100만 토큰당 가격
출력 100만 토큰당 가격
Gemini Decision 1
$0.10
$0
Gemini 3.5 Flash-Lite
$0.30
$2.50 (thinking 토큰 포함)
cost_per_request()는 토큰 수에 100만 토큰당 가격을 곱합니다. Decision 1은 입력 토큰만 계산합니다. Flash-Lite는 thinking 토큰이 출력 가격으로 과금되므로 출력 토큰에 합산합니다.각 설정의 1,000건당 비용은 다음과 같습니다.
설정
Gemini Decision 1
Gemini 3.5 Flash-Lite
Flash-Lite / Decision 1
요청당 1개 메시지
$0.034
$0.147
4.3배
요청당 5개 질문
$0.155
$0.271
1.7배
요청당 10개 질문
$0.306
$0.459
1.5배
요청당 25개 질문
$0.757
$1.088
1.4배
25개 질문, 다이어트 설정(Step 7)
$0.400
$0.831
2.1배
요청당 50개 질문
$1.510
Failed
해당 없음
100개 질문, 빈 설명
$1.601
Failed
해당 없음
단일 메시지에서는 Decision 1이 4.3배 저렴했지만, 한 요청에 더 많은 질문을 배치할수록 격차가 줄어듭니다. 공용 입력은 두 API 모두에서 한 번만 과금됩니다. 하지만 Decision 1에서는 각 질문이 자체 지시문과 12개 선택지 설명을 포함하는 반면, Flash-Lite는 라벨 목록을 한 번만 보고 답마다 짧은 출력을 지불합니다. 25개 질문에서 Decision 1은 7,570개의 입력 토큰을, Flash-Lite는 710개의 입력과 350개의 출력 토큰을 사용했습니다.
참고: Decisions API는 컨텍스트 캐싱이나 배치 API를 지원하지 않습니다. 동일한 입력을 여러 요청에 보낸다면 매번 전체가 과금됩니다. 따라서 동일한 입력에 대해 질문이 많다면 여러 호출로 나누지 말고 한 요청에 모으세요.
접근 방식별 사용 시점
위 실험을 바탕으로, 다음과 같은 경우 결정 모델이 더 적합합니다.
다음과 같은 경우에는 생성 모델이 여전히 더 적합합니다.
다음이 필요하다면 Decisions API 사용
다음이 필요하다면 Interactions API 사용
예/아니오 확률, 고정 세트에서 하나의 선택, 고정 척도의 평점
생성 텍스트, 요약, 설명
임계값을 적용할 수 있는 보정된 확률
자체 JSON 스키마를 따르는 값/객체 추출
하나의 호출에서 동일 입력에 대한 다수의 독립 점검
인자와 함께하는 도구 호출
낮은 지연 시간과 0의 출력 토큰 비용
다단계 추론
마무리
이 튜토리얼에서 우리는 Gemini Decision 1과 Gemini 3.5 Flash-Lite로 은행 의도 분류기를 만들고, 두 모델의 정확도, 지연 시간, 보정, 비용을 비교했습니다. 핵심 요약 네 가지는 다음과 같습니다.
이 결과는 하나의 작업, 하나의 데이터셋, Colab 노트북에서의 소수 실행으로 나온 것입니다. 일반적 성능 주장이 아닌 데모 관찰로 받아들이면 좋겠습니다.