표 데이터 실전 파이프라인

03장에서 결측을 채우고 범주를 원-핫으로 바꿨고, 05장에서 전처리는 훈련 데이터에만 맞춰야 한다고 했고, 06~08장에서 로지스틱 회귀·트리 앙상블·kNN을 교차검증으로 비교했다. 이 장은 이 조각들을 한 덩어리로 묶어 표 데이터 문제 하나를 처음부터 끝까지 푼다. 열마다 다른 전처리를 ColumnTransformer로, 전처리와 모델을 Pipeline으로 묶고, 기준선 → 한 번에 하나씩 개선 → 하이퍼파라미터 탐색 → 제출으로 나아간다. 마지막으로 전처리까지 포함한 모델을 저장해 새 프로세스에서 다시 불러 같은 예측이 나오는지 확인하고, 제출 파일의 행이 양식과 맞는지 점검한다. 2부를 마치며 1·2부의 선택 기준표를 작업 순서대로 정리한다.

9-1. 이 장의 목표와 완료 기준

섹션 제목: “9-1. 이 장의 목표와 완료 기준”
목표 완료 기준
열마다 다른 전처리를 묶는다 숫자·범주 열에 다른 전처리를 ColumnTransformer로 적용하고, 처음 보는 범주·결측이 어떻게 처리되는지 확인한다
전처리와 모델을 한 덩어리로 만든다 Pipeline으로 묶어 교차검증·예측·저장을 한 객체로 한다
기준선부터 잰다 평균만 예측하는 모델과 선형 모델로 기준 점수를 만들고, 이후 개선을 같은 교차검증 조각으로 비교한다
특성 공학을 파이프라인에 넣는다 날짜·비율 특성을 함수로 만들어 FunctionTransformer로 넣고, 치우친 목표를 로그로 바꿔 학습한다
하이퍼파라미터를 탐색한다 GridSearchCV로 파이프라인 안의 인자를 단계__인자 이름으로 탐색하고 결과 표를 읽는다
마지막 확인과 제출을 한다 홀드아웃에서 한 번 확인하고, 전체 훈련 데이터로 다시 학습해 양식과 같은 행 순서의 제출 파일을 만든다
저장하고 다시 불러온다 joblib으로 저장한 파이프라인을 새 프로세스에서 불러 같은 예측을 확인하고, 재현에 필요한 조건을 말한다
1·2부 기준표를 정리한다 표 데이터 작업 순서에 따라 지금까지의 선택 기준을 말한다
실습 노트북 09를 끝낸다 실습/문제/ch09_표_데이터_실전_파이프라인.ipynb의 점검 셀이 모두 “통과”를 출력한다

예상 시간: 원고 1시간 30분, 실습 1시간 30분.

9-2. 왜 파이프라인인가

섹션 제목: “9-2. 왜 파이프라인인가”

지금까지는 전처리 한 단계, 모델 하나를 따로 보여 주었다. 실제 문제에서는 이것들을 이어 붙이다가 틀린다. 자주 깨지는 곳은 세 군데다.

Pipeline은 “원본 표를 받아 예측을 내는 전체 과정”을 객체 하나로 만든다. fit 한 번에 모든 단계가 같은 데이터로 맞춰지고, predict 한 번에 같은 규칙이 적용되고, 저장하면 전처리까지 함께 저장된다. 세 문제 중 앞의 둘을 구조로 막는다. 셋째는 9-7절의 점검으로 막는다.

9-3. 과제와 데이터

섹션 제목: “9-3. 과제와 데이터”

가상 중고차 가격

섹션 제목: “가상 중고차 가격”

중고차 판매 공고 4000건 중 3000건(train)에는 가격이 있고, 1000건(test)에는 없다. test의 가격을 예측해 양식(sample)에 맞춰 제출한다. 지표는 RMSE(만원)이다. 실제 대회·시험의 train.csv, test.csv, sample_submission.csv 구성과 같다.

데이터는 아래 규칙으로 만든다. 가격은 신차 가격(제조사 × 차종 × 연료)에서 해마다 일정 비율씩 빠지고, 수입차·전기차는 더 빨리 빠진다. 한 해 주행거리가 2만 km를 넘으면 더 싸고, 사고가 날 때마다 싸진다. 색상은 가격과 무관하다. 실제 문제에서는 이 규칙을 모른다. 여기서는 개선이 왜 통했는지 확인하려고 알고 시작한다.

import numpy as np
import pandas as pd
def make_cars(n, seed):
rng = np.random.default_rng(seed)
makers = ["현대", "기아", "제네시스", "쉐보레", "르노", "KG", "BMW", "벤츠", "아우디", "볼보", "미니"]
new = dict(zip(makers, [2600, 2500, 5200, 2300, 2200, 2400, 5500, 6000, 5000, 4800, 3500])) # 신차 가격(만원)
body = {"경차": 0.55, "세단": 1.0, "SUV": 1.25, "승합": 1.15}
fuel = {"가솔린": 1.0, "디젤": 1.05, "LPG": 0.85, "하이브리드": 1.15, "전기": 1.3}
df = pd.DataFrame({
"제조사": rng.choice(makers, n, p=[0.30, 0.28, 0.06, 0.07, 0.06, 0.05, 0.07, 0.07, 0.02, 0.01, 0.01]),
"차종": rng.choice(list(body), n, p=[0.15, 0.4, 0.35, 0.1]),
"연료": rng.choice(list(fuel), n, p=[0.5, 0.2, 0.08, 0.14, 0.08]),
"연식": rng.integers(2010, 2025, n),
"색상": rng.choice(["흰색", "검정", "회색", "파랑", "빨강"], n),
})
ad = pd.Timestamp("2024-01-01") + pd.to_timedelta(rng.integers(0, 731, n), unit="D")
df["공고일"] = ad.strftime("%Y-%m-%d") # 판매 공고 날짜(문자열)
age = (ad.year - df["연식"]).clip(lower=0) + rng.uniform(0, 1, n) # 실제 차령(년)
annual = rng.gamma(4.0, 3500, n) # 한 해 주행(km)
df["주행거리"] = (annual * np.maximum(age, 0.3)).round(-2)
df["사고횟수"] = rng.poisson(0.4, n)
imported = df["제조사"].isin(["BMW", "벤츠", "아우디", "볼보", "미니"])
rate = 0.09 + 0.07 * imported + 0.05 * (df["연료"] == "전기") # 해마다 값이 빠지는 비율
log_price = (np.log(df["제조사"].map(new) * df["차종"].map(body) * df["연료"].map(fuel))
- rate * age - 0.25 * (annual > 20000) - 0.08 * df["사고횟수"] + rng.normal(0, 0.12, n))
df["가격"] = np.exp(log_price).round()
df.loc[rng.random(n) < 0.08, "주행거리"] = np.nan
df.loc[rng.random(n) < 0.05, "연료"] = np.nan
df.insert(0, "id", np.arange(1, n + 1))
return df
cars = make_cars(4000, seed=0)
train = cars.iloc[:3000].reset_index(drop=True) # 정답이 있는 표
test = cars.iloc[3000:].drop(columns="가격").reset_index(drop=True) # 정답이 없는 표(제출 대상)
test.loc[[5, 400, 800], "제조사"] = "포르쉐" # 훈련에 없는 제조사
sample = pd.DataFrame({"id": test["id"], "가격": 0.0}) # 제출 양식
print(train.shape, test.shape, sample.shape)
print(train.head(3).to_string())
출력
(3000, 10) (1000, 9) (1000, 2)
id 제조사 차종 연료 연식 색상 공고일 주행거리 사고횟수 가격
0 1 제네시스 SUV 디젤 2010 파랑 2024-05-16 113000.0 0 2288.0
1 2 현대 세단 LPG 2017 빨강 2024-08-06 NaN 0 981.0
2 3 현대 세단 LPG 2022 회색 2024-02-01 18700.0 0 1874.0

먼저 볼 것

섹션 제목: “먼저 볼 것”

모델보다 먼저 결측, 범주, 테스트에만 있는 값, 목표의 분포를 본다(03장).

print("결측:", train.isna().sum()[lambda s: s > 0].to_dict())
print("범주 수:", {c: train[c].nunique() for c in ["제조사", "차종", "연료", "색상"]})
print("테스트에만 있는 제조사:", set(test["제조사"]) - set(train["제조사"]))
print("가격 평균", round(train["가격"].mean()), "/ 중앙값", round(train["가격"].median()), "/ 최대", train["가격"].max(),
"/ 왜도", round(train["가격"].skew(), 2), "→ 로그 뒤", round(np.log(train["가격"]).skew(), 2))
출력
결측: {'연료': 160, '주행거리': 238}
범주 수: {'제조사': 11, '차종': 4, '연료': 5, '색상': 5}
테스트에만 있는 제조사: {'포르쉐'}
가격 평균 1468 / 중앙값 1206 / 최대 8646.0 / 왜도 2.1 → 로그 뒤 0.02

개발·홀드아웃·교차검증

섹션 제목: “개발·홀드아웃·교차검증”

정답이 있는 3000건을 개발(development) 데이터 2400건과 홀드아웃(hold-out) 600건으로 나눈다. 모델 고르기와 탐색은 모두 개발 데이터의 5겹 교차검증으로 하고, 홀드아웃은 다 고른 뒤 한 번만 본다(05장의 테스트 역할). 제출 대상 test에는 정답이 없으니 점수를 잴 수 없다.

from sklearn.model_selection import train_test_split, KFold
X = train.drop(columns=["id", "가격"]) # id는 특성이 아니다
y = train["가격"]
X_dev, X_hold, y_dev, y_hold = train_test_split(X, y, test_size=0.2, random_state=0)
cv = KFold(n_splits=5, shuffle=True, random_state=0) # 모든 비교에 같은 조각
print("개발", X_dev.shape, "/ 홀드아웃", X_hold.shape)
출력
개발 (2400, 8) / 홀드아웃 (600, 8)

9-4. 기준선: ColumnTransformer와 Pipeline

섹션 제목: “9-4. 기준선: ColumnTransformer와 Pipeline”

열마다 다른 전처리

섹션 제목: “열마다 다른 전처리”

숫자 열은 중앙값으로 채우고 표준화하고, 범주 열은 가장 흔한 값으로 채우고 원-핫으로 바꾼다. ColumnTransformer는 열 목록마다 다른 전처리를 적용하고 결과를 옆으로 이어 붙인다. 각 전처리는 make_pipeline으로 여러 단계를 이을 수 있다.

from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline, make_pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
num_cols = ["연식", "주행거리", "사고횟수"]
cat_cols = ["제조사", "차종", "연료"]
def linear_prep(num_cols):
return ColumnTransformer([
("num", make_pipeline(SimpleImputer(strategy="median"), StandardScaler()), num_cols),
("cat", make_pipeline(SimpleImputer(strategy="most_frequent"),
OneHotEncoder(handle_unknown="ignore", sparse_output=False)), cat_cols),
]) # 목록에 없는 열(색상·공고일)은 버린다
prep = linear_prep(num_cols)
Z = prep.fit_transform(X_dev) # 개발 데이터로만 fit
print(Z.shape, list(prep.get_feature_names_out()[[0, 1, 2, 3, 14]]))
print("주행거리 결측을 채운 값(개발 중앙값):", prep.named_transformers_["num"][0].statistics_[1])
print("포르쉐 행의 제조사 열 합:", prep.transform(test.iloc[[5]])[:, 3:14].sum())
출력
(2400, 23) ['num__연식', 'num__주행거리', 'num__사고횟수', 'cat__제조사_BMW', 'cat__차종_SUV']
주행거리 결측을 채운 값(개발 중앙값): 89350.0
포르쉐 행의 제조사 열 합: 0.0

전처리 + 모델 한 덩어리

섹션 제목: “전처리 + 모델 한 덩어리”

Pipeline은 (이름, 단계) 목록을 차례로 잇는다. 이 장의 예측용 파이프라인은 마지막 단계가 모델이고, 앞 단계는 모두 fit/transform을 하는 변환기다(전처리만 묶은 파이프라인은 마지막 단계도 변환기일 수 있다). fit하면 앞 단계부터 fit_transform해 다음 단계에 넘기고, predict하면 앞 단계는 transform만 한다. make_pipeline은 이름을 자동으로 붙이는 줄임 형태다(05·08장).

평균만 예측하는 DummyRegressor와 선형 모델 Ridge(06장)로 기준선을 잰다.

from sklearn.model_selection import cross_val_score
from sklearn.linear_model import Ridge
from sklearn.dummy import DummyRegressor
def cv_rmse(model):
return -cross_val_score(model, X_dev, y_dev, cv=cv, scoring="neg_root_mean_squared_error")
ridge = Pipeline([("prep", linear_prep(num_cols)), ("model", Ridge())])
for name, model in [("평균만 예측", DummyRegressor()), ("Ridge", ridge)]:
s = cv_rmse(model)
print(f"{name:7s} RMSE {s.mean():6.1f} ± {s.std(ddof=1):5.1f}")
ridge.fit(X_dev, y_dev)
print("단계:", list(ridge.named_steps), "/ 테스트 앞 3대 예측", ridge.predict(test.head(3)).round())
출력
평균만 예측 RMSE 957.2 ± 69.6
Ridge RMSE 492.7 ± 42.7
단계: ['prep', 'model'] / 테스트 앞 3대 예측 [766. 556. 771.]
원본 표가 특성 만들기, 열마다 다른 전처리, 모델을 차례로 지나 예측이 되고, 바깥을 목표 변환이 감싼다원본 표가 특성 만들기, 열마다 다른 전처리, 모델을 차례로 지나 예측이 되고, 바깥을 목표 변환이 감싼다

그림 설명. 왼쪽 “원본 표(DataFrame)“에서 오른쪽 “예측(만원)“까지 화살표로 이어진다. 가운데 파란 테두리 상자가 Pipeline이고, 그 안에 차례로 점선 상자 “fe(9-5절): 차령·연간주행 만들기”, 실선 상자 “prep: ColumnTransformer”, “model Ridge”가 있다. ColumnTransformer 안은 두 줄이다. 숫자 열은 SimpleImputer(중앙값) → StandardScaler, 범주 열은 SimpleImputer(최빈값) → OneHotEncoder(ignore)를 지나고, 나머지 열(색상·공고일·id)은 버린다(remainder='drop'). Pipeline 바깥을 점선 상자 “TransformedTargetRegressor(9-5절)“가 감싸며, 학습 때 정답을 log(가격)으로 바꾸고 예측은 exp로 되돌린다. 아래 두 줄은 fit은 앞 단계부터 fit_transform한 결과를 다음 단계로 넘기고, predict는 앞 단계를 transform만 하며, joblib.dump는 바깥 상자 전체를 한 파일로 저장한다는 설명이다.

기준선은 바로 제출해 둔다

섹션 제목: “기준선은 바로 제출해 둔다”

기준선이 나오면 개선보다 먼저 제출 파일까지 한 번 만든다(9-7절의 순서). 시간이 모자라도 0점은 피하고, 제출 형식의 문제를 일찍 발견한다.

9-5. 개선: 한 번에 하나씩

섹션 제목: “9-5. 개선: 한 번에 하나씩”

개선은 한 번에 하나씩 바꾸고 같은 교차검증 조각으로 잰다. 여러 개를 한꺼번에 바꾸면 무엇이 효과였는지 모른다.

치우친 목표는 로그로

섹션 제목: “치우친 목표는 로그로”

신차 가격에 해마다 일정 비율씩 곱해 값이 빠지므로, 가격은 여러 요인의 곱이다. 선형 모델은 요인을 더한다. 로그를 씌우면 곱이 더하기가 된다(a,b>0a, b > 0일 때 log⁡(ab)=log⁡a+log⁡b\log(ab) = \log a + \log b). TransformedTargetRegressor는 학습할 때 정답에 func를 적용하고, 예측을 inverse_func로 되돌린다. 점수는 원래 단위(만원)로 잰다.

from sklearn.compose import TransformedTargetRegressor
def log_target(model):
return TransformedTargetRegressor(model, func=np.log, inverse_func=np.exp)
ridge_log = log_target(ridge)
s = cv_rmse(ridge_log)
print(f"Ridge + 로그 RMSE {s.mean():6.1f} ± {s.std(ddof=1):5.1f}")
출력
Ridge + 로그 RMSE 388.4 ± 52.2

날짜와 비율로 특성 만들기

섹션 제목: “날짜와 비율로 특성 만들기”

특성 공학(feature engineering)은 모델이 쓰기 쉬운 모양으로 특성을 만드는 일이다. 이 데이터에서 가격을 정하는 것은 연식이 아니라 공고 시점의 차령이다. 주행거리도 총량보다 한 해 동안 얼마나 탔는지가 중요하다. 둘 다 원래 열에는 없다.

이 함수를 파이프라인 안에 넣으려면 FunctionTransformer로 감싼다. 저장한 모델을 다른 곳에서 불러오려면 같은 함수를 import할 수 있어야 하므로(9-8절), 함수는 노트북 셀이 아니라 .py 파일에 둔다. 아래 코드는 car_features.py를 만든다. 편집기로 같은 내용의 파일을 만들어도 된다.

from pathlib import Path
Path("car_features.py").write_text('''import pandas as pd
def add_features(df):
"""공고일·연식·주행거리로 차령과 한 해 주행거리를 만든다. 입력 표는 바꾸지 않는다."""
out = df.copy()
year = pd.to_datetime(out["공고일"]).dt.year
out["차령"] = (year - out["연식"]).clip(lower=0) + 0.5
out["연간주행"] = out["주행거리"] / out["차령"]
return out
''', encoding="utf-8")
from car_features import add_features
print(add_features(X_dev.head(3))[["공고일", "연식", "차령", "주행거리", "연간주행"]].round({"연간주행": 0}).to_string())
출력
공고일 연식 차령 주행거리 연간주행
2370 2025-11-19 2020 5.5 53100.0 9655.0
1774 2024-02-19 2022 2.5 8900.0 3560.0
731 2024-10-13 2022 2.5 40400.0 16160.0
from sklearn.preprocessing import FunctionTransformer
fe_cols = ["차령", "주행거리", "연간주행", "사고횟수"]
ridge_fe_log = log_target(Pipeline([("fe", FunctionTransformer(add_features)),
("prep", linear_prep(fe_cols)),
("model", Ridge())]))
s = cv_rmse(ridge_fe_log)
print(f"Ridge + 로그 + 특성 RMSE {s.mean():6.1f} ± {s.std(ddof=1):5.1f}")
출력
Ridge + 로그 + 특성 RMSE 370.7 ± 41.0

트리 모델과 범주 열

섹션 제목: “트리 모델과 범주 열”

07장대로 HistGradientBoosting을 쓴다. 트리는 표준화가 필요 없고 결측을 그대로 받는다. 범주 열은 원-핫 대신 정수로 바꾸고, categorical_features로 “이 열은 범주”라고 알려 주면 범주 묶음으로 나누는 분할을 쓴다. 정수의 크기 순서를 쓰지 않는다.

from sklearn.preprocessing import OrdinalEncoder
from sklearn.ensemble import HistGradientBoostingRegressor
def tree_prep(num_cols):
return ColumnTransformer([
("num", "passthrough", num_cols),
("cat", OrdinalEncoder(handle_unknown="use_encoded_value", unknown_value=np.nan), cat_cols),
], verbose_feature_names_out=False).set_output(transform="pandas") # 열 이름을 유지한 DataFrame으로
def hgb_model(num_cols, fe=False):
steps = [("fe", FunctionTransformer(add_features))] if fe else []
steps += [("prep", tree_prep(num_cols)),
("model", HistGradientBoostingRegressor(categorical_features=cat_cols, random_state=0))]
return log_target(Pipeline(steps))
tp = tree_prep(fe_cols).fit(add_features(X_dev))
print(tp.transform(add_features(test.iloc[[0, 5]])).round({"연간주행": 0}).to_string())
출력
차령 주행거리 연간주행 사고횟수 제조사 차종 연료
0 11.5 130800.0 11374.0 1 10.0 2.0 1.0
5 12.5 166700.0 13336.0 1 NaN 1.0 1.0

같은 조각으로 비교

섹션 제목: “같은 조각으로 비교”

지금까지의 모델을 한 표에 모은다. 모두 같은 cv 조각으로 잰다.

models = {"평균만 예측": DummyRegressor(), "Ridge": ridge, "Ridge+로그": ridge_log,
"Ridge+로그+특성": ridge_fe_log, "HGB+로그": hgb_model(num_cols), "HGB+로그+특성": hgb_model(fe_cols, fe=True)}
scores = {name: cv_rmse(model) for name, model in models.items()}
print("모델 평균 표준편차")
for name, s in scores.items():
print(f"{name:13s} {s.mean():7.1f} {s.std(ddof=1):7.1f}")
print("조각별 (HGB+로그) − (HGB+로그+특성):", (scores["HGB+로그"] - scores["HGB+로그+특성"]).round(1))
출력
모델 평균 표준편차
평균만 예측 957.2 69.6
Ridge 492.7 42.7
Ridge+로그 388.4 52.2
Ridge+로그+특성 370.7 41.0
HGB+로그 297.6 19.4
HGB+로그+특성 276.9 15.9
조각별 (HGB+로그) − (HGB+로그+특성): [ 26.4 -10.3 49.2 19.8 18.2]

9-6. 하이퍼파라미터 탐색

섹션 제목: “9-6. 하이퍼파라미터 탐색”

GridSearchCV와 이름 규칙

섹션 제목: “GridSearchCV와 이름 규칙”

하이퍼파라미터(hyperparameter)는 학습 전에 사람이 정하는 값이다(트리 수, 학습률, C, alpha, k). 06~08장에서는 후보마다 cross_val_score를 for 문으로 돌렸다. GridSearchCV는 후보의 모든 조합을 교차검증하고, 가장 좋은 조합으로 개발 데이터 전체에 다시 학습(refit=True, 기본값)까지 해 준다.

파이프라인 안의 인자는 단계이름__인자(밑줄 두 개)로 부른다. TransformedTargetRegressor 안의 파이프라인은 regressor, 그 안의 모델 단계는 model이므로 학습률은 regressor__model__learning_rate다. 이름이 헷갈리면 get_params()의 키를 본다.

from sklearn.model_selection import GridSearchCV
best_base = hgb_model(fe_cols, fe=True)
print([k for k in best_base.get_params() if k.endswith(("learning_rate", "max_leaf_nodes"))])
grid = {"regressor__model__learning_rate": [0.05, 0.1, 0.2],
"regressor__model__max_leaf_nodes": [7, 15, 31]}
search = GridSearchCV(best_base, grid, cv=cv, scoring="neg_root_mean_squared_error").fit(X_dev, y_dev)
print("고른 값", search.best_params_, "/ 교차검증 RMSE", round(-search.best_score_, 1))
r = pd.DataFrame(search.cv_results_)
print((-r.pivot_table(index="param_regressor__model__learning_rate",
columns="param_regressor__model__max_leaf_nodes", values="mean_test_score")).round(1))
출력
['regressor__model__learning_rate', 'regressor__model__max_leaf_nodes']
고른 값 {'regressor__model__learning_rate': 0.2, 'regressor__model__max_leaf_nodes': 7} / 교차검증 RMSE 267.5
param_regressor__model__max_leaf_nodes 7 15 31
param_regressor__model__learning_rate
0.05 324.6 286.3 282.4
0.10 276.0 269.3 276.9
0.20 267.5 272.3 280.9
교차검증 RMSE가 평균만 예측 957에서 탐색한 HGB 268까지 한 단계씩 줄고, 탐색 표에서는 학습률 0.2·잎 7개가 가장 낮다교차검증 RMSE가 평균만 예측 957에서 탐색한 HGB 268까지 한 단계씩 줄고, 탐색 표에서는 학습률 0.2·잎 7개가 가장 낮다

그림 설명. 왼쪽 막대그래프는 같은 조각으로 잰 교차검증 RMSE(만원, 세로 0~1120)다. 한 번에 하나씩 바꾼 순서로 평균만 예측 957, Ridge 493, Ridge+로그 388, Ridge+로그+특성 371, HGB+로그+특성 277, 탐색한 HGB 268로 줄어든다(특성 없는 HGB+로그 298은 특성의 효과를 보는 별도 비교라 그림에서 뺐다). 막대 끝의 선은 조각 간 표준편차이고(탐색한 HGB는 없다), 색은 회색(기준선), 파랑(Ridge 계열), 초록(HGB 계열), 빨강(탐색)이다. 오른쪽은 GridSearchCV 9개 조합의 교차검증 RMSE 표로, 세로가 learning_rate(0.05·0.1·0.2), 가로가 max_leaf_nodes(7·15·31)다. 값이 작을수록 진한 파랑이다. 0.05·7이 324.6으로 가장 크고, 0.2·7이 267.5로 가장 작아 빨간 테두리로 표시했다. 기본값 0.1·31은 276.9다.

탐색 방법 고르기

섹션 제목: “탐색 방법 고르기”
상황 방법 이유
인자 1~2개, 후보가 적다 GridSearchCV 모든 조합을 본다. 결과 표를 읽기 쉽다
인자가 여럿이거나 범위가 넓다 RandomizedSearchCV(n_iter=…) 정해진 횟수만 무작위로 뽑는다. 중요한 인자 몇 개에 대해서는 같은 시간에 더 많은 값을 본다
선형 모델의 정규화 강도 하나 LogisticRegressionCV·RidgeCV(06장) 탐색이 내장돼 빠르다

탐색 점수는 낙관적이다

섹션 제목: “탐색 점수는 낙관적이다”

best_score_는 9개 중 가장 좋았던 점수다. 같은 조각에서 여러 번 골랐으므로 새 데이터에서는 대개 이보다 나쁘다(05장: 고르는 데 쓴 점수는 낙관적이다). 그래서 다 고른 뒤 홀드아웃에서 한 번 확인한다.

from sklearn.metrics import root_mean_squared_error
for name, model in [("Ridge(기준선)", ridge.fit(X_dev, y_dev)),
("HGB+로그+특성(기본값)", hgb_model(fe_cols, fe=True).fit(X_dev, y_dev)),
("탐색으로 고른 HGB", search)]:
print(f"{name:16s} 홀드아웃 RMSE {root_mean_squared_error(y_hold, model.predict(X_hold)):6.1f}")
출력
Ridge(기준선) 홀드아웃 RMSE 566.0
HGB+로그+특성(기본값) 홀드아웃 RMSE 316.5
탐색으로 고른 HGB 홀드아웃 RMSE 309.1

9-7. 제출

섹션 제목: “9-7. 제출”

전체로 다시 학습하고 양식에 맞춘다

섹션 제목: “전체로 다시 학습하고 양식에 맞춘다”

고른 설정으로 정답이 있는 3000건 전체에 다시 학습한다. 데이터가 많을수록 대개 낫고, 설정은 이미 정했으니 더 나눌 이유가 없다. clone은 같은 설정의 학습 전 모델을 만든다.

from sklearn.base import clone
final = clone(search.best_estimator_).fit(X, y) # 개발 + 홀드아웃 전체로 다시 학습
pred = final.predict(test) # 열 이름으로 고르므로 id 열은 쓰이지 않는다
sub = pd.DataFrame({"id": test["id"], "가격": pred.round()}) # id와 예측을 같은 표에서 짝짓는다
sub = sample[["id"]].merge(sub, on="id", how="left", validate="one_to_one") # 양식의 id 순서로
print(sub.head(3).to_string(), "\n행", len(sub), "/ 빈 예측", sub["가격"].isna().sum(), "/ 최솟값", sub["가격"].min())
출력
id 가격
0 3001 874.0
1 3002 736.0
2 3003 929.0
행 1000 / 빈 예측 0 / 최솟값 280.0

행 대응 점검

섹션 제목: “행 대응 점검”

제출 전에 양식과 비교하는 함수를 하나 만들어 둔다.

def check_submission(sub, sample):
problems = []
if list(sub.columns) != list(sample.columns):
problems.append(f"열 이름 {list(sub.columns)}")
if len(sub) != len(sample):
problems.append(f"행 수 {len(sub)} ≠ {len(sample)}")
elif not np.array_equal(sub["id"].to_numpy(), sample["id"].to_numpy()):
problems.append("id 순서가 양식과 다르다")
if sub["id"].duplicated().any():
problems.append("중복 id")
if sub[sample.columns[1]].isna().any():
problems.append("빈 예측")
return problems or ["문제 없음"]
print("제출:", check_submission(sub, sample))
by_maker = test.sort_values("제조사") # 둘러보다 정렬해 둔 표
wrong = sample.copy()
wrong["가격"] = final.predict(by_maker).round() # 정렬된 순서의 예측을 양식에 그대로 붙임
print("정렬된 예측을 양식에 붙임:", check_submission(wrong, sample), "/ 예측값이 같은 행", (wrong["가격"] == sub["가격"]).sum(),
"개 / 제자리인 차", (by_maker["id"].to_numpy() == test["id"].to_numpy()).sum(), "대")
print("dropna한 표로 예측:", check_submission(pd.DataFrame({"id": test.dropna()["id"], "가격": 1.0}), sample))
출력
제출: ['문제 없음']
정렬된 예측을 양식에 붙임: ['문제 없음'] / 예측값이 같은 행 3 개 / 제자리인 차 2 대
dropna한 표로 예측: ['행 수 855 ≠ 1000']

9-8. 저장·재로딩·재현

섹션 제목: “9-8. 저장·재로딩·재현”

joblib으로 저장

섹션 제목: “joblib으로 저장”

joblib은 sklearn과 함께 설치되는 저장 도구다. 파이프라인을 통째로 저장하면 전처리와 모델이 함께 저장된다. 이 장의 최종 모델에는 범주 인코딩 목록, 특성 함수 참조, 학습된 트리, 로그 되돌리기가 들어 있다(결측을 중앙값으로 채우는 단계가 있으면 그 중앙값도 들어간다). 학습에 쓴 열 목록과 sklearn 버전도 함께 넣어 둔다.

import joblib, sklearn
bundle = {"model": final, "columns": list(X.columns), "sklearn": sklearn.__version__}
joblib.dump(bundle, "car_price.joblib")
loaded = joblib.load("car_price.joblib")
print("버전 같음:", loaded["sklearn"] == sklearn.__version__,
"/ 같은 예측:", np.array_equal(loaded["model"].predict(test[loaded["columns"]]), pred))
출력
버전 같음: True / 같은 예측: True

새 프로세스에서 불러오기

섹션 제목: “새 프로세스에서 불러오기”

같은 노트북 안의 재로딩은 메모리에 남은 함수·변수 덕분에 될 수도 있다. 진짜 확인은 새 프로세스에서 한다. 제출용 스크립트 predict.py를 만들어 별도 파이썬으로 실행한다(터미널에서 python predict.py를 친 것과 같다).

import subprocess, sys
test.to_csv("test.csv", index=False)
np.save("pred.npy", pred)
Path("predict.py").write_text('''import joblib, numpy as np, pandas as pd, sklearn
bundle = joblib.load("car_price.joblib")
assert bundle["sklearn"] == sklearn.__version__, "학습 때와 sklearn 버전이 다르다"
test = pd.read_csv("test.csv")
pred = bundle["model"].predict(test[bundle["columns"]])
print("새 프로세스에서 같은 예측:", np.array_equal(pred, np.load("pred.npy")))
''', encoding="utf-8")
run = subprocess.run([sys.executable, "-X", "utf8", "predict.py"], capture_output=True, text=True, encoding="utf-8")
print(run.stdout.strip() or run.stderr[-500:])
출력
새 프로세스에서 같은 예측: True
import shutil, tempfile
elsewhere = tempfile.mkdtemp() # car_features.py가 없는 폴더
shutil.copy("car_price.joblib", elsewhere)
run = subprocess.run([sys.executable, "-X", "utf8", "-c", "import joblib; joblib.load('car_price.joblib')"],
capture_output=True, text=True, encoding="utf-8", cwd=elsewhere)
print(run.stderr.strip().splitlines()[-1])
출력
ModuleNotFoundError: No module named 'car_features'

같은 예측이 나오는 조건

섹션 제목: “같은 예측이 나오는 조건”
again = clone(final).fit(X, y).predict(test)
print("같은 설정으로 다시 학습:", np.array_equal(again, pred))
Xf, ylog = add_features(X)[fe_cols], np.log(y)
for rs in [0, 0, 1, 2]:
m = HistGradientBoostingRegressor(early_stopping=True, random_state=rs).fit(Xf, ylog)
print(f"조기 종료, random_state={rs}: 트리 {m.n_iter_}개")
출력
같은 설정으로 다시 학습: True
조기 종료, random_state=0: 트리 34개
조기 종료, random_state=0: 트리 34개
조기 종료, random_state=1: 트리 30개
조기 종료, random_state=2: 트리 37개

9-9. 선택 기준표에 추가

섹션 제목: “9-9. 선택 기준표에 추가”
상황 고를 것 이유 장
열마다 전처리가 다른 표 데이터 ColumnTransformer(숫자: 채우기·표준화, 범주: 채우기·원-핫/정수) + 모델을 Pipeline 하나로 교차검증·예측·저장에 같은 규칙이 저절로 적용된다 09
문제를 처음 받았다 평균(또는 최빈값) 예측 → 선형 모델 기준선 → 제출 파일까지 먼저 개선의 비교 기준과 0점 방지 제출이 생긴다 09
정답이 양수이고 오른쪽으로 길게 치우친 회귀(가격·소득) TransformedTargetRegressor(func=np.log, inverse_func=np.exp), 점수는 원래 단위로 곱으로 얽힌 관계가 더하기가 되고, 큰 값 몇 개에 끌려가지 않는다 09
날짜·비율 같은 특성을 만든다 행 단위 함수는 .py 모듈 + FunctionTransformer로 파이프라인 안에, 전체 통계를 쓰는 특성은 fit이 있는 변환기로 훈련·예측 규칙이 같아지고 저장 모델을 다른 곳에서 불러올 수 있다 09
하이퍼파라미터를 고른다 마지막 단계에서 GridSearchCV(인자가 많으면 RandomizedSearchCV), 단계__인자 이름, 홀드아웃 한 번 확인 탐색 점수는 낙관적이고, 시간이 곱으로 들며 데이터 모양이 바뀌면 다시 해야 한다 09
제출 파일을 만든다 id와 예측을 같은 표에서 짝짓고 양식 id로 merge, 점검 함수 + 다시 읽어 확인, 테스트 행은 지우지 않는다 정렬·삭제로 어긋난 행은 오류 없이 점수를 망친다 09
모델을 저장해 다른 곳에서 쓴다 joblib으로 파이프라인 통째 + 열 목록·버전, 새 프로세스에서 같은 예측 확인, random_state 고정 전처리를 빠뜨리지 않고, 버전·무작위성 차이를 잡는다. 믿을 수 없는 파일은 열지 않는다 09

9-10. 1·2부 선택 기준표 정리

섹션 제목: “9-10. 1·2부 선택 기준표 정리”

01~09장의 기준표를 표 데이터 작업 순서로 다시 묶는다. 각 줄의 자세한 이유는 장 열의 장에 있다. 19장에서 3·4부와 합쳐 데이터 종류·양·라벨·설명 필요성·지연·비용 기준으로 다시 정리한다.

단계 판단 기본 선택 장
방법 규칙이 법·정책으로 정해져 있나, 정답 달린 예시가 있나 정해진 규칙은 규칙 기반, 정답 달린 예시가 있으면 지도 학습, 정답이 없으면 비지도(아래 ‘정답 없음’). 꼭 지킬 조건은 규칙 + 모델 01
데이터 모양 모델이 받는 모양인가 (표본, 특성) 숫자 배열, 계산은 벡터화 02
데이터 확인 결측·범주·중복 키·목표 분포 숫자 결측은 훈련 중앙값 + 결측 표시, 범주 결측은 최빈값 또는 별도 범주, 순서 없는 범주는 원-핫(ignore), ID는 뺀다, 합칠 때 merge(validate=…) 03·09
나누기 어떻게 채점할까 훈련·검증(교차검증)·테스트, 분류는 층화, 테스트는 마지막 한 번 05
지표 무엇이 비싼 실수인가 불균형이면 정확도 대신 재현율·정밀도·F1·AUC, 회귀는 RMSE·MAE. 임계값은 목적에 맞게 05
전처리 fit하는 단계가 있나 모두 파이프라인 안에서 훈련 부분으로만 fit 05·09
기준선 무엇과 비교할까 평균·최빈값 예측 → 선형(회귀: LinearRegression·Ridge, 분류: 표준화 + LogisticRegression) 04·06·09
개선 무엇부터 바꿀까 목표 변환·특성 공학 → 트리 앙상블(랜덤 포레스트, HistGradientBoosting + 조기 종료) 06·07·09
선형 모델 정규화·스케일 표준화 후 C·alpha를 로그 간격으로 교차검증, 쓸모 있는 특성이 일부면 L1 06
거리 모델 kNN·k-평균·PCA를 쓰나 표준화, k·성분 수는 교차검증·설명된 분산으로 08
정답 없음 묶기·줄이기·찾기 k-평균(n_init), PCA, 정규화 + 코사인 검색. 결과는 사람이 해석 08
탐색 하이퍼파라미터 마지막에 GridSearchCV·RandomizedSearchCV, 홀드아웃 한 번 09
해석 무엇이 중요했나 검증 데이터 순열 중요도, 인과로 읽지 않는다 07
제출·저장 같은 규칙, 같은 행 전체로 다시 학습, id로 맞춘 제출 + 점검, 파이프라인 통째 저장 + 새 프로세스 확인 09

확인 문제

섹션 제목: “확인 문제”

9-11. 실습과 문제

섹션 제목: “9-11. 실습과 문제”

실습/문제/ch09_표_데이터_실전_파이프라인.ipynb를 .venv 커널로 열고 위에서부터 푼다. 내려받기가 없고 CPU로 1분 안팎에 끝난다. 다 푼 뒤 해설 노트북과 비교한다. 실습은 원고와 다른 가상 데이터(분류)로 같은 과정을 밟는다.

번호 유형 내용
1 개념 파이프라인·누수 참/거짓
2 코드 숫자·범주 열 전처리를 ColumnTransformer로
3 코드 날짜·비율 특성 함수
4 코드 같은 조각으로 기준선과 모델 비교
5 코드 파이프라인 안의 인자를 GridSearchCV로 탐색
6 코드 id로 맞춘 제출 파일과 점검
7 코드 저장·재로딩 후 같은 예측 확인
8 개념 탐색·제출·저장 참/거짓
9 사례 검증보다 크게 낮은 제출 점수
10 사례 1·2부 상황별 선택

9-12. 공식 문서와 참고 자료

섹션 제목: “9-12. 공식 문서와 참고 자료”