Bài 3: Quy trình build model ML — từ raw data tới deploy

Một ML project điển hình đi qua nhiều bước: hiểu bài toán, thu thập data, làm sạch, chọn feature, train, đánh giá, deploy, monitor. Mỗi bước đều có khả năng tạo bug hoặc đưa bias vào model — và bug ML khó phát hiện hơn bug code thông thường, vì code vẫn chạy nhưng kết quả sai lệch.

Vài ví dụ thực tế:

• Label sai 5% → accuracy report 95% nhưng model thực ra học nhiễu.
• Scale dữ liệu trước khi split → metric trên test set lệch lên (data leakage).
• Train tập có 99% class A, 1% class B → model chỉ cần đoán toàn A là đã 99% accuracy, nhưng vô dụng cho class B.

Một quy trình rõ ràng giúp:

• Reproducibility — chạy lại ra cùng kết quả.
• Debug dễ — biết bước nào hỏng để quay lại fix.
• Tách trách nhiệm — nhiều người cùng làm trên cùng pipeline.

CRISP-DM (Cross-Industry Standard Process for Data Mining) ra đời năm 1996, đến nay vẫn là framework được trích dẫn nhiều nhất cho data mining và ML. Gồm 6 phase:

1. Business Understanding — hiểu mục tiêu kinh doanh, định nghĩa thành công bằng số đo nào.
2. Data Understanding — thu thập data ban đầu, mô tả, khám phá, kiểm tra chất lượng.
3. Data Preparation — clean, transform, tạo feature, ghép dữ liệu, định dạng cuối cho modeling.
4. Modeling — chọn thuật toán, train, tune hyperparameter.
5. Evaluation — đánh giá model có giải quyết được mục tiêu business không, không chỉ nhìn metric.
6. Deployment — đưa model ra production, viết doc, plan monitoring.

6 phase này không tuyến tính. Mũi tên trong sơ đồ gốc đi cả 2 chiều: từ Evaluation có thể quay về Business Understanding, từ Modeling có thể quay về Data Preparation. Đây là điểm cốt lõi — ML là quy trình lặp.

Adaptation trong industry: nhiều công ty không follow CRISP-DM nguyên bản. Họ rút gọn còn 5 bước, hoặc gộp Business + Data Understanding, hoặc thêm phase Monitoring riêng. Microsoft có Team Data Science Process (TDSP), Google có ML lifecycle riêng. Tinh thần thì giống nhau.

Trong series này dùng 7 bước rút gọn, phù hợp với ML cổ điển và workflow của sklearn:

1. Define problem — supervised hay unsupervised? Regression, classification, clustering? Metric thành công là gì (RMSE, F1, recall ≥ 0.9)?
2. Collect / load data — đọc CSV, query database, gọi API, scrape web, lấy từ data lake. Đảm bảo có quyền dùng data.
3. EDA (Exploratory Data Analysis) — vẽ histogram, scatter, correlation, đếm missing, xem phân phối class. Đã preview ở Series 1 Bài 36 (Pandas + Matplotlib).
4. Preprocessing — clean missing, encode categorical, scale số, split train/test. Module 2 sẽ deep dive từ Bài 6 đến Bài 14.
5. Train model — fit thuật toán đã chọn trên train set.
6. Evaluate — chạy trên test set, tính metric. Nếu chưa đạt → quay lại bước 3 hoặc 4.
7. Iterate / Deploy — tune hyperparameter, thử thuật toán khác, hoặc đưa lên production (deploy là chủ đề chính của Series 5 — System Deployment).

7 bước này không "thay thế" CRISP-DM; nó là cách diễn đạt thực dụng cho người mới. Sau khi quen, sẽ thấy bước 1 chính là Business Understanding, bước 2–3 là Data Understanding, bước 4 là Data Preparation, bước 5–6 là Modeling + Evaluation, bước 7 là Deployment.

Trên giấy quy trình là 1→2→3→...→7. Thực tế nó là vòng lặp. Vài tình huống điển hình:

• Evaluate kém → quay lại bước 4 (Preprocessing) thử feature engineering khác, hoặc bước 5 đổi thuật toán.
• Model quá đơn giản (underfit) → thử model phức tạp hơn: Linear → Random Forest → Gradient Boosting.
• Model quá phức tạp (overfit) → giảm độ phức tạp, thêm regularization, thu thêm data.
• Phát hiện data leak (test accuracy cao bất thường) → quay lại bước 4, kiểm tra cách split và scale.
• Phát hiện label sai → quay lại bước 2 thu thập / kiểm tra lại nguồn.
• Production drift (model deploy rồi nhưng metric xuống dốc) → trigger retrain, có thể phải redefine cả problem.

Người mới hay nghĩ "train xong là xong". Thực tế phần lớn thời gian một ML engineer ngồi loop giữa bước 3 (EDA), bước 4 (Preprocessing) và bước 6 (Evaluate). Code train chỉ vài dòng; phần khó là hiểu data và iterate.

Đây là pitfall thường gặp nhất với người mới và là nguyên nhân số 1 khiến report nội bộ "đẹp" nhưng deploy ra production thì model dở. Tên gọi: data leakage — thông tin từ test set "rò rỉ" vào quá trình train.

Cách SAI

# SAI - scale TRƯỚC khi split
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)  # mean, std tính trên TOÀN BỘ data

X_train, X_test, y_train, y_test = train_test_split(
    X_scaled, y, test_size=0.2, random_state=42
)
# mean của test set đã "tham gia" tính mean dùng cho train → leak

Cách ĐÚNG

# ĐÚNG - split TRƯỚC, fit scaler chỉ trên train
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)   # fit + transform trên train
X_test = scaler.transform(X_test)         # CHỈ transform trên test

Quy tắc tổng quát: bất kỳ transformation nào "học" từ data (scaler, encoder, PCA, imputer điền missing bằng mean) đều phải fit trên train, rồi chỉ transform trên validation và test. Sklearn Pipeline (Bài 14) giúp tránh quên quy tắc này.

Tỷ lệ chia phổ biến: 60/20/20 hoặc 70/15/15. Vai trò từng tập:

• Train — model thấy data này và học tham số (weight, coefficient, cây).
• Validation — model không thấy lúc fit, dùng để chọn hyperparameter (depth của tree, learning rate, số neuron) và so sánh các model với nhau.
• Test — chốt cuối cùng. Dùng 1 lần sau khi mọi quyết định đã xong, để ước lượng performance thật trên data chưa từng thấy.

Tại sao cần 3 phần, không phải 2? Nếu chỉ có train/test mà tune hyperparameter dựa trên test, thì test set đã gián tiếp "huấn luyện" model — metric không còn unbiased nữa. Validation set tách riêng để tune, test set giữ "trinh nguyên" cho đánh giá cuối.

Khi data ít, dùng cross-validation (Bài 39) thay cho validation set cố định.

Bài 6 sẽ deep dive về train/val/test split, cross-validation, stratified split cho data imbalance.

• Data leakage qua preprocessing — đã nói ở mục 5. Còn dạng leak khác: tạo feature dùng future information (vd dùng giá đóng cửa hôm sau để dự đoán hôm nay), join nhầm table chứa label.
• Overfit train set — model nhớ thuộc data train, train accuracy 99% nhưng val accuracy chỉ 70%. Dấu hiệu rõ qua learning curve (Bài 37).
• Test set bị "nhìn" nhiều lần — mỗi lần chỉnh model rồi đo trên test, đó là một lần leak gián tiếp. Sau 50 lần đo, test set đã thành validation set trá hình.
• Imbalanced data — bài toán fraud có 99.5% giao dịch sạch, 0.5% fraud. Đoán "sạch" hết là đã 99.5% accuracy nhưng không bắt được một fraud nào.
• Wrong metric — chọn metric không match business goal. Với fraud detection nên nhìn Recall (bắt được bao nhiêu % fraud thật) hoặc Precision-Recall AUC, không phải Accuracy.
• Random seed không cố định — chạy lại ra kết quả khác → không reproducible. Luôn đặt random_state.
• Data drift — data production khác data train (distribution khác). Cần monitoring sau deploy.

Mỗi loại bài toán có metric riêng. Module 3 và 4 sẽ deep dive; ở đây liệt kê tổng quan để có khái niệm.

Regression (dự đoán số)

• MSE (Mean Squared Error) — trung bình bình phương sai số.
• RMSE — căn bậc 2 của MSE, cùng đơn vị với target.
• MAE (Mean Absolute Error) — ít nhạy với outlier hơn MSE.
• R² — mức độ giải thích phương sai, dao động trong (−∞, 1].

Classification (phân loại)

• Accuracy — tỉ lệ đoán đúng. Chỉ tin được khi data cân bằng.
• Precision — trong số dự đoán dương, bao nhiêu % đúng.
• Recall — trong số dương thật, bao nhiêu % bắt được.
• F1 — harmonic mean của Precision và Recall.
• AUC-ROC — diện tích dưới đường ROC, đánh giá khả năng phân tách 2 class.

Clustering (gom nhóm)

• Silhouette Score — đo mức độ "chặt" trong cluster vs cách biệt giữa các cluster.
• Davies-Bouldin Index, Calinski-Harabasz Index.

Quy tắc: chọn metric trước khi train, không phải sau. Nếu chọn metric sau khi nhìn kết quả, dễ rơi vào bias confirmation.

Sklearn cung cấp class Pipeline để đóng gói chuỗi preprocessing + model thành 1 object duy nhất. Lợi ích:

• Tránh duplicate code: không phải scale lại trên test thủ công, pipeline tự lo.
• Tránh data leak: fit chỉ chạy trên train; predict tự gọi đúng transform trên test.
• Dễ tune: GridSearchCV nhận luôn pipeline, tune hyperparameter của cả scaler lẫn model trong 1 lần.
• Dễ deploy: lưu pipeline thành file .pkl hoặc .joblib, load ở production và predict trực tiếp.

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)        # scale train + train model
score = pipe.score(X_test, y_test)  # tự scale test rồi predict

Bài 14 sẽ thực hành Pipeline với ColumnTransformer cho data có cả số và categorical.

Khi ra production, một model không đứng riêng. Mỗi lần retrain sinh ra một "version" mới, kèm theo:

• Snapshot data dùng để train (hash hoặc tên dataset + version).
• Code + git commit của pipeline.
• Hyperparameter.
• Metric trên validation và test.
• Artifact (file .pkl, .onnx, hoặc thư mục checkpoint).

Công cụ phổ biến: MLflow, Weights & Biases, DVC, SageMaker Model Registry, Vertex AI Model Registry. Khi cần rollback (model mới có vấn đề ở production), chỉ việc switch về version cũ trong registry. Series 5 (AI System Deployment) sẽ đi sâu.

MLOps = DevOps + Machine Learning. Vòng đời rút gọn của một model ở production:

1. Train — script hoặc pipeline tự động, có thể trigger định kỳ.
2. Validate — kiểm metric, kiểm bias, smoke test trên data mới.
3. Deploy — đưa model lên server (REST API), batch job, hoặc embed vào app.
4. Monitor — log prediction, đo latency, đo metric thực tế (so với ground truth khi có), phát hiện drift.
5. Retrain — khi metric tụt hoặc data drift vượt ngưỡng, tự động hoặc thủ công train lại với data mới rồi đi qua bước 2.

Workflow này không phải bài toán của Bài 3, nhưng cần biết trước để khi viết code ở Series 2 không quên log seed, save model, save metadata — những thứ Series 5 sẽ cần.

15 dòng code, đi đủ 5 bước cốt lõi: load → split → preprocess → train → evaluate. Mục đích để thấy bộ khung; chi tiết từng API sẽ học ở các bài sau.

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report

# 1. Load
X, y = load_iris(return_X_y=True)

# 2. Split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42
)

# 3. Preprocess (fit chỉ trên train)
scaler = StandardScaler().fit(X_train)
X_train_s = scaler.transform(X_train)
X_test_s = scaler.transform(X_test)

# 4. Train
model = LogisticRegression(max_iter=200).fit(X_train_s, y_train)

# 5. Evaluate
y_pred = model.predict(X_test_s)
print("Accuracy:", accuracy_score(y_test, y_pred))
print(classification_report(y_test, y_pred))

Ghi chú:

• stratify=y đảm bảo tỉ lệ 3 class iris được giữ nguyên ở train và test.
• random_state=42 để reproducible.
• scaler.fit chỉ chạy trên train — đúng nguyên tắc tránh leak.
• Iris là dataset cân bằng, dễ → accuracy thường > 95%. Đừng kỳ vọng con số đẹp này lặp lại trên data thực.

Bài 1 — Lập kế hoạch 7 bước

Bài toán: phân loại ảnh X-ray phổi thành "bình thường" / "viêm phổi". Viết ra 7 bước cụ thể bạn sẽ làm. Với mỗi bước, ghi rõ:

• Input của bước đó là gì.
• Output của bước đó là gì.
• Một rủi ro có thể gặp ở bước đó.

Gợi ý: ở bước 1 (Define), tự hỏi "false negative nguy hiểm hơn hay false positive nguy hiểm hơn?" để chọn metric phù hợp (Recall hay Precision).

Bài 2 — Hunt data leakage

Cho workflow sau cho bài toán dự đoán tỉ lệ chuyển đổi (conversion) của user trên website. Tìm ít nhất 3 chỗ có thể leak:

1. Lấy data 12 tháng gần nhất, mỗi row = 1 session.
2. Tạo feature "total_sessions_of_user" = đếm tổng số session của user đó trong cả 12 tháng.
3. Encode feature "country" bằng mean target encoding (mean conversion của country đó) tính trên toàn bộ data.
4. Fill missing "session_duration" bằng mean của toàn bộ cột.
5. Random shuffle rồi split 80/20.
6. Train + đo trên test.

Tự trả lời rồi đối chiếu với mục 5 và 7 của bài.

• CRISP-DM là framework chuẩn 6 phase; bài này dùng 7 bước thực tế tương đương.
• ML không linear — luôn iterate giữa EDA, preprocessing và evaluate.
• Split train/test trước khi preprocessing. Fit transformer chỉ trên train.
• Train / Validation / Test có 3 vai trò khác nhau. Test dùng 1 lần.
• Pitfall hay gặp: data leakage, overfit, test bị "nhìn" nhiều lần, imbalanced data, wrong metric.
• Chọn metric phù hợp với bài toán: Regression dùng MSE/RMSE/R², Classification dùng Precision/Recall/F1/AUC, Clustering dùng Silhouette.
• Sklearn Pipeline giúp đóng gói preprocessing + model, tránh duplicate code và tránh leak.
• Model registry và MLOps lifecycle là chủ đề của Series 5 — biết trước để chuẩn bị tư duy.