Cheat sheet scikit-learn (sklearn)
Cập nhật lần cuối
Nạp và chia dữ liệu
Tách riêng một tập kiểm tra trước mọi bước khác, và chỉ nhìn vào nó ở bước cuối cùng.
| Việc cần làm | Code |
|---|---|
| Import hàm chia dữ liệu | from sklearn.model_selection import train_test_split |
| Đặc trưng và biến mục tiêu từ DataFrame | X = df.drop(columns="target")
y = df["target"] |
| Bộ dữ liệu có sẵn dưới dạng pandas | from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True, as_frame=True) |
| Dữ liệu tổng hợp để thử nghiệm | from sklearn.datasets import make_classification
X, y = make_classification(n_samples=500, n_features=8, random_state=0) |
| Chia tập huấn luyện và kiểm tra theo tỷ lệ 80/20 | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) |
| Giữ tỷ lệ các lớp ở cả hai phần | train_test_split(X, y, test_size=0.2, stratify=y, random_state=42) |
| Huấn luyện, validation và kiểm tra (60/20/20) | X_tmp, X_test, y_tmp, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
X_train, X_val, y_train, y_val = train_test_split(X_tmp, y_tmp, test_size=0.25, random_state=0) |
Tiền xử lý đặc trưng
Chỉ fit transformer trên dữ liệu huấn luyện, sau đó transform cả hai tập. Fit trên dữ liệu kiểm tra sẽ làm rò rỉ thông tin.
| Việc cần làm | Code |
|---|---|
| Import | from sklearn.preprocessing import StandardScaler, MinMaxScaler, OneHotEncoder, OrdinalEncoder |
| Chuẩn hóa về trung bình 0 và độ lệch chuẩn 1 | scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train[["age", "income"]])
X_test_s = scaler.transform(X_test[["age", "income"]]) |
| Co giãn về khoảng từ 0 đến 1 | MinMaxScaler().fit_transform(X_train[["age", "income"]]) |
| Mã hóa one-hot cho biến phân loại | enc = OneHotEncoder(handle_unknown="ignore", sparse_output=False)
enc.fit_transform(X_train[["city"]]) |
| Mã hóa các nhóm có thứ tự thành số | OrdinalEncoder(categories=[["low", "mid", "high"]]).fit_transform([["mid"], ["high"]]) |
| Điền giá trị thiếu | from sklearn.impute import SimpleImputer
SimpleImputer(strategy="median").fit_transform(X_train[["age", "income"]]) |
| Đặc trưng đa thức và đặc trưng tương tác | from sklearn.preprocessing import PolynomialFeatures
PolynomialFeatures(degree=2, include_bias=False).fit_transform(X_train[["age", "income"]]) |
| Nhận lại DataFrame thay vì mảng | scaler.set_output(transform="pandas") |
| Nhãn dạng chữ thành số nguyên | from sklearn.preprocessing import LabelEncoder
LabelEncoder().fit_transform(["cat", "dog", "cat"]) |
Chọn mô hình
Bắt đầu từ mô hình đơn giản và giữ điểm số của nó làm mốc để vượt qua.
| Bài toán | Bắt đầu với | Sau đó thử |
|---|---|---|
| Dự đoán một con số (hồi quy) | LinearRegression(), Ridge(alpha=1.0) | RandomForestRegressor(), HistGradientBoostingRegressor() |
| Dự đoán một lớp (phân loại) | LogisticRegression(max_iter=1000) | RandomForestClassifier(), HistGradientBoostingClassifier() |
| Dữ liệu nhỏ, các điểm gần nhau có cùng nhãn | KNeighborsClassifier(n_neighbors=5) | SVC(kernel="rbf") |
| Quy tắc đọc hiểu được | DecisionTreeClassifier(max_depth=3) | RandomForestClassifier() |
| Gom nhóm các hàng không có nhãn | KMeans(n_clusters=3) | DBSCAN(eps=0.5) |
| Giảm số đặc trưng để vẽ biểu đồ hoặc tăng tốc | PCA(n_components=2) | TSNE(n_components=2) |
| Tìm các hàng bất thường | IsolationForest(random_state=0) | LocalOutlierFactor() |
Fit một mô hình
Mọi estimator đều theo cùng một mẫu: tạo nó với các thiết lập, rồi gọi fit.
| Việc cần làm | Code |
|---|---|
| Mẫu chung cho mọi mô hình | model = LogisticRegression(max_iter=1000)
model.fit(X_train, y_train) |
| Hồi quy tuyến tính | from sklearn.linear_model import LinearRegression
LinearRegression() |
| Hồi quy tuyến tính có chính quy hóa | from sklearn.linear_model import Ridge, Lasso
Ridge(alpha=1.0), Lasso(alpha=0.1) |
| Hồi quy logistic (phân loại) | from sklearn.linear_model import LogisticRegression
LogisticRegression(C=1.0, max_iter=1000) |
| k láng giềng gần nhất | from sklearn.neighbors import KNeighborsClassifier
KNeighborsClassifier(n_neighbors=5) |
| Cây quyết định | from sklearn.tree import DecisionTreeClassifier
DecisionTreeClassifier(max_depth=3, random_state=0) |
| Rừng ngẫu nhiên (random forest) | from sklearn.ensemble import RandomForestClassifier
RandomForestClassifier(n_estimators=200, random_state=0) |
| Gradient boosting, nhanh trên dữ liệu lớn | from sklearn.ensemble import HistGradientBoostingClassifier
HistGradientBoostingClassifier(random_state=0) |
| Support vector machine | from sklearn.svm import SVC
SVC(kernel="rbf", C=1.0) |
| Naive Bayes | from sklearn.naive_bayes import GaussianNB
GaussianNB() |
| Mô hình mốc luôn đoán lớp chiếm đa số | from sklearn.dummy import DummyClassifier
DummyClassifier(strategy="most_frequent") |
Dự đoán và kiểm tra mô hình
| Việc cần làm | Code |
|---|---|
| Dự đoán lớp hoặc giá trị | y_pred = model.predict(X_test) |
| Xác suất của lớp dương | model.predict_proba(X_test)[:, 1] |
| Điểm nhanh: accuracy hoặc R² | model.score(X_test, y_test) |
| Hệ số của mô hình tuyến tính | model.coef_, model.intercept_ |
| Độ quan trọng đặc trưng của mô hình cây | pd.Series(forest.feature_importances_, index=X_train.columns).sort_values() |
| Độ quan trọng bằng cách xáo trộn từng đặc trưng | from sklearn.inspection import permutation_importance
permutation_importance(model, X_test, y_test, random_state=0).importances_mean |
| Các nhãn lớp mà mô hình biết | model.classes_ |
| Đọc và thay đổi thiết lập | model.get_params(), model.set_params(C=0.5) |
| Vẽ cây quyết định | from sklearn.tree import plot_tree
plot_tree(tree, filled=True, feature_names=list(X_train.columns)) |
Metric cho bài toán phân loại
Chỉ nhìn accuracy sẽ che mất các lỗi trên lớp hiếm. Hãy xem cả precision, recall và ma trận nhầm lẫn.
| Việc cần làm | Code |
|---|---|
| Import | from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score |
| Accuracy | accuracy_score(y_test, y_pred) |
| Precision, recall và F1 | precision_score(y_test, y_pred), recall_score(y_test, y_pred), f1_score(y_test, y_pred) |
| F1 cho nhiều lớp | f1_score(y_test, y_pred, average="macro") |
| Mọi metric theo từng lớp | from sklearn.metrics import classification_report
print(classification_report(y_test, y_pred)) |
| Ma trận nhầm lẫn | from sklearn.metrics import confusion_matrix
confusion_matrix(y_test, y_pred) |
| Vẽ ma trận nhầm lẫn | from sklearn.metrics import ConfusionMatrixDisplay
ConfusionMatrixDisplay.from_estimator(model, X_test, y_test) |
| ROC AUC từ xác suất | from sklearn.metrics import roc_auc_score
roc_auc_score(y_test, model.predict_proba(X_test)[:, 1]) |
| Vẽ đường cong ROC | from sklearn.metrics import RocCurveDisplay
RocCurveDisplay.from_estimator(model, X_test, y_test) |
| Accuracy cho các lớp mất cân bằng | from sklearn.metrics import balanced_accuracy_score
balanced_accuracy_score(y_test, y_pred) |
| Ngưỡng quyết định của riêng bạn | y_pred = (model.predict_proba(X_test)[:, 1] >= 0.3).astype(int) |
Metric cho bài toán hồi quy
Các metric sai số có cùng đơn vị với biến mục tiêu (càng thấp càng tốt). R² là tỷ lệ phương sai được giải thích (1 là hoàn hảo).
| Việc cần làm | Code |
|---|---|
| Import | from sklearn.metrics import mean_absolute_error, mean_squared_error, root_mean_squared_error, r2_score |
| Sai số tuyệt đối trung bình | mean_absolute_error(y_test, y_pred) |
| Sai số bình phương trung bình và căn bậc hai của nó | mean_squared_error(y_test, y_pred), root_mean_squared_error(y_test, y_pred) |
| Điểm R² | r2_score(y_test, y_pred) |
| Sai số phần trăm tuyệt đối trung bình | from sklearn.metrics import mean_absolute_percentage_error
mean_absolute_percentage_error(y_test, y_pred) |
| Vẽ giá trị dự đoán so với giá trị thực | from sklearn.metrics import PredictionErrorDisplay
PredictionErrorDisplay.from_predictions(y_test, y_pred, kind="actual_vs_predicted") |
Pipeline
Pipeline nối bước tiền xử lý và mô hình thành một estimator duy nhất, nhờ đó cross-validation và grid search chỉ fit từng bước trên các fold huấn luyện.
| Việc cần làm | Code |
|---|---|
| Import | from sklearn.pipeline import make_pipeline, Pipeline |
| Chuẩn hóa rồi fit mô hình | pipe = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000))
pipe.fit(X_train, y_train) |
| Các bước với tên do bạn đặt | pipe = Pipeline([("scale", StandardScaler()), ("model", LogisticRegression(max_iter=1000))]) |
| Truy cập một bước bên trong | pipe.named_steps["model"], pipe[-1] |
| Các bước khác nhau cho các cột khác nhau | from sklearn.compose import ColumnTransformer
pre = ColumnTransformer([
("num", StandardScaler(), ["age", "income"]),
("cat", OneHotEncoder(handle_unknown="ignore"), ["city"]),
]) |
| Tiền xử lý và mô hình trong một đối tượng | model = make_pipeline(pre, RandomForestClassifier(random_state=0))
model.fit(X_train, y_train)
model.score(X_test, y_test) |
| Chọn cột theo kiểu dữ liệu | from sklearn.compose import make_column_selector
make_column_selector(dtype_include="number")(X_train) |
| Điền giá trị thiếu rồi chuẩn hóa | make_pipeline(SimpleImputer(strategy="median"), StandardScaler()) |
| Tên của các đặc trưng đầu ra | pre.get_feature_names_out() |
Cross-validation (kiểm định chéo)
Cross-validation huấn luyện và chấm điểm mô hình trên nhiều cách chia dữ liệu, cho ước lượng ổn định hơn so với một tập kiểm tra duy nhất.
| Việc cần làm | Code |
|---|---|
| Import | from sklearn.model_selection import cross_val_score, cross_validate, KFold, StratifiedKFold |
| Chấm điểm trên 5 fold | scores = cross_val_score(pipe, X, y, cv=5)
scores.mean(), scores.std() |
| Chọn metric | cross_val_score(pipe, X, y, cv=5, scoring="f1_macro") |
| Fold được xáo trộn | cv = KFold(n_splits=5, shuffle=True, random_state=0) |
| Cân bằng lớp như nhau ở mỗi fold | cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=0) |
| Nhiều metric và điểm trên tập huấn luyện | cross_validate(pipe, X, y, cv=cv, scoring=["accuracy", "f1"], return_train_score=True) |
| Dự đoán cho mọi hàng, tạo ra ngoài fold | from sklearn.model_selection import cross_val_predict
cross_val_predict(pipe, X, y, cv=5) |
| Fold theo nhóm, fold theo thứ tự thời gian | from sklearn.model_selection import GroupKFold, TimeSeriesSplit
GroupKFold(n_splits=5), TimeSeriesSplit(n_splits=5) |
| Mọi tên scoring hợp lệ | from sklearn.metrics import get_scorer_names
get_scorer_names() |
Grid search và tinh chỉnh
Quá trình tìm kiếm fit mô hình với từng thiết lập bằng cross-validation, giữ lại thiết lập tốt nhất và fit lại trên toàn bộ dữ liệu huấn luyện.
| Việc cần làm | Code |
|---|---|
| Import | from sklearn.model_selection import GridSearchCV, RandomizedSearchCV |
| Thử mọi tổ hợp | grid = GridSearchCV(RandomForestClassifier(random_state=0), {"n_estimators": [50, 100], "max_depth": [None, 5]}, cv=5)
grid.fit(X_train, y_train) |
| Thiết lập tốt nhất và điểm số của nó | grid.best_params_, grid.best_score_ |
| Dùng mô hình tốt nhất | grid.best_estimator_.predict(X_test), grid.score(X_test, y_test) |
| Tinh chỉnh một bước bên trong pipeline | GridSearchCV(pipe, {"logisticregression__C": [0.1, 1, 10]}, cv=5).fit(X_train, y_train) |
| Thiết lập ngẫu nhiên từ các phân phối | from scipy.stats import randint
search = RandomizedSearchCV(RandomForestClassifier(random_state=0), {"n_estimators": randint(50, 150)}, n_iter=5, cv=3, random_state=0)
search.fit(X_train, y_train) |
| Dùng mọi lõi CPU | GridSearchCV(pipe, {"logisticregression__C": [0.1, 1]}, cv=5, n_jobs=-1) |
| Toàn bộ kết quả dưới dạng bảng | pd.DataFrame(grid.cv_results_).sort_values("rank_test_score") |
Phân cụm và giảm chiều dữ liệu
Mô hình không giám sát chỉ học từ X. Hãy chuẩn hóa đặc trưng trước, vì cả hai đều dùng khoảng cách.
| Việc cần làm | Code |
|---|---|
| Phân cụm k-means | from sklearn.cluster import KMeans
km = KMeans(n_clusters=3, random_state=0)
labels = km.fit_predict(X) |
| Tâm cụm và inertia | km.cluster_centers_, km.inertia_ |
| Mức độ tách biệt giữa các cụm | from sklearn.metrics import silhouette_score
silhouette_score(X, labels) |
| Phân cụm theo mật độ, nhiễu được gán -1 | from sklearn.cluster import DBSCAN
DBSCAN(eps=0.5, min_samples=5).fit_predict(X) |
| Chiếu xuống 2 thành phần | from sklearn.decomposition import PCA
pca = PCA(n_components=2)
X_2d = pca.fit_transform(X) |
| Phương sai mà mỗi thành phần giải thích | pca.explained_variance_ratio_ |
| Giữ lại 95% phương sai | PCA(n_components=0.95).fit_transform(X) |
scikit-learn 1.9: cách viết cũ và cách viết hiện nay
Code chép từ các hướng dẫn cũ có thể lỗi hoặc cảnh báo trong scikit-learn 1.9. Hãy viết theo cột scikit-learn 1.9.
| Việc cần làm | scikit-learn 1.9 | Cách viết cũ |
|---|---|---|
| Căn sai số bình phương trung bình | root_mean_squared_error(y_test, y_pred) | mean_squared_error(y_test, y_pred, squared=False) |
| Đầu ra one-hot dạng dense | OneHotEncoder(sparse_output=False) | OneHotEncoder(sparse=False) |
| Hồi quy logistic L1 (lasso) | LogisticRegression(l1_ratio=1, solver="liblinear") | LogisticRegression(penalty="l1", solver="liblinear") |
| Hồi quy logistic không chính quy hóa | LogisticRegression(C=np.inf) | LogisticRegression(penalty=None) |
Lưu, nạp và tái tạo kết quả
| Việc cần làm | Code |
|---|---|
| Lưu một mô hình hoặc pipeline đã fit | import joblib
joblib.dump(model, "model.joblib") |
| Nạp lại | model = joblib.load("model.joblib") |
| Cùng một kết quả ở mọi lần chạy | random_state=0 |
| Phiên bản đang được cài | import sklearn
sklearn.__version__ |
Code scikit-learn của một quy trình machine learning thực tế, theo đúng thứ tự bạn viết: nạp và chia dữ liệu, tiền xử lý, chọn mô hình, fit và predict, đo kết quả, nối các bước thành một pipeline, rồi cross-validation và tinh chỉnh bằng grid search. Mỗi hàng là một đoạn code ngắn để dán vào, kèm một dòng giải thích tác dụng.
Mọi mô hình trong scikit-learn dùng chung một API: fit học từ dữ liệu huấn luyện, predict và transform áp dụng những gì đã học. Mọi thứ ở đây được viết cho scikit-learn 1.9, phiên bản Coddy đang chạy, với X là các đặc trưng (feature) và y là biến mục tiêu. scikit-learn làm việc với mảng NumPy và DataFrame pandas, còn cheat sheet Matplotlib lo phần biểu đồ. Mới làm quen với Python? Hãy bắt đầu với cheat sheet Python.
Câu hỏi thường gặp về cheat sheet scikit-learn
Cheat sheet scikit-learn này có miễn phí không?
Có. Cheat sheet scikit-learn này hoàn toàn miễn phí, không cần đăng ký. Lưu trang lại, hoặc in ra PDF từ trình duyệt, và quay lại bất cứ khi nào bạn cần đúng lệnh gọi cho một pipeline, một metric hay một lần grid search.
sklearn có phải là scikit-learn không?
Đúng vậy. scikit-learn là tên của thư viện và của package bạn cài (
pip install scikit-learn), còn sklearn là tên bạn import trong code (from sklearn.linear_model import LinearRegression). Cheat sheet sklearn và cheat sheet scikit-learn nói về cùng một thứ.fit, transform và fit_transform khác nhau thế nào?
fit học từ dữ liệu: scaler học giá trị trung bình của từng cột, mô hình học các trọng số. transform áp dụng những gì đã học, còn fit_transform làm cả hai trong một lần gọi. Dùng fit_transform trên tập huấn luyện và chỉ dùng transform trên tập kiểm tra, nếu không dữ liệu kiểm tra sẽ rò rỉ vào quá trình huấn luyện. Pipeline tự lo việc này cho bạn.Có cần chuẩn hóa đặc trưng không?
Với các mô hình dùng khoảng cách hoặc gradient thì có: k láng giềng gần nhất, SVM, k-means, PCA, hồi quy tuyến tính và hồi quy logistic có chính quy hóa đều hoạt động tốt hơn trên dữ liệu đã chuẩn hóa. Các mô hình cây như cây quyết định, random forest và gradient boosting không cần chuẩn hóa. Hãy đặt scaler trong một pipeline để nó chỉ được fit trên dữ liệu huấn luyện.
Nên bắt đầu với mô hình scikit-learn nào?
Bắt đầu với một mô hình đơn giản, nhanh làm mốc:
LinearRegression để dự đoán con số, LogisticRegression để dự đoán lớp. Sau đó thử RandomForestClassifier hoặc HistGradientBoostingClassifier (hoặc phiên bản regressor của chúng), so sánh bằng cross-validation, rồi tinh chỉnh mô hình tốt nhất bằng GridSearchCV.Cheat sheet này dành cho phiên bản scikit-learn nào?
scikit-learn 1.9, phiên bản Coddy đang chạy, trên NumPy 2 và pandas 3. Các lệnh gọi cũ nay bị lỗi hoặc cảnh báo, như
squared=False trong mean_squared_error, sparse=False trong OneHotEncoder và đối số penalty của LogisticRegression, nằm trong bảng cách viết cũ, bên cạnh cách viết nên dùng thay thế.Có thể chạy code scikit-learn online không?
Có. Playground Matplotlib miễn phí chạy Python cùng scikit-learn, pandas, NumPy và Matplotlib ngay trên trình duyệt, nên bạn có thể dán bất kỳ đoạn code nào trong cheat sheet này và chạy mà không cần cài gì. Khóa học Machine Learning của Coddy dạy từng bước toàn bộ quy trình trên trang này, từ chia dữ liệu đến tinh chỉnh mô hình.
Tài nguyên liên quan
Thêm cheat sheet
