scikit-learn

scikit-learn - Python 机器学习

一个功能强大的传统机器学习库。它提供统一的 API：所有对象都使用相同的接口进行拟合、转换和预测。

适用场景

• 分类：检测类别（垃圾邮件与正常邮件、疾病诊断）。
• 回归：预测连续值（房价、股票趋势）。
• 聚类：将相似对象分组（市场细分、图像压缩）。
• 降维：在保留信息的同时减少特征数量（PCA、可视化）。
• 模型选择：比较模型并调整超参数（交叉验证、网格搜索）。
• 预处理：将原始数据转换为特征（缩放、编码、填补）。

参考文档

官方文档：https://scikit-learn.org/stable/
用户指南：https://scikit-learn.org/stable/user_guide.html
搜索模式：sklearn.pipeline.Pipeline、sklearn.model_selection、sklearn.ensemble、sklearn.preprocessing

核心原则

“估计器”接口

• 估计器：实现 fit(X, y)。它们从数据中学习。
• 转换器：实现 transform(X)（以及 fit_transform(X)）。它们会修改数据。
• 预测器：实现 predict(X)。它们会对新数据进行估计。

适合使用 scikit-learn 的场景

• 表格数据（类似 Excel 的数据、CSV 文件）。
• 传统机器学习（随机森林、SVM、线性模型）。
• 特征工程和工作流自动化。
• 中小型数据集。

不适合使用的场景

• 深度学习 / 神经网络（使用 PyTorch 或 TensorFlow）。
• 大规模自然语言处理（使用 spaCy 或 HuggingFace）。
• 大规模“大数据”（使用 Spark MLlib 或 Dask-ML）。
• 实时流式预测（考虑使用专用推理引擎）。

快速参考

安装

pip install scikit-learn

标准导入

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.metrics import classification_report, mean_squared_error

基本模式 - 训练/预测

from sklearn.ensemble import RandomForestClassifier

# 1. Prepare data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# 2. Instantiate and fit
model = RandomForestClassifier(n_estimators=100)
model.fit(X_train, y_train)

# 3. Predict and evaluate
predictions = model.predict(X_test)
print(classification_report(y_test, predictions))

关键规则

✅ 应做事项

• 先划分数据 - 查看数据属性前，始终先使用 train_test_split。
• 使用 Pipelines - 将预处理和建模组合起来，以防止数据泄漏。
• 缩放数据 - SVM、KNN 和线性回归等模型需要进行特征缩放。
• 检查类别不平衡 - 分类时，在 train_test_split 中使用 stratify=y。
• 进行交叉验证 - 不要只依赖一次训练/测试集划分；使用 cross_val_score。
• 处理缺失值 - 拟合模型前，使用 SimpleImputer 或类似工具。
• 统一类别编码 - 名义数据使用 OneHotEncoder，有序数据使用 OrdinalEncoder。

❌ 不应做事项

• 在测试数据上拟合 - 绝不要在测试集上调用 .fit() 或 .fit_transform()。
• 直接使用类别数据 - Scikit-learn 要求输入为数值；先对字符串进行编码。
• 忽略类别不平衡 - 对于不平衡数据集，准确率容易产生误导；应使用 F1 分数或 AUC。
• 过拟合 - 不要不断调整超参数，直到测试分数达到完美。
• 忽略随机状态 - 实验时设置 random_state，以确保结果可复现。

反模式（绝对不要这样做）

# ❌ BAD: Data Leakage (Fitting scaler on the whole dataset)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X) # Data from "future" test set leaks into training!
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y)

# ✅ GOOD: Fit scaler only on training data
X_train, X_test, y_train, y_test = train_test_split(X, y)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test) # Use training mean/std

# ❌ BAD: Repeating preprocessing manually
# (Error-prone and hard to maintain)

# ✅ GOOD: Use Pipelines (Automates everything safely)
pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('model', RandomForestClassifier())
])
pipe.fit(X_train, y_train)

预处理（sklearn.preprocessing）

缩放与编码

from sklearn.preprocessing import StandardScaler, MinMaxScaler, OneHotEncoder

# Scaling numerical data
scaler = StandardScaler()
X_num_scaled = scaler.fit_transform(X_numeric)

# Encoding categorical data
encoder = OneHotEncoder(sparse_output=False, handle_unknown='ignore')
X_cat_encoded = encoder.fit_transform(X_categorical)

# Handling missing values
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(strategy='median')
X_imputed = imputer.fit_transform(X_with_nan)

列转换器（专业做法）

from sklearn.compose import ColumnTransformer

numeric_features = ['age', 'salary']
categorical_features = ['city', 'job_type']

preprocessor = ColumnTransformer(
    transformers=[
        ('num', StandardScaler(), numeric_features),
        ('cat', OneHotEncoder(), categorical_features)
    ])

# Now use this in a pipeline
pipeline = Pipeline([
    ('prep', preprocessor),
    ('clf', LogisticRegression())
])

分类

常见算法

from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.ensemble import GradientBoostingClassifier

# Logistic Regression (Baseline)
log_reg = LogisticRegression(max_iter=1000)

# Support Vector Machine
svm = SVC(kernel='rbf', probability=True)

# Gradient Boosting
gb = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1)

回归

常见算法

from sklearn.linear_model import Ridge, Lasso, ElasticNet
from sklearn.ensemble import RandomForestRegressor

# Regularized Linear Models
ridge = Ridge(alpha=1.0) # L2
lasso = Lasso(alpha=0.1) # L1

# Non-linear Regression
rf_reg = RandomForestRegressor(n_estimators=100, max_depth=10)

模型评估

指标

from sklearn.metrics import accuracy_score, f1_score, roc_auc_score, r2_score, mean_absolute_error

# Classification
acc = accuracy_score(y_true, y_pred)
f1 = f1_score(y_true, y_pred, average='weighted')

# Regression
r2 = r2_score(y_true, y_pred)
mae = mean_absolute_error(y_true, y_pred)

交叉验证

from sklearn.model_selection import cross_val_score

scores = cross_val_score(pipeline, X, y, cv=5, scoring='f1_macro')
print(f"Mean F1: {scores.mean():.4f} (+/- {scores.std():.4f})")

超参数调优

网格搜索与随机搜索

from sklearn.model_selection import GridSearchCV

param_grid = {
    'clf__n_estimators': [50, 100, 200],
    'clf__max_depth': [None, 10, 20],
    'clf__min_samples_split': [2, 5]
}

grid_search = GridSearchCV(pipeline, param_grid, cv=3, scoring='accuracy', n_jobs=-1)
grid_search.fit(X_train, y_train)

print(f"Best params: {grid_search.best_params_}")
best_model = grid_search.best_estimator_

降维

PCA（主成分分析）

from sklearn.decomposition import PCA

# Reduce to 2 components for visualization
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)

print(f"Explained variance ratio: {pca.explained_variance_ratio_}")

聚类

K-Means 和 DBSCAN

from sklearn.cluster import KMeans, DBSCAN

# K-Means (Requires specifying K)
kmeans = KMeans(n_clusters=3, n_init='auto')
clusters = kmeans.fit_predict(X)

# DBSCAN (Density-based, finds K automatically)
dbscan = DBSCAN(eps=0.5, min_samples=5)
clusters = dbscan.fit_predict(X)

实用工作流

1. 端到端分类流水线

def build_and_train_model(X, y):
    # 1. Identify types
    num_cols = X.select_dtypes(include=['int64', 'float64']).columns
    cat_cols = X.select_dtypes(include=['object', 'category']).columns

    # 2. Setup Preprocessing
    preprocessor = ColumnTransformer([
        ('num', StandardScaler(), num_cols),
        ('cat', OneHotEncoder(handle_unknown='ignore'), cat_cols)
    ])

    # 3. Create Pipeline
    clf = Pipeline([
        ('preprocessor', preprocessor),
        ('classifier', RandomForestClassifier(random_state=42))
    ])

    # 4. Train
    X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y)
    clf.fit(X_train, y_train)
    
    return clf, X_test, y_test

# model, X_test, y_test = build_and_train_model(df.drop('target', axis=1), df['target'])

2. 自定义特征工程（转换器）

from sklearn.base import BaseEstimator, TransformerMixin

class LogTransformer(BaseEstimator, TransformerMixin):
    def __init__(self, columns=None):
        self.columns = columns
    
    def fit(self, X, y=None):
        return self
    
    def transform(self, X):
        X_copy = X.copy()
        for col in self.columns:
            X_copy[col] = np.log1p(X_copy[col])
        return X_copy

性能优化

使用 n_jobs

# Use all CPU cores for training/tuning
model = RandomForestClassifier(n_jobs=-1)
grid = GridSearchCV(model, param_grid, n_jobs=-1)

处理大型数据（partial_fit）

from sklearn.linear_model import SGDClassifier

# Online learning (incremental fit)
model = SGDClassifier()
for X_chunk, y_chunk in data_stream:
    model.partial_fit(X_chunk, y_chunk, classes=np.unique(y_all))

常见问题与解决方案

类别不平衡

# ❌ Problem: Model predicts only the majority class
# ✅ Solution: Adjust class weights
model = RandomForestClassifier(class_weight='balanced')
# OR use SMOTE from imbalanced-learn library

收敛警告

# ❌ Problem: "ConvergenceWarning: Liblinear failed to converge"
# ✅ Solution: Increase max_iter or scale data
model = LogisticRegression(max_iter=2000)
# Often solved by applying StandardScaler first!

测试集中的类别值不在训练集中

# ❌ Problem: ValueError when unseen categories appear in test
# ✅ Solution: Use handle_unknown in OneHotEncoder
encoder = OneHotEncoder(handle_unknown='ignore')

Scikit-learn 是 Python 机器学习的基石。它的 API 非常成功，以至于许多其他库（XGBoost、LightGBM）都模仿它。