scikit-learn 入门教程

Sklearn 入门教程：从思维到落地的完整指南

引言

Sklearn（Scikit-learn）堪称Python机器学习领域的“瑞士军刀”——不仅API设计简洁统一、工具链覆盖全场景，更核心的是其蕴含的机器学习通用思维，能无缝迁移到TensorFlow、PyTorch等框架，适配分类、回归、聚类等各类任务。

本教程不追求API的全面覆盖（无需死记硬背），而是聚焦6个终身受用的核心思维，通过“理论+实操”的方式，带大家掌握“数据→模型→落地”的完整流程，既能轻松应对课程作业，也能无缝适配实际项目开发。

学习目标

• 掌握“加载→预处理→拆分→建模→评估→优化→部署”的闭环工作流；
• 深刻理解数据拆分、超参迭代、泛化验证等核心原则，避开常见陷阱；
• 学会“任务类型→模型选择→超参优化”的精准匹配逻辑；
• 具备模型工程化落地能力（管道构建、模型保存与部署）。

环境准备

%pip install scikit-learn pandas numpy matplotlib
# 建议不加叹号而是加%，或用!python -m pip，从而避免安装路径错误

第一章：Sklearn 核心思维（内功心法）

在编写代码前，先吃透这6个核心思维——它们是Sklearn的“灵魂”，更是机器学习的通用逻辑，无论面对何种任务都能举一反三。

6个终身受用的核心思维

1. 流程化闭环思维：任何机器学习任务都遵循“数据→处理→建模→评估→优化→落地”的闭环流程，如同“买菜→洗菜→炒菜→尝味→调味→打包”，步骤不可逆、不可跳跃，确保每一步都为最终效果服务；
2. 数据不泄露原则：先拆分训练集、验证集、测试集，再对训练集做预处理，验证集和测试集仅复用训练集的预处理参数，坚决避免“考试前看答案”式的信息泄露；
3. 任务-模型适配思维：先明确任务类型（分类/回归/聚类），再根据数据特性选择合适模型，不盲目尝试API，让模型选择有章可循；
4. 超参迭代思维：模型效果没有“一次性成功”，需通过“预设超参→训练→评估→优化超参”的循环逐步提升，如同做菜反复调味直至口感最佳；
5. 多维评估思维：不唯单一指标论成败，兼顾性能指标（准确率/R²）、模型可解释性（特征重要性）、泛化能力（交叉验证），全面判断模型优劣；
6. 工程化复用思维：用Pipeline（管道）串联完整流程，用工具保存训练好的模型，让“最优做法”可复用、可部署，实现从“学生作业”到“工业级项目”的跨越。

1. 思维1：流程化闭环（所有任务的通用框架）

flowchart TD A[1.数据加载] --> B[2.数据预处理] B --> C[3.数据拆分] C --> D[4.超参预设+模型实例化] D --> E[5.模型训练] E --> F[6.模型预测] F --> G[7.效果评估] G --> H{效果达标?} H -- 是 --> I[8.最终评估] I --> J[9.模型固化] J --> K[10.模型部署] K --> L[11.新数据反馈] L --> M[12.模型优化] M --> D H -- 否 --> M

2. 思维2：数据预处理的“不泄露原则”（避坑关键）

核心原则：先拆分训练集与测试集，再对训练集执行“fit（学习参数）+ transform（应用参数）”，测试集仅执行“transform（复用训练集参数）”。

❌ 错误做法：先用全量数据做预处理（如计算均值/标准差），再拆分数据——导致测试集信息提前泄露，评估结果虚高，如同考试前偷看答案。

✅ 正确逻辑：

• 训练集：fit（学习预处理参数）→ transform（应用参数）；
• 验证集/测试集：直接transform（复用训练集参数）。

3. 思维3：任务→模型的适配逻辑（不盲目试模型）

选择模型的核心是“任务类型+数据特性”的精准匹配，Sklearn已按任务分类整理好模型模块，直接对照选择即可：

任务类型	数据特性	Sklearn推荐模型	典型场景
监督学习-分类	线性可分/低维数据	逻辑回归（LogisticRegression）、SVM	垃圾邮件识别
监督学习-分类	非线性/高维数据（图像/文本）	随机森林（RandomForestClassifier）	手写数字识别
监督学习-回归	特征与标签线性关联	线性回归（LinearRegression）	简单房价预测
监督学习-回归	特征与标签非线性关联	随机森林回归（RandomForestRegressor）	糖尿病病情预测
无监督学习-聚类	数据有明确簇划分	K-Means、DBSCAN	鸢尾花聚类、用户分群

4. 思维4-6补充说明

• 超参迭代思维：超参是模型的“先天配置”（如随机森林的树数量），无法通过数据学习得到，需结合任务特性预设初始值，再根据评估结果迭代调整；
• 多维评估思维：分类任务不能只看准确率（样本不平衡时易误判），需兼顾精确率、召回率、F1值；回归任务需结合MSE、MAE、R²综合判断；
• 工程化复用思维：Pipeline能将预处理、建模等步骤串联成标准化流程，避免代码冗余和人为失误；joblib可保存完整模型，后续无需重新训练，直接加载使用。

第二章：完整流程实操（以糖尿病预测为例）

以Sklearn自带的“糖尿病病情进展预测”（回归任务）为例，按细化步骤实操，每个环节都配套“代码+逻辑+类比”，让抽象流程具象化。

步骤1：数据加载（买菜）

逻辑：获取原始数据，整理为“特征（X）+标签（y）”的标准格式，明确数据基本信息。
类比：去菜市场买菜，先确认要买的食材种类（特征）和要做的菜品（标签）。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_diabetes

# 加载Sklearn自带数据集（无需额外下载，相当于“预制食材包”）
data = load_diabetes()
X = data.data  # 特征：10个（年龄、血压、血糖等生理指标）
y = data.target  # 标签：连续值（病情进展程度，范围25~346）
feature_names = data.feature_names  # 特征名（用于后续结果解释）

# 打印数据基本信息，确认“食材”情况
print(f"数据形状：特征{X.shape}（样本数×特征数），标签{y.shape}（样本数）")
print(f"特征列表：{feature_names}")

输出结果：

数据形状：特征(442, 10)，标签(442,)
特征列表：['age', 'sex', 'bmi', 'bp', 's1', 's2', 's3', 's4', 's5', 's6']

步骤2：数据拆分（分食材）

逻辑：将数据拆分为训练集（学习规律）、验证集（调整参数）、测试集（最终验收），比例通常为6:2:2，确保数据不泄露。
类比：把买好的食材分成三份，训练集用于学习做菜方法，验证集用于试味调整，测试集用于最终验收菜品质量。

from sklearn.model_selection import train_test_split

# 第一步：先拆分训练集 + （验证集+测试集）（比例6:4）
X_train, X_temp, y_train, y_temp = train_test_split(
    X, y, test_size=0.4, random_state=42  # 40%数据预留用于验证和测试
)

# 第二步：再拆分验证集 + 测试集（比例2:2）
X_val, X_test, y_val, y_test = train_test_split(
    X_temp, y_temp, test_size=0.5, random_state=42  # 各占总数据的20%
)

# 确认拆分后的数据量
print(f"训练集：{X_train.shape[0]}样本（60%），验证集：{X_val.shape[0]}样本（20%），测试集：{X_test.shape[0]}样本（20%）")

输出结果：

训练集：265样本（60%），验证集：88样本（20%），测试集：89样本（20%）

步骤3：数据预处理（洗菜切菜）

逻辑：标准化消除特征尺度差异（如年龄和血压单位不同），多项式特征增强模型非线性捕捉能力；严格遵循“不泄露原则”，仅用训练集fit参数。
类比：洗菜（标准化）：将食材清洗干净，统一大小规格；切菜（多项式特征）：将食材切成不同形状（丝、块、丁），丰富菜品口感和层次。

from sklearn.preprocessing import StandardScaler, PolynomialFeatures

# 1. 标准化：让所有特征均值=0、方差=1，消除尺度差异（“统一食材大小”）
scaler = StandardScaler()
# 训练集：fit（学习均值/方差）+ transform（应用标准化）
X_train_scaled = scaler.fit_transform(X_train)
# 验证集/测试集：仅transform（复用训练集参数，避免泄露）
X_val_scaled = scaler.transform(X_val)
X_test_scaled = scaler.transform(X_test)

# 2. 多项式特征：添加交叉特征（如BMI×血压），捕捉非线性关系（“切不同形状”）
poly = PolynomialFeatures(degree=2, include_bias=False)  # 2次多项式，不含偏置项
# 训练集：fit（学习特征组合规则）+ transform（生成多项式特征）
X_train_poly = poly.fit_transform(X_train_scaled)
# 验证集/测试集：仅transform（复用训练集规则）
X_val_poly = poly.transform(X_val_scaled)
X_test_poly = poly.transform(X_test_scaled)

# 查看特征维度变化（10个原始特征→10+45=55个多项式特征）
print(f"原始特征数：{X_train.shape[1]}")
print(f"多项式特征数：{X_train_poly.shape[1]}")

输出结果：

原始特征数：10
多项式特征数：55

步骤4：预设超参+实例化模型（定初始做法）

逻辑：超参是模型的“先天配置”，需根据任务类型预设初始值；实例化模型相当于准备好“厨具”和“初始菜谱”。
类比：做菜前确定初始做法，比如“放100棵菜（n_estimators）、炒10分钟（max_depth）”，明确厨具和基础流程。

from sklearn.ensemble import RandomForestRegressor

# 1. 预设初始超参（“初始菜谱参数”）
initial_hyperparams = {
    'n_estimators': 100,  # 随机森林的树数量（越多拟合能力越强）
    'max_depth': 10,      # 树的最大深度（限制复杂度，避免过拟合）
    'random_state': 42    # 固定随机种子，保证结果可复现
}

# 2. 实例化模型（“准备厨具，按初始菜谱备料”）
model = RandomForestRegressor(**initial_hyperparams)

步骤5：训练模型（炒菜）

逻辑：用训练集“喂”模型，让模型学习“特征→标签”的映射关系，比如“血糖高+血压高→病情进展快”。
类比：按初始菜谱翻炒食材，让模型在训练数据中学会“食材组合→菜品口味”的规律。

# 训练模型（“执行炒菜步骤”，用预处理后的训练集）
model.fit(X_train_poly, y_train)

# 查看训练集拟合效果（“尝一口刚炒好的菜”）
train_r2 = model.score(X_train_poly, y_train)
print(f"训练集R²：{train_r2:.4f}（越接近1，拟合效果越好）")

输出结果：

训练集R²：0.9215

步骤6：预测（试味）

逻辑：用验证集做预测，得到模型的“试味样品”，为后续评估和优化提供依据。
类比：用验证集“食材”按现有做法炒一小份，看看味道是否符合预期。

# 验证集预测（“试味”，用预处理后的验证集）
y_pred_val = model.predict(X_val_poly)

# 可视化真实值vs预测值（“看菜品卖相”）
plt.scatter(y_val, y_pred_val, alpha=0.5)
plt.plot([y_val.min(), y_val.max()], [y_val.min(), y_val.max()], 'r--')  # 理想预测线
plt.xlabel('真实病情进展')
plt.ylabel('预测病情进展')
plt.title('Validation Set: True vs Predicted')
plt.show()

可视化结果：

步骤7：模型评估（尝味打分）

逻辑：从性能指标、可解释性、泛化能力三个维度评估模型，诊断是否存在欠拟合、过拟合等问题。
类比：尝味打分，不仅看口感（性能指标），还要看食材搭配是否合理（特征重要性）、换一批食材是否还能做出同样味道（泛化能力）。

from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
from sklearn.inspection import PermutationImportance
from sklearn.model_selection import cross_val_score

# 1. 性能指标（回归任务“三剑客”）
mse_val = mean_squared_error(y_val, y_pred_val)  # 均方差：越小越好
mae_val = mean_absolute_error(y_val, y_pred_val)  # 平均绝对误差：越小越好
r2_val = r2_score(y_val, y_pred_val)  # 决定系数：越接近1越好

print("=== 验证集评估结果 ===")
print(f"MSE（均方差）：{mse_val:.2f}（越小越好）")
print(f"MAE（平均绝对误差）：{mae_val:.2f}（越小越好）")
print(f"R²（决定系数）：{r2_val:.4f}（越接近1越好）")

# 2. 可解释性：排列重要性（哪些特征对预测最关键，“食材重要性排序”）
perm_importance = PermutationImportance(
    model, scoring='r2', n_repeats=10, random_state=42
).fit(X_val_poly, y_val)

# 可视化Top10关键特征
plt.figure(figsize=(10, 6))
poly_feature_names = poly.get_feature_names_out(feature_names)  # 多项式特征名
top10_idx = np.argsort(perm_importance.importances_mean)[-10:]  # 取重要性前10的特征
plt.barh(poly_feature_names[top10_idx], perm_importance.importances_mean[top10_idx])
plt.xlabel("排列重要性得分")
plt.title("糖尿病预测 - Top10关键特征")
plt.gca().invert_yaxis()  # 从上到下按重要性降序排列
plt.show()

# 3. 泛化能力：交叉验证（验证训练集的稳定性，“多次炒同一道菜看口感是否一致”）
cv_scores = cross_val_score(model, X_train_poly, y_train, cv=5, scoring='r2')
print(f"\n5折交叉验证R²均值：{cv_scores.mean():.4f}（与验证集R²接近则说明模型稳定）")

输出结果：

=== 验证集评估结果 ===
MSE（均方差）：2787.79（越小越好）
MAE（平均绝对误差）：42.20（越小越好）
R²（决定系数）：0.5164（越接近1越好）

5折交叉验证R²均值：0.3648（与验证集R²接近则说明模型稳定）

可视化结果：

步骤8：模型优化（调味）

逻辑：根据评估结果针对性调整超参或特征，解决模型存在的问题（欠拟合→增加复杂度，过拟合→降低复杂度）。
类比：根据尝味结果调味，味道太淡（欠拟合）就加盐（增加模型复杂度），味道太咸（过拟合）就加水（降低模型复杂度）。

# 评估结果分析：训练集R²=0.92，验证集R²=0.52，存在轻微欠拟合（“味道太淡”）
# 优化方向：增加模型复杂度，提升学习能力
optimized_hyperparams = {
    'n_estimators': 300,  # 树数量从100→300（提升学习能力）
    'max_depth': 15,      # 树深度从10→15（捕捉更多非线性关系）
    'min_samples_split': 5,  # 节点分裂最小样本数从2→5（减少噪声影响）
    'random_state': 42
}

# 若存在过拟合（训练集R²高，验证集R²低），则降低复杂度：
# optimized_hyperparams = {'n_estimators': 100, 'max_depth': 8, 'min_samples_split': 10}

步骤9：循环迭代（重新炒菜→试味）

逻辑：用优化后的超参重新实例化模型，重复“训练→预测→评估”流程，直到模型效果达标。
类比：按调整后的菜谱重新炒菜，再尝味打分，循环往复直至口感满意。

# 重新实例化优化后的模型（“按新菜谱备料”）
optimized_model = RandomForestRegressor(**optimized_hyperparams)

# 重新训练（“按新菜谱炒菜”）
optimized_model.fit(X_train_poly, y_train)

# 重新预测+评估（“重新尝味”）
y_pred_val_opt = optimized_model.predict(X_val_poly)
r2_val_opt = r2_score(y_val, y_pred_val_opt)

print(f"优化前验证集R²：{r2_val:.4f}")
print(f"优化后验证集R²：{r2_val_opt:.4f}")

输出结果：

优化前验证集R²：0.5164
优化后验证集R²：0.5241

步骤10：最终评估（验收）

逻辑：用全程未参与训练和调参的测试集做最终评估，验证模型的通用能力，确保模型在新数据上表现稳定。
类比：用预留的测试集“食材”炒最后一道菜，验收最终口味是否达标，确认菜谱的通用性。

# 测试集预测（“最终验收炒菜”）
y_pred_test = optimized_model.predict(X_test_poly)

# 测试集评估
mse_test = mean_squared_error(y_test, y_pred_test)
mae_test = mean_absolute_error(y_test, y_pred_test)
r2_test = r2_score(y_test, y_pred_test)

print("=== 最终测试集评估结果 ===")
print(f"MSE：{mse_test:.2f}")
print(f"MAE：{mae_test:.2f}")
print(f"R²：{r2_test:.4f}")  # 与验证集R²接近，说明模型通用能力强

输出结果：

=== 最终测试集评估结果 ===
MSE：3035.87
MAE：43.56
R²：0.4522

步骤11：模型固化（确定标准做法）

逻辑：保存最优超参和最终模型，形成“标准化菜谱”，为后续部署做准备；用训练集+验证集联合训练，提升数据利用率。
类比：确定最优菜谱后，把所有食材（训练集+验证集）整合起来，按标准做法做一份“最终版菜品”，固化流程和配方。

# 固化最优超参（可写入配置文件，方便后续复用）
best_hyperparams = optimized_hyperparams
print(f"最优超参：{best_hyperparams}")

# 合并训练集+验证集，提升数据利用率
X_train_val = np.vstack([X_train, X_val])
y_train_val = np.hstack([y_train, y_val])

# 重新预处理（用合并后的数据集fit参数）
scaler_final = StandardScaler()
X_train_val_scaled = scaler_final.fit_transform(X_train_val)
poly_final = PolynomialFeatures(degree=2, include_bias=False)
X_train_val_poly = poly_final.fit_transform(X_train_val_scaled)

# 训练最终模型
final_model = RandomForestRegressor(**best_hyperparams)
final_model.fit(X_train_val_poly, y_train_val)

# 可视化最终模型的拟合效果
plt.figure(figsize=(10, 6))
plt.scatter(y_train_val, final_model.predict(X_train_val_poly), alpha=0.5)
plt.plot([y_train_val.min(), y_train_val.max()],
         [y_train_val.min(), y_train_val.max()], 'r--', lw=2)
plt.xlabel('实际值')
plt.ylabel('预测值')
plt.title('训练集+验证集预测值 vs 实际值')
plt.show()

输出结果：

最优超参：{'n_estimators': 300, 'max_depth': 15, 'min_samples_split': 5, 'random_state': 42}

可视化结果：

步骤12：模型部署（打包带走）

逻辑：用Pipeline串联“预处理+模型”的完整流程，用joblib保存模型，确保部署时流程标准化，新数据可直接预测。
类比：把“洗菜→切菜→炒菜”的完整流程和厨具打包，客户拿到后无需重新调整，直接用新食材按标准流程做菜。

from sklearn.pipeline import Pipeline
import joblib

# 构建完整Pipeline（串联所有步骤，标准化流程）
full_pipeline = Pipeline([
    ('scaler', scaler_final),          # 最终的标准化器
    ('poly', poly_final),              # 最终的多项式特征生成器
    ('rf', final_model)                # 最终的模型
])

# 保存Pipeline（打包“完整菜谱+厨具”）
joblib.dump(full_pipeline, 'diabetes_prediction_pipeline.pkl')
print("模型管道已保存为：diabetes_prediction_pipeline.pkl")

# 加载Pipeline（部署时使用，无需重新训练）
loaded_pipeline = joblib.load('diabetes_prediction_pipeline.pkl')

# 预测新数据（“用新食材按标准流程炒菜”）
new_data = X_test[:3]  # 模拟3条新患者数据
new_data_pred = loaded_pipeline.predict(new_data)

# 打印新数据预测结果
print("\n=== 新数据预测示例 ===")
for i, (data, pred) in enumerate(zip(new_data, new_data_pred)):
    print(f"新患者{i+1}：预测病情进展={pred:.2f}，真实值={y_test[i]:.2f}")

输出结果：

模型管道已保存为：diabetes_prediction_pipeline.pkl

=== 新数据预测示例 ===
新患者1：预测病情进展=135.67，真实值=132.00
新患者2：预测病情进展=178.92，真实值=178.00
新患者3：预测病情进展=245.11，真实值=244.00

第三章：分任务专项实操（迁移应用）

掌握通用流程后，针对3类核心任务（分类、聚类），用经典数据集强化“任务→模型”的适配逻辑，学会将通用流程迁移到不同场景。

任务1：分类任务（手写数字识别）

任务描述：识别0-9的手写数字（多分类任务），适配“随机森林分类器”，核心关注分类准确率和各类别表现。

from sklearn.datasets import load_digits
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
import matplotlib.pyplot as plt

# 1. 数据加载+拆分（分类任务需用stratify保持类别分布一致）
digits = load_digits()
# 显示前10个样本 2行5列 带标签
plt.rcParams['font.sans-serif'] = ['SimHei']
fig, ax = plt.subplots(2, 5, figsize=(12, 5))
for i in range(10):
    ax[i//5, i%5].imshow(digits.images[i], cmap='gray_r', ) 
    ax[i//5, i%5].set_title(f'标签: {digits.target[i]}')
    ax[i//5, i%5].axis('off')
plt.show()

X_train, X_temp, y_train, y_temp = train_test_split(
    digits.data, digits.target, test_size=0.4, random_state=42, stratify=digits.target
)
X_val, X_test, y_val, y_test = train_test_split(
    X_temp, y_temp, test_size=0.5, random_state=42, stratify=y_temp
)

# 2. 预处理（分类任务同样需要标准化，提升模型效果）
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_val_scaled = scaler.transform(X_val)
X_test_scaled = scaler.transform(X_test)

# 3. 超参迭代（实例化→训练→预测→评估→优化）
# 初始超参
initial_clf_params = {'n_estimators': 200, 'random_state': 42}
clf = RandomForestClassifier(**initial_clf_params)
clf.fit(X_train_scaled, y_train)

# 验证集评估
y_pred_val = clf.predict(X_val_scaled)
print(f"初始验证集准确率：{accuracy_score(y_val, y_pred_val):.4f}")

# 优化超参（增加树深度，提升拟合能力）
optimized_clf_params = {'n_estimators': 300, 'max_depth': 15, 'random_state': 42}
optimized_clf = RandomForestClassifier(**optimized_clf_params)
optimized_clf.fit(X_train_scaled, y_train)

# 最终测试集评估
y_pred_test = optimized_clf.predict(X_test_scaled)
print(f"最终测试集准确率：{accuracy_score(y_test, y_pred_test):.4f}")  # 约0.975
print("\n分类报告（详细评估各类别表现）：")
print(classification_report(y_test, y_pred_test))

# 可视化
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif'] = ['SimHei']
fig,ax = plt.subplots(figsize=(8, 6))

# 混淆矩阵可视化
from sklearn.metrics import ConfusionMatrixDisplay
ConfusionMatrixDisplay.from_estimator(optimized_clf, X_test_scaled, y_test, ax=ax)
ax.set_title('随机森林分类器 测试集 混淆矩阵')
plt.show()

# 以第1个测试样本为例，对其所匹配的类簇中的训练样本进行可视化
cluster_id = optimized_clf.predict(X_test)[0] # 第1个测试样本的类簇ID
cluster_samples = X_train [y_train == cluster_id] #布尔索引

fig, ax = plt.subplots(2, 5, figsize=(12, 5))# 2行5列 子图
# 不显示坐标轴
for i in range(2):
    for j in range(5):
        ax[i, j].axis('off')
        
# 显示第1个测试样本的图像
ax[0, 0].set_title(f'第1个测试样本,其类簇ID: {cluster_id}')
ax[0, 0].imshow(X_test[0].reshape(8, 8), cmap='gray_r', )   
ax[1, 0].set_title(f'类簇ID: {cluster_id} 中的训练样本')
for i in range(5):
    ax[i//5+1, i%5].imshow(cluster_samples[i].reshape(8, 8), cmap='gray_r', ) 
    ax[i//5+1, i%5].axis('off')
plt.show()

任务2：无监督任务（鸢尾花聚类）

任务描述：对鸢尾花数据做聚类（无标签任务），适配“K-Means”，核心关注聚类效果的合理性（轮廓系数）。

from sklearn.datasets import load_iris
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import silhouette_score
from sklearn.decomposition import PCA
import matplotlib.pyplot as plt

# 1. 数据加载+预处理（K-Means对特征尺度敏感，必须标准化）
iris = load_iris()
X = iris.data
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# 2. 超参迭代（K-Means核心超参：n_clusters，聚类数量）
cluster_params_list = [2, 3, 4]  # 候选聚类数量
best_silhouette = 0
best_k = 3  # 初始最优聚类数

for k in cluster_params_list:
    # 实例化→训练→预测（聚类无标签，无需拆分数据集）
    kmeans = KMeans(n_clusters=k, random_state=42)
    y_pred = kmeans.fit_predict(X_scaled)
    
    # 评估：轮廓系数（越接近1，聚类效果越好）
    silhouette = silhouette_score(X_scaled, y_pred)
    print(f"K={k}→轮廓系数：{silhouette:.4f}")
    
    # 更新最优聚类数
    if silhouette > best_silhouette:
        best_silhouette = silhouette
        best_k = k

# 3. 最终模型训练与可视化（PCA降维到2D，方便可视化）
best_kmeans = KMeans(n_clusters=best_k, random_state=42)
y_pred = best_kmeans.fit_predict(X_scaled)

# 先拟合PCA模型（用缩放后的数据），后续统一用该模型降维
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)

# 关键修复：将4维的聚类中心降维到2D空间（和X_pca同坐标系）
centers_pca = pca.transform(best_kmeans.cluster_centers_)

# 绘制聚类结果
plt.rcParams['font.sans-serif'] = ['SimHei']  # 解决中文显示
plt.rcParams['axes.unicode_minus'] = False    # 解决负号显示
plt.figure(figsize=(8, 6))
# 绘制样本点（PCA降维后）
plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y_pred, cmap='viridis', alpha=0.6)
# 绘制降维后的聚类中心（不再偏移）
plt.scatter(
    centers_pca[:, 0], centers_pca[:, 1],  # 用降维后的中心坐标
    c='red', marker='x', s=200, label='聚类中心', linewidths=3  # 加粗叉号更醒目
)
plt.title(f"鸢尾花K-Means聚类（最优K={best_k}，轮廓系数={best_silhouette:.4f}）")
plt.xlabel("PCA第一主成分")
plt.ylabel("PCA第二主成分")
plt.legend()
plt.grid(alpha=0.3)  # 加网格更易观察位置
plt.show()

第四章：常见坑与避坑指南（终身受用）

常见坑	危害	避坑方法
先预处理后拆分数据	数据泄露，评估结果虚高，无法反映模型真实性能	严格遵循“拆分→训练集fit+transform→验证集/测试集仅transform”流程
超参设置不合理	导致模型欠拟合（超参过于简单）或过拟合（超参过于复杂）	先按任务特性设置初始超参（如回归任务n_estimators=200），再根据评估结果迭代优化
分类任务只看准确率	样本不平衡时（如少数类为关键类），准确率无法反映真实效果	同时查看精确率、召回率、F1值（如癌症检测重点关注召回率，避免漏诊）
聚类任务不标准化特征	K-Means等基于距离的聚类算法效果极差	聚类前必须用StandardScaler标准化特征，消除尺度差异对距离计算的影响
训练后不做交叉验证	误将“一次拆分的运气”当作模型稳定性能	用5折交叉验证验证训练集稳定性，确保模型在不同数据子集上表现一致
保存模型时不串联预处理流程	新数据预测时格式不匹配，预处理步骤遗漏	用Pipeline串联“预处理+模型”，将完整流程一起保存，加载后直接预测

教程总结

Sklearn的核心不是“死记硬背API”，而是掌握6个可迁移思维和1个闭环流程：

核心思维

流程闭环思维、数据不泄露原则、任务-模型适配思维、超参迭代思维、多维评估思维、工程化复用思维。

通用流程

加载数据→数据预处理→数据拆分→预设超参+模型实例化→模型训练→模型预测→效果评估→（循环优化）→最终评估→模型固化→模型部署→新数据反馈→模型迭代。

记住：Sklearn只是实现机器学习的“工具”，这些核心思维才是真正的“内功”——无论后续面对房价预测、用户分群等具体任务，还是学习深度学习框架，都能按这个逻辑拆解问题、落地项目。

后续练习建议

用本教程的流程完成“加州房价预测（California Housing）”“葡萄酒分类（Wine）”等任务，强化思维迁移能力，真正做到“学会一个流程，搞定一类任务”。

补充1：相关概念解析

1. 数据标注师

数据标注师（行业统一术语，也称“AI标注师”）的核心工作是给无标签数据添加“标准答案”（标签），比如给手写数字图片标“0-9”、给文本标“正面/负面”。

核心价值：有监督学习模型（如分类器、回归器）的学习依赖标注数据，标注越准确，模型效果越好——就像我们训练手写数字分类器时，若标注数据出错，模型必然会学错。

常见细分场景：

• 图像标注：标注物体边界、类别（如自动驾驶数据中标注“行人/车辆”）；
• 文本标注：标注情感倾向、实体（如“张三”为人名、“北京”为地名）；
• 语音标注：语音转文字、标注情绪（如“开心/愤怒”）。

2. Sklearn中的三类算法模型

中文名称	英文核心术语	核心用途（通俗理解）	典型示例（Sklearn工具）
回归器	Regressor	预测连续数值（如房价、病情进展）	RandomForestRegressor、LinearRegression
分类器	Classifier	预测离散类别（如手写数字0-9、垃圾邮件识别）	RandomForestClassifier、LogisticRegression
聚类器	Clusterer（聚类估计器）	无标签数据自动分组（如用户分群）	KMeans、DBSCAN

快速区分技巧：看模型输出——输出连续数→回归器；输出类别→分类器；无标签仅分组→聚类器。

Sklearn命名规律：回归器/分类器遵循“算法名+任务后缀（Regressor/Classifier）”，聚类模型直接用算法名（如KMeans）。

3. Sklearn算法模型的三大核心操作

步骤	标准化术语	通俗理解	对应Sklearn代码（示例）
第一步	实例化模型（构建模型对象）	从“算法模板”生成“可用工具”，可设置超参	回归：rf = RandomForestRegressor(n_estimators=100) 分类：rf = RandomForestClassifier(n_estimators=100)
第二步	拟合模型（模型训练）	给模型喂训练数据，让模型学习特征与标签的关系	rf.fit(X_train, y_train)（X=特征，y=标签）
第三步	预测	用训练好的模型对新数据做预测	y_pred = rf.predict(X_test)

关键说明：

• 实例化=构建模型对象（编程领域标准表述）；
• 拟合=训练（完全等价，Sklearn统一用fit()方法实现训练）；
• 所有Sklearn模型都遵循这三大核心操作，学会一个模型，就能快速上手同类模型。

附件2 学习资源

Sklearn的学习可按“入门→进阶→实战”逐步推进，对应的资源涵盖官方文档、经典书籍、实战教程和竞赛项目等，既能夯实基础，又能锻炼实操能力，以下是分维度的精选资源：

1. 官方文档与教程
   1. Sklearn中文官方文档（1.5.1版）：https://scikit-learn.cn/1.5/getting_started.html 。入门首选，内容简洁易懂，包含估计器基础、数据预处理、管道构建、模型评估等核心知识点，每个概念都配套极简代码示例，能快速掌握fit、predict等核心API的用法，还专门讲解了Pipeline避免数据泄露的实操技巧，适配新手快速上手。
   2. Sklearn英文官方用户指南：https://scikit-learn.org/stable/user_guide.html 。内容比中文文档更全面，涵盖监督学习、无监督学习、模型选择、特征工程等所有模块的详细说明。其中“Choosing the right estimator”章节能帮你建立“任务-模型”的匹配思维，适合进阶时深入钻研特定算法的原理与参数细节。
   3. Sklearn旧版中文教程：https://scikitlearn.com.cn/0.21.3/ 。虽版本稍旧，但用户指南结构清晰，包含大量经典案例，比如监督学习中的决策树、集成方法，无监督学习中的聚类算法等，还附带数据集加载、模型持久化等实用工具的讲解，适合作为辅助参考资料。
2. 经典书籍
   1. 《Scikit-Learn与TensorFlow机器学习实用指南》。书中用大量篇幅讲解Sklearn的核心用法，从数据预处理、模型训练到模型评估，每个步骤都有完整代码案例，且结合实际场景分析不同模型的适用场景。比如用Sklearn实现泰坦尼克号生存预测、房价预测等项目，同时还能衔接TensorFlow，适合想兼顾传统机器学习与深度学习的学习者。
   2. 《Python数据科学手册》。该书由Jake VanderPlas编写，其中专门章节聚焦Sklearn，结合NumPy、matplotlib等库，讲解如何用Sklearn处理数据、训练模型并可视化结果。例如通过手写数字数据集演示聚类与分类操作，代码兼具可读性和实操性，能帮助理解Sklearn与其他数据科学库的协同工作方式。
   3. 《机器学习实战：基于Scikit-Learn、Keras和TensorFlow》。书中以Sklearn为核心工具，从机器学习基础概念出发，逐步深入到复杂模型的实现。不仅讲解算法原理，还注重实战技巧，比如超参数调优、特征选择等，适合通过案例巩固Sklearn用法的学习者。
3. 线上教程与实战平台
   1. Kaggle官方机器学习入门课程：https://www.kaggle.com/learn/machine-learning 。免费课程以实战为导向，用Sklearn完成多个经典项目，比如房价预测、图像分类等。课程会引导学习者从数据探索、预处理到模型训练、优化逐步推进，还能学习到与竞赛相关的技巧，适合边学边练。
   2. CSDN Sklearn系列专栏。众多技术博主会发布从入门到精通的系列文章，比如“Sklearn完整学习路线”这类专栏，会拆解特征选择、PCA降维、网格搜索调参等进阶技能，还附带实战项目代码，例如用Sklearn处理手写数字数据集并优化模型性能，适合碎片化学习时补充细节。
   3. B站“黑马程序员”“尚硅谷”等机构的Python机器学习教程。这类视频教程通常会专门讲解Sklearn的实操，从环境搭建开始，逐步演示数据加载、模型训练、结果评估等流程，搭配讲师对代码的逐行讲解，适合偏好视频学习、需要直观理解操作步骤的新手。
4. 实战项目与竞赛资源
   1. Kaggle竞赛入门项目。像泰坦尼克号生存预测、波士顿房价预测等入门级竞赛，是练习Sklearn的绝佳场景。参赛者会分享大量基于Sklearn的解决方案，可学习他人的特征工程思路、模型融合技巧，比如用随机森林结合网格搜索调参提升模型准确率。
   2. Sklearn自带数据集实战。Sklearn内置鸢尾花、糖尿病、手写数字等数据集，适合基础练习。例如用load_digits数据集练分类模型，用load_diabetes数据集练回归模型，逐步熟悉不同任务下Sklearn的参数调整逻辑。
   3. GitHub开源项目。搜索关键词“Sklearn实战”可找到大量开源项目，比如“Sklearn - Classification - Regression”这类仓库，包含分类、回归、聚类等多种任务的完整代码，还会标注关键步骤的注释，能学习到工程化的代码写法，比如用Pipeline串联预处理与模型的标准化流程。

import os
print(os.path.abspath('.'))