Day 14｜第 2 周复盘 + 完整 ML Pipeline 实战（AI 学习笔记 · 经典机器学习周 · 第 14 篇）

# 时间特征:从 datetime 拆出有用信号
df['hour']      = df['datetime'].dt.hour
df['dayofweek'] = df['datetime'].dt.dayofweek
df['is_weekend']= df['dayofweek'].isin([5, 6]).astype(int)

# 数值交叉:乘积 / 比值
df['area_per_room'] = df['area'] / df['rooms']

# 文本特征:长度 / 句子数 / 标点数
df['text_len']     = df['text'].str.len()
df['sentence_cnt'] = df['text'].str.count(r'[.!?]')

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression

pipe = Pipeline([
    ("scaler", StandardScaler()),
    ("clf", LogisticRegression()),
])
pipe.fit(X_train, y_train)
pipe.predict(X_test)

from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder

numeric_features     = ["age", "fare"]
categorical_features = ["sex", "embarked"]

preprocessor = ColumnTransformer([
    ("num", StandardScaler(),         numeric_features),
    ("cat", OneHotEncoder(handle_unknown="ignore"), categorical_features),
])

pipe = Pipeline([
    ("pre", preprocessor),
    ("clf", LogisticRegression()),
])

from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression

# 数值流水线:中位数填充 → 缩放
numeric_pipe = Pipeline([
    ("imputer", SimpleImputer(strategy="median")),
    ("scaler",  StandardScaler()),
])

# 类别流水线:众数填充 → OneHot
categorical_pipe = Pipeline([
    ("imputer", SimpleImputer(strategy="most_frequent")),
    ("ohe",     OneHotEncoder(handle_unknown="ignore")),
])

preprocessor = ColumnTransformer([
    ("num", numeric_pipe,     ["age", "fare"]),
    ("cat", categorical_pipe, ["sex", "embarked", "pclass"]),
])

model = Pipeline([
    ("pre", preprocessor),
    ("clf", LogisticRegression(max_iter=1000)),
])

import pandas as pd
from sklearn.model_selection import StratifiedKFold, cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
import lightgbm as lgb

# 1. 加载
df = pd.read_csv("titanic.csv")
y = df["Survived"]
X = df.drop(["Survived", "PassengerId", "Name", "Ticket", "Cabin"], axis=1)

# 2. 复用上面 §4.3 的 preprocessor
model = Pipeline([
    ("pre", preprocessor),
    ("clf", LogisticRegression(max_iter=1000)),
])

# 3. 5 折 CV
skf = StratifiedKFold(5, shuffle=True, random_state=42)
scores = cross_val_score(model, X, y, cv=skf, scoring="accuracy")
print(f"LogReg baseline: {scores.mean():.4f} ± {scores.std():.4f}")

# 4. 横向比较
for clf in [
    LogisticRegression(max_iter=1000),
    RandomForestClassifier(n_estimators=300, random_state=42),
    GradientBoostingClassifier(n_estimators=200, max_depth=3),
    lgb.LGBMClassifier(n_estimators=300, learning_rate=0.05,
                       num_leaves=31, verbose=-1),
]:
    m = Pipeline([("pre", preprocessor), ("clf", clf)])
    s = cross_val_score(m, X, y, cv=skf, scoring="accuracy")
    print(f"{clf.__class__.__name__:30s}  {s.mean():.4f} ± {s.std():.4f}")

import xgboost as xgb
from sklearn.model_selection import train_test_split

# 1. 手动特征工程
df["FamilySize"]  = df["SibSp"] + df["Parch"] + 1
df["IsAlone"]     = (df["FamilySize"] == 1).astype(int)
df["Title"]       = df["Name"].str.extract(r" ([A-Za-z]+)\.")
df["AgeBin"]      = pd.cut(df["Age"], bins=[0,12,18,35,60,100],
                            labels=["child","teen","adult","mid","old"])

X = df.drop(["Survived", "PassengerId", "Name", "Ticket", "Cabin"], axis=1)

# 2. 训练 XGBoost
X_tr, X_te, y_tr, y_te = train_test_split(X, y, stratify=y,
                                          test_size=0.2, random_state=42)
model = Pipeline([
    ("pre", preprocessor),
    ("clf", xgb.XGBClassifier(n_estimators=500, learning_rate=0.05,
                               max_depth=4, subsample=0.8,
                               colsample_bytree=0.8, eval_metric="logloss",
                               random_state=42, n_jobs=-1)),
])
model.fit(X_tr, y_tr)
print("Test Acc:", model.score(X_te, y_te))

def objective(trial):
    params = {
        "n_estimators":  trial.suggest_int("n", 100, 1000),
        "learning_rate": trial.suggest_float("lr", 1e-3, 1e-1, log=True),
        "max_depth":     trial.suggest_int("depth", 3, 10),
        "subsample":     trial.suggest_float("subsample", 0.6, 1.0),
        "colsample_bytree": trial.suggest_float("colsample", 0.6, 1.0),
        "reg_lambda":    trial.suggest_float("l2", 1e-3, 10, log=True),
        "reg_alpha":     trial.suggest_float("l1", 1e-3, 10, log=True),
        "random_state":  42, "n_jobs": -1, "tree_method": "hist",
    }
    m = Pipeline([("pre", preprocessor),
                  ("clf", xgb.XGBClassifier(**params))])
    s = cross_val_score(m, X, y, cv=skf, scoring="accuracy", n_jobs=-1)
    return s.mean()

study = optuna.create_study(direction="maximize")
study.optimize(objective, n_trials=50, show_progress_bar=False)
print("Best acc:", study.best_value, "params:", study.best_params)

from sklearn.ensemble import StackingClassifier

stack = StackingClassifier(
    estimators=[
        ("lr",  LogisticRegression(max_iter=1000)),
        ("rf",  RandomForestClassifier(n_estimators=300, random_state=42)),
        ("lgb", lgb.LGBMClassifier(n_estimators=300, verbose=-1)),
    ],
    final_estimator=LogisticRegression(),
    cv=5,
)
stack.fit(X_tr, y_tr)
print("Stack Test Acc:", stack.score(X_te, y_te))

import joblib
joblib.dump(model, "model_v1.pkl")     # 训练侧保存
model = joblib.load("model_v1.pkl")    # 服务侧加载
pred  = model.predict(X_new)

from skl2onnx import convert_sklearn
from skl2onnx.common.data_types import FloatTensorType

initial_type = [("float_input", FloatTensorType([None, X.shape[1]]))]
onnx_model = convert_sklearn(model, initial_types=initial_type)
with open("model.onnx", "wb") as f:
    f.write(onnx_model.SerializeToString())