scikit-learn으로 끝까지 해 보는 머신러닝 프로젝트

배달 앱의 "예상 도착 시간"을 만드는 프로젝트를 처음부터 끝까지 따라가요. 문제와 지표 정하기, 데이터 둘러보기, 시간 순서로 나누기, 기준점 세우기, 특징 만들기, 교차 검증으로 모델 고르기, 시험 데이터로 마지막 한 번 평가하기, 오차 분석, "늦어도 몇 분" 상한 예측, 모델 저장과 불러오기까지 머신러닝 트랙에서 배운 모든 것을 한 흐름으로 엮어요.

중급강의 8 / 8약 14분

머신러닝 트랙의 마지막 강의예요. 지금까지 배운 조각들을 실제 일의 순서대로 엮어서, 작은 프로젝트 하나를 끝까지 완성해 볼게요. 주제는 배달 앱의 예상 도착 시간이에요. 주문 버튼을 누르기 전에 "약 35분"이라고 보여 주는 그 숫자요.

프로젝트는 대략 이런 순서로 흘러가요. 이 순서 자체가 이번 강의에서 가져가야 할 것이에요.

  1. 문제와 지표 정하기
  2. 데이터 둘러보기
  3. 학습과 시험 데이터 나누기
  4. 기준점 세우기
  5. 특징 만들기와 파이프라인
  6. 교차 검증으로 모델 고르기
  7. 시험 데이터로 마지막 한 번 평가하기
  8. 오차 분석
  9. 저장하고 서비스에 붙이기

1. 문제와 지표 정하기

코드를 쓰기 전에 먼저 정할 것들이 있어요.

  • 무엇을 맞히나: 주문 시점에 알 수 있는 정보로, 실제 배달에 걸린 시간(분)을 맞혀요. 회귀 문제예요.
  • 무엇으로 평가하나: 평균 절대 오차(MAE). "평균 몇 분 틀리나"라서 서비스 담당자와 대화하기 쉬워요.
  • 얼마면 성공인가: 지금은 모든 주문에 "약 32분"이라고 똑같이 보여 주고 있다고 해요. 이걸 확실히 이겨야 하고, 목표는 평균 3분 이내로 정했어요.
  • 주문 시점에 알 수 있는 것만 쓰나: 라이더가 실제로 출발한 시각처럼 주문 뒤에 정해지는 값은 쓰면 안 돼요. 평가 강의의 정답 누수예요.

2. 데이터 둘러보기

석 달치 주문 6,000건이에요. 연습용으로 만든 데이터지만, 음식 종류마다 조리 시간이 다르고, 비나 눈이 오면 느려지고, 점심과 저녁 시간에 밀리는 실제 배달의 특징을 넣어 뒀어요.

import numpy as np
import pandas as pd

rng = np.random.default_rng(2026)
n = 6000
start = pd.Timestamp("2026-08-01")
t = start + pd.to_timedelta(np.sort(rng.uniform(0, 92, n)), unit="D")
hour = rng.choice(np.arange(10, 23), n, p=np.array([2, 6, 9, 7, 3, 2, 3, 6, 9, 8, 6, 4, 2]) / 67)
t = t.normalize() + pd.to_timedelta(hour, unit="h") + pd.to_timedelta(rng.integers(0, 60, n), unit="m")
food = rng.choice(["치킨", "피자", "한식", "카페"], n, p=[.35, .2, .3, .15])
prep = pd.Series(food).map({"치킨": 18, "피자": 20, "한식": 14, "카페": 7}).to_numpy()
dist = np.round(rng.gamma(2.2, 1.0, n), 1) + 0.3
weather = rng.choice(["맑음", "비", "눈"], n, p=[.75, .2, .05])
wmul = pd.Series(weather).map({"맑음": 1.0, "비": 1.25, "눈": 1.6}).to_numpy()
load = rng.poisson(4, n)                          # 가게에 밀린 주문 수
riders = rng.poisson(6, n).astype(float)          # 근처 라이더 수
rush = ((hour >= 11) & (hour <= 13)) | ((hour >= 18) & (hour <= 20))
weekend = t.day_of_week.to_numpy() >= 5
minutes = (prep + 0.6 * load + dist * 3.2 * wmul + np.where(rush, 6, 0) + np.where(weekend & rush, 3, 0)
           - 0.5 * np.minimum(riders, 10) + rng.gamma(2.0, 2.0, n))
riders[rng.random(n) < 0.05] = np.nan             # 라이더 수가 가끔 기록되지 않아요
df = pd.DataFrame({"주문시각": t, "음식": food, "거리km": dist, "날씨": weather,
                   "대기주문": load, "근처라이더": riders, "배달분": minutes.round(1)})
print(df["배달분"].describe()[["mean", "50%", "max"]].round(1).to_dict())   # {'mean': 32.3, '50%': 32.0, 'max': 78.0}
print(df.groupby("날씨")["배달분"].mean().round(1).to_dict())               # {'눈': 36.4, '맑음': 31.7, '비': 33.6}
print(df.groupby(df["주문시각"].dt.hour)["배달분"].mean().round(1).to_dict())

평균 32.3분이고, 눈이 오면 평균 36.4분으로 길어져요. 시간대별로 보면 점심(11시에서 13시)과 저녁(18시에서 20시)에 34분에서 35분, 나머지 시간에는 27분 안팎이에요. 피크 시간이라는 특징을 만들 근거가 데이터에서 보였어요. 이렇게 데이터를 먼저 보는 단계에서 특징 아이디어가 나와요.

3. 시간 순서로 나누기

주문 데이터는 시간이 흐르며 쌓여요. 서비스에서는 과거로 배운 모델로 미래를 예측하죠. 그러니 평가도 그렇게 해야 해요. 무작위로 섞어 나누면 미래 주문으로 과거를 맞히는 셈이라 성적이 부풀려져요(평가 강의의 시간 누수).

def add_features(d):
    d = d.copy()
    h = d["주문시각"].dt.hour
    d["시"] = h
    d["피크"] = (((h >= 11) & (h <= 13)) | ((h >= 18) & (h <= 20))).astype(int)
    d["주말"] = (d["주문시각"].dt.day_of_week >= 5).astype(int)
    d["라이더_빠짐"] = d["근처라이더"].isna().astype(int)
    return d

df = add_features(df)
cut = df["주문시각"].quantile(0.8)                      # 앞의 80%로 배우고, 마지막 20%로 시험
train, test = df[df["주문시각"] < cut], df[df["주문시각"] >= cut]
y_tr, y_te = train["배달분"], test["배달분"]
print(len(train), len(test))                            # 4800 1200

10월 14일 오전까지의 4,800건으로 배우고, 그 뒤 1,200건은 봉인해 둬요. add_features는 각 행 안의 정보만 쓰는 변환이라(전체 평균 같은 걸 쓰지 않아서) 나누기 전에 적용해도 누수가 없어요.

4. 기준점 세우기

"모든 주문에 학습 데이터의 중앙값을 보여 주기"가 기준점이에요. 이걸 못 이기면 모델은 쓸모가 없어요.

5. 특징과 파이프라인, 그리고 6. 교차 검증으로 고르기

전처리 강의의 파이프라인을 그대로 써요. 숫자는 빠진 값을 채우고 표준화하고, 범주는 원핫 인코딩해요. 교차 검증도 시간 순서를 지키는 TimeSeriesSplit을 써요. 항상 앞쪽 데이터로 배우고 바로 뒤 구간으로 검증해요.

from sklearn.base import clone
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from sklearn.impute import SimpleImputer
from sklearn.dummy import DummyRegressor
from sklearn.linear_model import Ridge
from sklearn.ensemble import HistGradientBoostingRegressor
from sklearn.model_selection import TimeSeriesSplit, cross_val_score

num = ["거리km", "대기주문", "근처라이더", "시", "피크", "주말", "라이더_빠짐"]
cat = ["음식", "날씨"]
pre = ColumnTransformer([
    ("num", make_pipeline(SimpleImputer(strategy="median"), StandardScaler()), num),
    ("cat", OneHotEncoder(handle_unknown="ignore"), cat),
])
pipe = lambda model: make_pipeline(clone(pre), model)

cv = TimeSeriesSplit(n_splits=5)
for name, m in [("기준점(중앙값)", pipe(DummyRegressor(strategy="median"))),
                ("릿지", pipe(Ridge(alpha=1.0))),
                ("부스팅", pipe(HistGradientBoostingRegressor(random_state=0)))]:
    mae = -cross_val_score(m, train, y_tr, cv=cv, scoring="neg_mean_absolute_error")
    print(name, mae.round(2), round(mae.mean(), 2))
모델교차 검증 5구간의 MAE (분)평균
기준점 (중앙값)6.49, 6.70, 6.08, 6.35, 6.546.43
릿지2.39, 2.44, 2.22, 2.19, 2.352.32
부스팅2.58, 2.57, 2.24, 2.24, 2.322.39

두 모델 모두 기준점(6.4분)을 크게 이겨요. 부스팅의 설정을 조금 다듬어 볼게요.

from sklearn.model_selection import GridSearchCV

grid = GridSearchCV(pipe(HistGradientBoostingRegressor(random_state=0)),
                    {"histgradientboostingregressor__learning_rate": [0.03, 0.1],
                     "histgradientboostingregressor__max_leaf_nodes": [15, 31]},
                    cv=cv, scoring="neg_mean_absolute_error").fit(train, y_tr)
print(round(-grid.best_score_, 2))   # 2.33

다듬은 부스팅도 2.33분으로 릿지(2.32분)와 사실상 같아요. 평가 강의에서 배운 대로, 차이가 구간별 흔들림(0.1분 이상)보다 작으면 더 단순한 쪽을 고르는 게 현명해요. 릿지는 학습이 빠르고, 가중치로 설명할 수 있고, 서버에서 가볍게 돌아가요. 이 데이터는 대부분 "더하기"로 만들어진 구조라 선형 모델이 충분했던 거예요. 데이터가 복잡했다면 부스팅이 이겼겠죠. 그래서 항상 둘 다 돌려 보는 거예요.

7. 시험 데이터로 마지막 한 번

모델을 정했으니 이제 봉인해 둔 시험 데이터를 열어요. 딱 한 번이에요.

from sklearn.metrics import mean_absolute_error

final = pipe(Ridge(alpha=1.0)).fit(train, y_tr)
pred = final.predict(test)
print(round(mean_absolute_error(y_te, pred), 2))                      # 2.32
base = DummyRegressor(strategy="median").fit(train, y_tr)
print(round(mean_absolute_error(y_te, base.predict(test)), 2))        # 6.48

처음 보는 미래 주문 1,200건에서 평균 2.32분을 틀려요. 기준점(6.48분)의 3분의 1이고, 목표(3분)도 넘어섰어요. 교차 검증 평균(2.32분)과도 같아서, 검증 과정을 믿을 수 있었다는 확인도 돼요.

8. 오차 분석: 어디서 틀리나

평균 하나로 끝내지 말고, 어디서 틀리는지 쪼개 봐요.

res = test.assign(예측=pred, 오차=(pred - y_te).abs())
print(res.groupby("날씨")["오차"].mean().round(2).to_dict())   # {'눈': 2.1, '맑음': 2.32, '비': 2.4}
print(round((res["오차"] <= 5).mean(), 3))                     # 0.922
coef = dict(zip(final[0].get_feature_names_out(), final[-1].coef_.round(2)))
print({k: v for k, v in coef.items() if k.startswith("cat__")})
  • 날씨별 오차는 2.1분에서 2.4분으로 고르게 작아요. 특정 상황에서만 크게 틀리지는 않아요.
  • 주문의 92.2%는 5분 안쪽으로 맞혀요.
  • 음식 종류의 가중치를 보면 피자(+5.2분)와 치킨(+3.3분)이 오래 걸리고 카페(-7.8분)가 빨라요. 조리 시간 차이를 제대로 배웠어요.
  • 가장 크게 틀린 주문들은 가까운 거리인데 40분이 걸린 경우예요. 가게 사정이나 라이더 사고처럼 데이터에 없는 이유로 늦어진 주문이에요. 이런 꼬리는 모델이 맞힐 수 없어요. 대신 아래처럼 "늦어도 몇 분"을 함께 알려 주면 고객의 실망을 줄일 수 있어요.

"늦어도 몇 분": 상한 예측

평균만 맞히는 대신 90번째 백분위수를 맞히도록 학습하면 "열에 아홉은 이 안에 와요"라는 상한을 줄 수 있어요. 손실 함수만 바꾸면 돼요(분위수 손실).

q90 = pipe(HistGradientBoostingRegressor(loss="quantile", quantile=0.9, random_state=0)).fit(train, y_tr)
print(round((y_te <= q90.predict(test)).mean(), 3))      # 0.855

시험 데이터에서 실제 배달 시간이 상한 안에 들어온 비율은 85.5%예요. 목표한 90%보다 조금 낮아요. 학습 기간과 시험 기간의 분위기가 조금 달랐거나, 분위수를 정확히 맞추기가 원래 어려워서예요. 서비스에 쓴다면 이 차이를 보고 기준을 0.93 정도로 올려서 다시 확인하는 식으로 다듬어요.

9. 저장하고 서비스에 붙이기

학습한 파이프라인은 통째로 파일에 저장해요. 전처리까지 함께 저장되니, 서버에서는 주문 정보만 넣으면 돼요.

import joblib

joblib.dump(final, "eta_model.joblib")                # 전처리와 모델을 한 파일로
model = joblib.load("eta_model.joblib")               # 서버에서 불러오기

order = add_features(pd.DataFrame([{"주문시각": pd.Timestamp("2026-11-20 19:10"), "음식": "치킨",
                                    "거리km": 3.0, "날씨": "비", "대기주문": 6, "근처라이더": 4.0}]))
print(round(float(model.predict(order)[0]), 1), round(float(q90.predict(order)[0]), 1))   # 41.7 46.8

금요일 저녁 7시 10분, 비 오는 날, 3km 거리의 치킨 주문은 "약 42분, 늦어도 47분"이에요. 피크 시간, 비, 밀린 주문 6건이 모두 반영된 숫자예요.

배포 뒤에도 일은 계속된다

모델을 서비스에 붙이는 순간부터 새로운 일이 시작돼요. AI 엔지니어링 트랙에서 자세히 다루지만, 핵심만 짚어 둘게요.

  • 감시: 매일 실제 배달 시간과 예측의 차이를 기록해요. 오차가 갑자기 커지면 경보를 울려요.
  • 데이터 변화: 새 동네에 서비스를 열거나, 라이더 정책이 바뀌면 세상이 학습 데이터와 달라져요. 모델이 조용히 나빠져요.
  • 다시 학습: 최신 데이터로 주기적으로 다시 학습하고, 이번 강의와 똑같은 절차로 평가한 뒤 바꿔요.
  • 피드백 고리: 예측이 행동을 바꾸기도 해요. "45분"을 보고 주문을 취소한 사람의 데이터는 쌓이지 않아요.

머신러닝 트랙을 마치며

이번 트랙에서 다룬 것을 한 줄씩 정리하면 이래요.

강의가져갈 한 가지
용어와 지도머신러닝은 데이터에서 규칙을 배우는 일이고, 모델, 손실, 최적화, 일반화로 이뤄져요
학습 방식정답이 있으면 지도, 없으면 비지도, 보상만 있으면 강화, 데이터에서 정답을 만들면 자기 지도
선형 모델표준화, 확률을 주는 로지스틱 회귀, 정규화로 과적합 막기
트리와 앙상블표 데이터의 최강자, 다수결과 잔차 고치기
평가정확도의 함정, 비용으로 기준값 정하기, 교차 검증, 누수
특징 공학좋은 특징이 좋은 모델을 이긴다
비지도 학습군집, 차원 축소, 이상 탐지와 표준화의 중요성
프로젝트문제 정의부터 배포 뒤까지의 순서

실습

  1. 시간 순서 대신 무작위로 섞어 나눠(train_test_split) 같은 실험을 해 보세요. 시험 오차가 어떻게 달라지나요? 왜 그럴까요?
  2. "거리 × 날씨" 상호작용 특징(비나 눈일 때만 거리를 따로 넣는 열)을 만들어 릿지에 추가해 보세요. 오차가 줄어드나요?
  3. 분위수를 0.9에서 0.93, 0.95로 올려 시험 데이터의 실제 포함 비율이 어떻게 변하는지 확인하세요.
  4. 학습 데이터를 앞의 절반만 써서 학습하면 시험 오차가 얼마나 나빠지나요? 데이터 양과 성능의 관계를 그려 보세요.

자주 하는 실수

  • 지표와 성공 기준 없이 시작하기. 끝나는 지점을 모르면 끝없이 다듬게 돼요.
  • 시간 데이터를 무작위로 나누기. 미래로 과거를 맞히게 돼요.
  • 기준점 없이 모델 성능을 자랑하기. "평균 2.3분 오차"는 기준점 6.5분과 함께 말해야 의미가 있어요.
  • 시험 데이터를 여러 번 보기. 모델 선택은 교차 검증으로, 시험은 마지막에 한 번.
  • 배포하고 잊기. 모델은 세상이 변하면 조용히 낡아요.

점검 문제

  1. 예상 도착 시간 모델에 "라이더가 가게에서 출발한 시각"을 특징으로 넣으면 왜 안 되나요?
  2. 이 프로젝트에서 데이터를 시간 순서로 나눈 이유는?
  3. 교차 검증에서 릿지 2.32분, 부스팅 2.33분이 나왔어요. 릿지를 고른 이유는?
  4. 상한 예측의 실제 포함 비율이 목표(90%)보다 낮게 나왔을 때 할 수 있는 일은?
  5. 모델을 저장할 때 전처리까지 파이프라인으로 함께 저장하는 이유는?

정답

  1. 주문 시점에는 알 수 없는 값이라 정답 누수예요. 학습 성적은 좋아도 실제 서비스에서는 쓸 수 없어요.
  2. 서비스에서는 과거로 배워 미래를 예측하니, 평가도 같은 방식으로 해야 부풀려지지 않은 성능을 알 수 있어서예요.
  3. 차이가 교차 검증 구간별 흔들림보다 작아서 우열을 가릴 수 없었고, 그렇다면 빠르고 설명 가능한 단순한 모델이 낫기 때문이에요.
  4. 분위수를 조금 올려 다시 학습하고, 검증 데이터로 포함 비율을 다시 확인해요. 최근 데이터로 다시 학습하는 것도 방법이에요.
  5. 서버에서 학습 때와 똑같은 전처리(같은 중앙값, 같은 평균과 표준편차, 같은 범주 목록)를 실수 없이 적용하기 위해서예요.

다음 강의

다음은 딥러닝 트랙이에요. 선형 모델의 뉴런을 여러 층으로 쌓으면 무엇이 달라지는지, 첫 강의에서 신경망을 numpy로 직접 만들고 역전파로 학습시켜 봐요. 미적분 트랙의 연쇄 법칙이 드디어 주인공이 돼요.