MLOps: 모델을 배포하고 지키는 법
모델은 학습이 끝난 순간부터 서비스에서 낡아 가요. 고객 이탈 예측 모델을 예로, 다시 만들 수 있게 데이터 지문과 환경을 기록하고, 전처리를 빠뜨린 서비스 코드가 정확도 72.7%를 내면서 이탈 고객을 한 명도 못 찾는 함정, 서비스 입력 검사, 카나리 배포에 필요한 표본 크기, 입력 분포가 크게 바뀌어도 성능은 그대로이고 입력은 그대로인데 성능이 떨어지는 두 종류의 변화를 PSI와 시뮬레이션으로 확인해요.
머신러닝 트랙에서는 모델을 학습시키고 시험 점수를 확인하는 데서 끝났어요. 실제 서비스에서는 거기서부터가 시작이에요. 모델을 서비스에 올리고, 잘 돌아가는지 지켜보고, 세상이 바뀌면 다시 학습하고, 문제가 생기면 되돌려야 해요. 이 일을 꾸준히 해내기 위한 방법과 도구를 통틀어 MLOps라고 불러요.
2015년 구글 연구진은 "머신러닝 시스템의 숨은 기술 부채"라는 논문에서, 실제 머신러닝 시스템에서 모델 코드는 아주 작은 부분이고 데이터 수집, 검증, 서빙, 감시 같은 둘레의 장치가 대부분을 차지한다고 짚었어요. 그리고 그 둘레가 허술하면 빚처럼 문제가 쌓인다고 했어요. 이번 강의는 그 둘레를 다뤄요.
모델의 일생
- 데이터: 어떤 데이터로 학습하는가 (앞 강의의 파이프라인)
- 학습과 평가: 충분히 좋은가 (머신러닝 트랙)
- 기록과 등록: 나중에 똑같이 다시 만들 수 있는가
- 배포: 사용자에게 안전하게 내보내는가
- 감시: 서비스에서도 여전히 잘하는가
- 다시 학습: 언제, 어떻게 새 모델로 바꾸는가
고객 이탈 예측 모델로 하나씩 해 볼게요. 사용 시간과 접속 일수가 적을수록 이탈하기 쉬운, 연습용 가상 데이터예요.
import hashlib
import json
import numpy as np
import pandas as pd
import sklearn
import joblib
from scipy import stats
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, roc_auc_score
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
FEATURES = ["age", "hours", "spend", "days"]
def make_users(n, seed, age_mean=40, price_effect=0.0):
rng = np.random.default_rng(seed)
age = np.clip(rng.normal(age_mean, 10, n), 18, 80) # 나이
hours = rng.gamma(2.0, 5.0, n) # 한 달 사용 시간
spend = rng.lognormal(10, 0.6, n) # 한 달 결제액(원)
days = rng.binomial(30, 0.5, n) # 한 달 접속 일수
z = (2.0 - 0.12 * days - 0.08 * hours + 0.02 * (age - 40)
+ price_effect * (np.log(spend) - 10) + rng.normal(0, 0.8, n))
return pd.DataFrame({"age": age, "hours": hours, "spend": spend, "days": days,
"churn": (z > 0).astype(int)})
def r3(x):
return round(float(x), 3)
train = make_users(5000, seed=0)
test = make_users(2000, seed=1)
model = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000)) # 전처리와 모델을 한 덩어리로
model.fit(train[FEATURES], train["churn"])
p = model.predict_proba(test[FEATURES])[:, 1]
print("이탈 비율", r3(test["churn"].mean()), "정확도", r3(accuracy_score(test["churn"], p > 0.5)),
"AUC", r3(roc_auc_score(test["churn"], p)))
이탈 비율 0.273 정확도 0.766 AUC 0.789
1. 다시 만들 수 있게: 기록하기
석 달 뒤 누군가 "그때 그 모델은 어떤 데이터로, 어떤 설정으로 만들었어요?"라고 물으면 답할 수 있어야 해요. 모델이 이상해졌을 때 원인을 찾으려면, 그리고 좋은 모델을 다시 만들려면 꼭 필요해요. 모델 파일과 함께 이런 것들을 남겨요.
- 데이터 지문: 학습 데이터의 해시값이에요. 데이터가 한 칸만 달라져도 값이 바뀌어서, "같은 데이터였나?"를 확실히 확인할 수 있어요.
- 설정: 하이퍼파라미터, 무작위 씨앗
- 코드 버전: 깃 커밋 번호
- 환경: 파이썬과 라이브러리 버전. 버전이 바뀌면 같은 코드도 결과가 달라질 수 있어요.
- 성능: 어떤 평가 세트에서 얼마였는지
fingerprint = hashlib.sha256(pd.util.hash_pandas_object(train, index=True).values.tobytes()).hexdigest()[:16]
card = {
"name": "churn", "version": 1,
"data_sha256": fingerprint, "rows": len(train),
"params": {"C": 1.0, "max_iter": 1000},
"metrics": {"accuracy": r3(accuracy_score(test["churn"], p > 0.5)), "auc": r3(roc_auc_score(test["churn"], p))},
"sklearn": sklearn.__version__,
}
joblib.dump(model, "churn-v1.joblib")
with open("churn-v1.json", "w", encoding="utf-8") as f:
json.dump(card, f, ensure_ascii=False, indent=1)
loaded = joblib.load("churn-v1.joblib")
print(card["data_sha256"], card["metrics"])
print(np.array_equal(loaded.predict_proba(test[FEATURES]), model.predict_proba(test[FEATURES])))
cb328e375106e94b {'accuracy': 0.766, 'auc': 0.789}
True
모델 파일(churn-v1.joblib) 옆에 설명서(churn-v1.json)를 함께 저장했어요. 이런 설명서를 모델 카드라고 해요. 모델이 여러 버전으로 늘어나면, 버전마다 파일과 카드를 모아 두고 "지금 서비스 중인 버전", "시험 중인 버전"을 표시하는 모델 저장소(레지스트리)를 둬요. MLflow 같은 도구가 이 일을 해 줘요.
한 가지 꼭 알아 둘 것이 있어요. joblib과 pickle 파일은 불러오는 순간 안에 든 코드가 실행될 수 있어요. 파이썬 공식 문서도 믿을 수 없는 pickle 데이터는 절대 불러오지 말라고 경고해요. 인터넷에서 받은 모델 파일은 출처를 확인하고, 신경망 가중치처럼 숫자만 담으면 되는 경우에는 코드를 실행하지 않는 형식(safetensors 같은 것)을 써요.
2. 학습과 서비스가 어긋나면
가장 흔하고 무서운 사고는 학습할 때와 서비스할 때 데이터를 다르게 다루는 것이에요. 학습 때는 표준화(평균 0, 표준편차 1로 맞추기)를 했는데, 서비스 코드를 따로 짜다가 표준화를 빠뜨렸다고 해 볼게요.
scaler = StandardScaler().fit(train[FEATURES])
lr = LogisticRegression(max_iter=1000).fit(scaler.transform(train[FEATURES]), train["churn"])
right = lr.predict(scaler.transform(test[FEATURES])) # 학습 때와 똑같이 표준화
wrong = lr.predict(test[FEATURES].values) # 서비스 코드가 표준화를 빼먹었어요
print("정확도", r3(accuracy_score(test["churn"], right)), "→", r3(accuracy_score(test["churn"], wrong)))
print("이탈 예측 비율", r3(right.mean()), "→", r3(wrong.mean()))
정확도 0.766 → 0.727
이탈 예측 비율 0.179 → 0.0
정확도만 보면 4%p 떨어졌을 뿐이에요. 그런데 이탈 예측 비율을 보면 0이에요. 모델이 모든 고객을 "이탈 안 함"으로 예측하고 있어요. 이탈하지 않는 고객이 72.7%라서 정확도가 그럭저럭 나왔을 뿐, 이탈 고객을 찾는다는 본래 목적은 완전히 실패했어요. 머신러닝 트랙 평가 강의에서 본 "정확도의 함정"이 서비스 사고로 나타난 거예요. 오류도 나지 않으니 누군가 알아채기 전까지 계속돼요.
막는 방법은 전처리를 모델과 한 덩어리로 묶는 것이에요. 처음 코드에서 make_pipeline(StandardScaler(), LogisticRegression())으로 만든 모델은 저장할 때 표준화 정보까지 함께 저장돼서, 서비스에서 빠뜨릴 수가 없어요. 그리고 뒤에서 볼 예측값 분포 감시를 해 두면, 평소 18% 안팎이던 이탈 예측 비율이 0%로 떨어진 걸 바로 잡을 수 있어요.
3. 들어오는 입력 검사하기
모델은 어떤 숫자를 넣어도 그럴듯한 숫자를 내놓아요. 나이에 150이 들어와도, 결제액에 음수가 들어와도요. 그래서 서비스 입구에서 입력을 검사해요.
LIMITS = {c: (float(train[c].min()), float(train[c].max())) for c in FEATURES}
def predict_one(record):
problems = []
for c in FEATURES:
v = record.get(c)
if not isinstance(v, (int, float)):
return {"ok": False, "problems": [f"{c}: 숫자가 아니에요"]} # 예측하지 않고 거절
if not LIMITS[c][0] <= v <= LIMITS[c][1]:
problems.append(f"{c}={v}: 학습 데이터의 범위 밖이에요")
prob = float(model.predict_proba(pd.DataFrame([record])[FEATURES])[0, 1])
return {"ok": not problems, "churn_prob": round(prob, 3), "problems": problems}
print(predict_one({"age": 35, "hours": 12.0, "spend": 25000, "days": 20}))
print(predict_one({"age": 35, "hours": "많음", "spend": 25000, "days": 20}))
print(predict_one({"age": 150, "hours": 12.0, "spend": 25000, "days": 20}))
{'ok': True, 'churn_prob': 0.044, 'problems': []}
{'ok': False, 'problems': ['hours: 숫자가 아니에요']}
{'ok': False, 'churn_prob': 0.815, 'problems': ['age=150: 학습 데이터의 범위 밖이에요']}
형식이 틀린 입력은 거절하고, 범위 밖의 입력은 예측은 하되 믿기 어렵다고 표시했어요. 나이 말고는 똑같은 고객인데, 나이 150이 들어오자 이탈 확률이 4.4%에서 81.5%로 튀었어요. 모델은 본 적 없는 범위에서 이렇게 엉뚱하게 굴기 쉬워요. 범위 밖 입력이 갑자기 늘면 입력을 만드는 쪽에 버그가 생겼거나, 고객층이 바뀌었다는 신호예요. 그래서 이런 표시는 전부 기록으로 남겨 감시해요.
4. 서비스하는 두 가지 방식
- 배치 예측: 정해진 시간(예: 매일 새벽)에 모든 고객의 이탈 확률을 한꺼번에 계산해서 표에 저장해요. 마케팅 팀은 아침에 그 표를 봐요. 단순하고 싸요.
- 실시간 예측: 요청이 올 때마다 바로 계산해서 돌려줘요. 결제 사기 탐지처럼 그 순간 판단해야 할 때 써요. 모델을 웹 API로 감싸고(FastAPI 같은 도구), 컨테이너(Docker)에 담아 서버에 올려요.
실시간 서비스라면 몇 가지를 더 챙겨요.
- 응답 시간: 평균이 아니라 느린 쪽을 봐요. 요청 100개 중 가장 느린 1개 수준(99번째 백분위수, p99)이 사용자 경험을 망쳐요.
- 모델은 한 번만 불러오기: 서버가 켜질 때 모델을 메모리에 올려 두고, 요청마다 파일을 다시 읽지 않아요.
- 실패했을 때의 대안: 모델이 응답하지 않으면 규칙 기반의 기본값으로 답하게 해서 서비스 전체가 멈추지 않게 해요.
5. 배포는 조금씩
새 모델을 한 번에 모든 사용자에게 내보내면, 문제가 있을 때 모두가 피해를 봐요. 그래서 단계를 밟아요.
- 그림자 배포: 새 모델에게도 실제 요청을 똑같이 보내되, 결과는 사용자에게 보여 주지 않고 기록만 해요. 기존 모델과 결과를 비교해서 이상한 점이 없는지 봐요.
- 카나리 배포: 요청의 일부(예: 5%)만 새 모델이 처리해요. 지표가 괜찮으면 비율을 늘려요. 탄광에서 유독 가스를 먼저 알려 주던 카나리아에서 따온 이름이에요.
- 되돌리기: 문제가 보이면 스위치 하나로 이전 버전으로 돌아가요. 그러려면 이전 버전을 지우지 않고 바로 쓸 수 있게 두어야 해요.
카나리를 얼마나 크게 해야 할까요? 기존 모델의 오류율이 5%인데 새 모델에 버그가 있어 8%라고 할 때, 카나리 요청 수에 따라 그 차이를 얼마나 자주 잡아내는지 시뮬레이션해 볼게요.
rng = np.random.default_rng(5)
for n in (100, 500, 2000):
caught = 0
for _ in range(300):
old_err = rng.binomial(20000, 0.05) # 기존 모델: 요청 2만 건, 오류율 5%
new_err = rng.binomial(n, 0.08) # 새 모델(버그): 카나리 n건, 오류율 8%
table = [[new_err, n - new_err], [old_err, 20000 - old_err]]
caught += stats.fisher_exact(table, alternative="greater").pvalue < 0.05
print(f"카나리 {n}건: {caught / 300:.0%} 확률로 잡아요")
카나리 100건: 27% 확률로 잡아요
카나리 500건: 86% 확률로 잡아요
카나리 2000건: 100% 확률로 잡아요
카나리 100건으로는 버그가 있는 모델을 네 번 중 세 번 놓쳐요. LLM 평가 강의에서 본 것처럼, 표본이 작으면 차이를 볼 수 없어요. 카나리 기간과 비율은 "어느 정도의 문제를 얼마나 확실하게 잡고 싶은가"에서 거꾸로 계산해서 정해요.
6. 배포 뒤 감시: 두 종류의 변화
서비스 중인 모델은 시간이 지나면서 낡아요. 세상이 학습 데이터와 달라지기 때문이에요. 변화에는 두 종류가 있어요.
- 데이터 변화: 들어오는 입력의 분포가 바뀌어요. 예: 광고 덕분에 젊은 고객이 몰려와요.
- 개념 변화: 입력과 정답의 관계가 바뀌어요. 예: 경쟁사가 싼 요금제를 내놓자, 결제액이 많은 고객이 예전보다 쉽게 떠나요.
입력 분포의 변화는 PSI(모집단 안정성 지수)로 흔히 재요. 학습 데이터를 10개 구간으로 나누고, 각 구간에 들어온 비율이 학습 때()와 지금() 얼마나 다른지 더해요.
정보 이론 강의의 KL 발산을 양쪽 방향으로 더한 것과 같은 모양이에요. 흔히 0.1 아래면 안정, 0.1에서 0.25면 주의, 0.25를 넘으면 큰 변화로 봐요.
def psi(expected, actual, bins=10):
edges = np.quantile(expected, np.linspace(0, 1, bins + 1)) # 학습 데이터 기준 10개 구간
edges[0], edges[-1] = -np.inf, np.inf
e = np.histogram(expected, edges)[0] / len(expected)
a = np.histogram(actual, edges)[0] / len(actual)
e, a = np.clip(e, 1e-6, None), np.clip(a, 1e-6, None)
return float(np.sum((a - e) * np.log(a / e)))
scenes = {
"그대로": make_users(2000, seed=2),
"젊은 고객 유입": make_users(2000, seed=3, age_mean=30), # 데이터 변화
"가격에 민감해짐": make_users(2000, seed=4, price_effect=1.5), # 개념 변화
}
for name, df in scenes.items():
prob = model.predict_proba(df[FEATURES])[:, 1]
worst = max(FEATURES, key=lambda c: psi(train[c], df[c]))
print(f"{name}: 가장 큰 PSI {worst} {psi(train[worst], df[worst]):.3f}, "
f"정확도 {r3(accuracy_score(df['churn'], prob > 0.5))}, AUC {r3(roc_auc_score(df['churn'], prob))}")
그대로: 가장 큰 PSI age 0.012, 정확도 0.77, AUC 0.789
젊은 고객 유입: 가장 큰 PSI age 0.893, 정확도 0.791, AUC 0.786
가격에 민감해짐: 가장 큰 PSI age 0.008, 정확도 0.681, AUC 0.707
| 상황 | 입력 감시(PSI) | 실제 성능 |
|---|---|---|
| 그대로 | 조용함 | 그대로 |
| 젊은 고객 유입 (데이터 변화) | 크게 울림 (0.893) | 그대로 |
| 가격에 민감해짐 (개념 변화) | 조용함 (0.008) | 떨어짐 (AUC 0.789에서 0.707) |
이 표가 감시의 핵심을 보여 줘요.
- 입력이 바뀌었다고 성능이 꼭 떨어지는 건 아니에요. 젊은 고객이 몰려왔지만, 나이와 이탈의 관계는 그대로라 모델은 여전히 잘 맞혀요. PSI 경보만 보고 서둘러 다시 학습할 필요는 없어요. 다만 어디서 왜 바뀌었는지는 확인해요.
- 입력이 그대로인데 성능이 떨어질 수 있어요. 개념 변화는 입력만 봐서는 절대 보이지 않아요. 고객들의 나이, 사용 시간, 결제액은 예전과 똑같은데, 그 고객들이 떠나는 이유가 달라졌으니까요.
그래서 감시는 여러 겹으로 해요.
- 시스템: 응답 시간, 오류율, 처리량
- 입력: 빈 값, 범위 밖 값, 분포 변화(PSI)
- 출력: 예측값의 분포. 이탈 예측 비율이 평소 18%였는데 0%나 60%가 되면 무언가 잘못된 거예요. 2번 실습의 사고도 여기서 바로 잡혀요.
- 성능: 정답이 들어오는 대로 실제 정확도를 계산해요. 이탈처럼 정답이 한 달 뒤에야 나오는 경우가 많아서, 늦게라도 꼭 계산해야 해요. 개념 변화를 잡는 유일한 방법이에요.
- 사업 지표: 결국 이 모델 덕분에 이탈이 줄었는가
7. 다시 학습하기
- 언제: 정해진 주기(매달)로 하거나, 성능 감시가 기준 아래로 떨어지면 해요.
- 무엇으로: 최근 데이터를 넣어 학습하고, 가장 최근 기간의 데이터로 평가해요. 미래를 예측하는 모델이니까요.
- 어떻게 바꾸나: 새 모델(도전자)이 지금 모델(챔피언)을 같은 평가 세트에서 이길 때만, 카나리를 거쳐 바꿔요.
- 되먹임 조심: 모델의 예측이 미래 데이터를 바꾸기도 해요. 이탈할 것 같은 고객에게 할인 쿠폰을 보냈더니 실제로 남았다면, 다음 학습 데이터에서 그 고객은 "남은 고객"이 돼요. 모델이 자기 예측의 효과를 학습해 버려요. 일부 고객은 일부러 개입하지 않고 남겨 두는 대조군을 두기도 해요.
LLM 서비스의 운영
LLM을 쓰는 서비스도 같은 원리예요. 몇 가지가 더 있어요.
- 모델 버전 고정: API의 모델 이름에 버전을 명시하고, 제공사가 모델을 바꾸거나 오래된 모델을 내릴 때는 평가 세트로 새 모델을 확인한 뒤 옮겨요.
- 프롬프트도 버전 관리: 프롬프트를 바꾸는 건 모델을 바꾸는 것과 같아요. 바꿀 때마다 평가 세트를 돌려요(LLM 평가 강의).
- 비용과 응답 시간 감시: 요청당 토큰 수가 갑자기 늘면 비용이 바로 늘어요(자동화 강의).
- 안전 감시: 거절 비율, 사용자 신고, 이상한 입력 패턴을 지켜봐요.
실습
make_pipeline없이 표준화와 모델을 따로 저장했다가, 서비스 코드에서 표준화를 빼먹으면 어떻게 되는지 위의 2번처럼 직접 확인해 보세요. 그다음 파이프라인으로 고쳐 보세요.predict_one에 결제액이 음수인 입력을 넣어 보세요. 범위 검사 말고 어떤 규칙을 더하면 좋을까요?- 카나리 시뮬레이션에서 새 모델의 오류율을 6%로 바꾸면, 90% 확률로 잡으려면 카나리가 몇 건 필요한가요?
make_users에age_mean=30과price_effect=1.5를 동시에 주면 PSI와 성능이 어떻게 되나요?- "가격에 민감해짐" 데이터의 절반으로 다시 학습한 모델을 나머지 절반으로 평가해 보세요. AUC가 회복되나요?
자주 하는 실수
- 모델 파일만 저장하기. 데이터 지문, 설정, 환경, 성능을 함께 남겨요.
- 전처리를 서비스 코드에서 다시 짜기. 파이프라인으로 모델과 묶어요.
- 믿을 수 없는 pickle 파일 불러오기. 불러오는 순간 코드가 실행될 수 있어요.
- 입력 검사 없이 예측하기. 모델은 쓰레기 입력에도 그럴듯한 숫자를 내요.
- 한 번에 전부 배포하기. 그림자, 카나리, 되돌리기 순서를 밟아요.
- 작은 카나리로 안심하기. 표본이 작으면 문제를 못 봐요.
- 입력 분포 감시만 하기. 개념 변화는 정답이 들어온 뒤의 성능 감시로만 잡혀요.
점검 문제
- 모델 카드에 남겨야 할 것 다섯 가지는?
- 표준화를 빠뜨린 서비스 코드의 정확도가 72.7%였는데도 심각한 사고인 이유는?
- 학습과 서비스의 전처리 불일치를 막는 방법 두 가지는?
- 그림자 배포와 카나리 배포의 차이는?
- 오류율 5%와 8%를 구별하는 데 카나리 100건이 부족한 이유는?
- 데이터 변화와 개념 변화의 차이는? 어느 쪽이 PSI로 보이나요?
- 이탈 예측 모델의 성능 감시가 늦을 수밖에 없는 이유와, 그래도 해야 하는 이유는?
정답
- 데이터 지문(해시), 설정(하이퍼파라미터와 씨앗), 코드 버전, 환경(라이브러리 버전), 평가 성능이에요.
- 모든 고객을 "이탈 안 함"으로 예측해서 이탈 고객을 한 명도 못 찾았기 때문이에요. 이탈하지 않는 고객이 72.7%라 정확도만 그럴듯하게 나왔어요.
- 전처리를 모델과 하나의 파이프라인으로 묶어 함께 저장하고, 예측값 분포를 감시해서 평소와 다르면 경보를 울려요.
- 그림자 배포는 새 모델의 결과를 사용자에게 보여 주지 않고 기록만 하고, 카나리 배포는 일부 사용자에게 실제로 새 모델의 결과를 보여 줘요.
- 차이가 3%p로 작아서, 100건에서는 우연에 의한 흔들림이 차이보다 커요. 시뮬레이션에서 27%만 잡았어요.
- 데이터 변화는 입력의 분포가 바뀌는 것이고, 개념 변화는 입력과 정답의 관계가 바뀌는 거예요. PSI는 입력 분포를 재니까 데이터 변화만 보여요.
- 이탈했는지는 시간이 지나야 알 수 있어서 정답이 늦게 들어오기 때문이에요. 그래도 개념 변화는 정답과 비교한 성능으로만 잡을 수 있어서 꼭 해야 해요.
다음 강의
지금까지의 모델은 정답이 있는 데이터로 배웠어요. 다음 강의에서는 정답 대신 보상으로 배우는 강화학습을 다뤄요. 시행착오로 미로를 빠져나가는 에이전트를 직접 만들고, 사전 학습과 정렬 강의의 사람 피드백 강화 학습이 어디서 왔는지 이어 봐요.