📘 Scikit-learn 完整教程

Scikit-learn 是 Python 中最流行的机器学习库，提供了各种经典的机器学习算法和工具。本教程将从零开始，系统讲解 Scikit-learn 的核心概念、算法和实战应用。

🌳 Scikit-learn 知识体系

一、机器学习工作流程

掌握标准的机器学习项目流程是成功的关键。

🔄 完整工作流程图

📋 各阶段详细说明

二、Scikit-learn API 设计

理解 Scikit-learn 的统一 API 设计是高效使用的关键。

🔄 统一 API 序列图

📋 核心 API 方法

💻 API 使用示例

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 1. 准备数据
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# 2. 创建模型
model = RandomForestClassifier(n_estimators=100, random_state=42)

# 3. 训练模型 (fit)
model.fit(X_train, y_train)

# 4. 预测 (predict)
y_pred = model.predict(X_test)

# 5. 评估 (score)
accuracy = model.score(X_test, y_test)
print(f"准确率：{accuracy:.4f}")

# 6. 获取特征重要性
importances = model.feature_importances_

三、监督学习算法

监督学习使用标记数据训练模型，包括分类和回归两大任务。

🌳 监督学习算法分类

📋 分类算法详细对比

📋 回归算法详细对比

💻 分类算法对比示例

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, classification_report

# 加载数据
iris = load_iris()
X, y = iris.data, iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 定义多个分类器
classifiers = {
    '逻辑回归': LogisticRegression(max_iter=1000),
    '决策树': RandomForestClassifier(n_estimators=10, random_state=42),
    '随机森林': RandomForestClassifier(n_estimators=100, random_state=42),
    'SVM': SVC(kernel='rbf', probability=True),
    'KNN': KNeighborsClassifier(n_neighbors=5),
    '梯度提升': GradientBoostingClassifier(n_estimators=100, random_state=42)
}

# 训练和评估
results = {}
for name, clf in classifiers.items():
    clf.fit(X_train, y_train)
    y_pred = clf.predict(X_test)
    accuracy = accuracy_score(y_test, y_pred)
    results[name] = accuracy
    print(f"{name}: {accuracy:.4f}")

# 找出最佳模型
best_model = max(results, key=results.get)
print(f"\n最佳模型：{best_model} (准确率：{results[best_model]:.4f})")

四、无监督学习算法

无监督学习处理未标记数据，包括聚类和降维等任务。

🌳 无监督学习算法分类

📋 聚类算法详细对比

💻 聚类分析完整示例

from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans, DBSCAN, AgglomerativeClustering
from sklearn.metrics import silhouette_score
import matplotlib.pyplot as plt

# 生成聚类数据
X, y_true = make_blobs(n_samples=300, centers=4, cluster_std=0.60, random_state=0)

# 1. K-Means 聚类
kmeans = KMeans(n_clusters=4, random_state=42, n_init=10)
kmeans_labels = kmeans.fit_predict(X)
kmeans_score = silhouette_score(X, kmeans_labels)
print(f"K-Means 轮廓分数：{kmeans_score:.4f}")

# 2. DBSCAN 聚类
dbscan = DBSCAN(eps=0.3, min_samples=5)
dbscan_labels = dbscan.fit_predict(X)
# 去除噪声点计算轮廓分数
mask = dbscan_labels != -1
if mask.sum() > 1:
    dbscan_score = silhouette_score(X[mask], dbscan_labels[mask])
    print(f"DBSCAN 轮廓分数：{dbscan_score:.4f}")

# 3. 层次聚类
hierarchical = AgglomerativeClustering(n_clusters=4)
hierarchical_labels = hierarchical.fit_predict(X)
hierarchical_score = silhouette_score(X, hierarchical_labels)
print(f"层次聚类轮廓分数：{hierarchical_score:.4f}")

# 可视化比较
fig, axes = plt.subplots(1, 3, figsize=(15, 5))
axes[0].scatter(X[:, 0], X[:, 1], c=kmeans_labels, cmap='viridis')
axes[0].set_title(f'K-Means (score={kmeans_score:.3f})')
axes[1].scatter(X[:, 0], X[:, 1], c=dbscan_labels, cmap='viridis')
axes[1].set_title(f'DBSCAN')
axes[2].scatter(X[:, 0], X[:, 1], c=hierarchical_labels, cmap='viridis')
axes[2].set_title(f'层次聚类 (score={hierarchical_score:.3f})')
plt.tight_layout()
plt.show()

五、数据预处理

数据预处理是机器学习成功的关键步骤。

🔄 预处理流程图

📋 预处理方法对比

💻 完整预处理示例

from sklearn.preprocessing import StandardScaler, MinMaxScaler, OneHotEncoder, LabelEncoder
from sklearn.impute import SimpleImputer
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
import pandas as pd
import numpy as np

# 创建示例数据
data = pd.DataFrame({
    'age': [25, 30, np.nan, 45, 50],
    'salary': [50000, 60000, 75000, np.nan, 90000],
    'city': ['北京', '上海', '北京', '广州', '上海'],
    'department': ['技术', '销售', '技术', '技术', '销售'],
    'target': [1, 0, 1, 1, 0]
})

# 1. 分离特征和标签
X = data.drop('target', axis=1)
y = data['target']

# 2. 识别数值和类别特征
numeric_features = ['age', 'salary']
categorical_features = ['city', 'department']

# 3. 创建数值预处理管道
numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),  # 填充缺失值
    ('scaler', StandardScaler())  # 标准化
])

# 4. 创建类别预处理管道
categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
    ('onehot', OneHotEncoder(handle_unknown='ignore'))  # 独热编码
])

# 5. 创建预处理器
preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, numeric_features),
        ('cat', categorical_transformer, categorical_features)
    ]
)

# 6. 应用预处理
X_processed = preprocessor.fit_transform(X)

print(f"原始形状：{X.shape}")
print(f"处理后形状：{X_processed.shape}")
print(f"特征名：{preprocessor.get_feature_names_out()}")

六、模型选择与调优

选择合适的模型和参数是提升性能的关键。

🔄 交叉验证流程图

📋 交叉验证方法对比

💻 网格搜索与随机搜索

from sklearn.model_selection import GridSearchCV, RandomizedSearchCV, cross_val_score
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
import numpy as np

# 加载数据
iris = load_iris()
X, y = iris.data, iris.target

# 1. 交叉验证
rf = RandomForestClassifier(n_estimators=100, random_state=42)
cv_scores = cross_val_score(rf, X, y, cv=5, scoring='accuracy')
print(f"5 折交叉验证平均分：{cv_scores.mean():.4f} (+/- {cv_scores.std():.4f})")

# 2. 网格搜索（穷举）
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [None, 10, 20, 30],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4]
}

grid_search = GridSearchCV(
    RandomForestClassifier(random_state=42),
    param_grid,
    cv=5,
    scoring='accuracy',
    n_jobs=-1,
    verbose=1
)

grid_search.fit(X, y)

print(f"\n网格搜索最佳参数：{grid_search.best_params_}")
print(f"最佳交叉验证分数：{grid_search.best_score_:.4f}")

# 3. 随机搜索（更高效）
param_dist = {
    'n_estimators': np.random.randint(50, 300, 100),
    'max_depth': [None] + list(np.random.randint(10, 50, 50)),
    'min_samples_split': np.random.randint(2, 20, 50),
    'min_samples_leaf': np.random.randint(1, 10, 50)
}

random_search = RandomizedSearchCV(
    RandomForestClassifier(random_state=42),
    param_dist,
    n_iter=50,  # 随机搜索 50 次
    cv=5,
    scoring='accuracy',
    n_jobs=-1,
    random_state=42
)

random_search.fit(X, y)

print(f"\n随机搜索最佳参数：{random_search.best_params_}")
print(f"最佳交叉验证分数：{random_search.best_score_:.4f}")

七、实战案例

通过实际案例掌握 Scikit-learn 的完整应用。

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt

# 1. 加载数据
iris = load_iris()
X, y = iris.data, iris.target

# 2. 划分训练测试集
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# 3. 训练模型
clf = RandomForestClassifier(n_estimators=100, random_state=42)
clf.fit(X_train, y_train)

# 4. 评估
y_pred = clf.predict(X_test)
print(classification_report(y_test, y_pred, target_names=iris.target_names))

# 5. 可视化
cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.xlabel('预测')
plt.ylabel('真实')
plt.title('混淆矩阵')
plt.show()

from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.metrics import mean_squared_error, r2_score
import numpy as np

# 1. 加载数据
housing = fetch_california_housing()
X, y = housing.data, housing.target

# 2. 划分数据
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 3. 训练模型
reg = GradientBoostingRegressor(
    n_estimators=100,
    learning_rate=0.1,
    max_depth=3,
    random_state=42
)
reg.fit(X_train, y_train)

# 4. 评估
y_pred = reg.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_test, y_pred)

print(f"RMSE: ${rmse*100000:.2f}")
print(f"R²: {r2:.4f}")

# 5. 特征重要性
importances = reg.feature_importances_
for name, importance in zip(housing.feature_names, importances):
    print(f"{name}: {importance:.4f}")