1
传统编程：规则 + 数据 → [程序] → 答案
2
机器学习：数据 + 答案 → [训练] → 规则（模型）→ 预测新数据的答案

1
监督学习细分：
2
- 分类（Classification）：预测离散类别（垃圾邮件/正常，猫/狗）
3
- 回归（Regression）：预测连续数值（房价、股价、温度）

1
1. 收集数据      →  爬虫/数据库/公开数据集
2
2. 数据预处理    →  清洗、缺失值、编码、归一化、特征工程
3
3. 划分数据集    →  训练集 / 验证集 / 测试集
4
4. 选择模型      →  根据问题类型选算法
5
5. 训练模型      →  fit(X_train, y_train)
6
6. 评估模型      →  准确率/精确率/召回率/混淆矩阵
7
7. 调优          →  超参数调优、交叉验证、特征选择
8
8. 部署预测      →  predict(X_new)

1
from sklearn.preprocessing import StandardScaler, MinMaxScaler, LabelEncoder, OneHotEncoder
2

3
# 标准化（均值0方差1，适合大多数算法）
4
scaler = StandardScaler()
5
X_train = scaler.fit_transform(X_train)   # 训练集 fit + transform
6
X_test = scaler.transform(X_test)         # 测试集只 transform（用训练集的参数！）
7

8
# 归一化（缩放到 [0,1]）
9
MinMaxScaler().fit_transform(X)
10

11
# 类别特征编码
12
LabelEncoder().fit_transform(["男", "女", "男"])        # → [1, 0, 1]（有序）
13
OneHotEncoder(sparse_output=False).fit_transform([["红"], ["蓝"]])  # 独热（无序）

1
from sklearn.neighbors import KNeighborsClassifier
2

3
knn = KNeighborsClassifier(n_neighbors=5)   # K=5
4
knn.fit(X_train, y_train)
5
knn.predict([[5.1, 3.5, 1.4, 0.2]])
6

7
# K 值选择：太小易过拟合（受噪声影响），太大易欠拟合（边界模糊）
8
# 通常取奇数（避免平票），用交叉验证选最优 K

1
kNN 特点：
2
✅ 简单、无需训练（惰性学习）、天然支持多分类
3
❌ 预测慢（要算所有距离）、对特征尺度敏感（必须先标准化）、高维失效
4
适用：小数据、低维、需要简单基线模型

1
from sklearn.tree import DecisionTreeClassifier, export_text
2

3
tree = DecisionTreeClassifier(max_depth=3, criterion="gini")
4
tree.fit(X_train, y_train)
5

6
# 查看决策规则
7
print(export_text(tree, feature_names=data.feature_names))
8

9
# 特征重要性
10
print(tree.feature_importances_)

1
决策树特点：
2
✅ 可解释性强（能画出树）、不用标准化、能处理数值和类别
3
❌ 易过拟合（需限制 max_depth / min_samples_split）
4
关键参数：max_depth（最大深度）、min_samples_split（分裂最小样本）
5
         criterion（gini 基尼 / entropy 信息熵）

1
# 线性回归（预测连续值，如房价）
2
from sklearn.linear_model import LinearRegression
3
reg = LinearRegression()
4
reg.fit(X_train, y_train)
5
print(reg.coef_)        # 系数（权重）
6
print(reg.intercept_)   # 截距
7
# 方程：y = w1*x1 + w2*x2 + ... + b
8

9
# 逻辑回归（尽管叫"回归"，其实是分类！输出概率）
10
from sklearn.linear_model import LogisticRegression
11
clf = LogisticRegression()
12
clf.fit(X_train, y_train)
13
clf.predict_proba(X_test)   # 输出各类别概率

1
过拟合 vs 欠拟合：
2
过拟合（Overfitting）：训练集很好，测试集差 → 模型太复杂，学到了噪声
3
                       解决：正则化、简化模型、增数据、交叉验证、剪枝
4
欠拟合（Underfitting）：训练集和测试集都差 → 模型太简单，没学到规律
5
                       解决：加特征、增复杂度、减正则化

1
from sklearn.svm import SVC
2

3
svm = SVC(kernel="rbf", C=1.0, gamma="scale")   # rbf 高斯核（非线性）
4
svm.fit(X_train, y_train)
5
# kernel: linear（线性）/ rbf（高斯，最常用）/ poly（多项式）
6
# C: 惩罚系数（大→不容错易过拟合，小→容忍错易欠拟合）

1
# 随机森林（Bagging：多棵决策树并行投票，降方差防过拟合）
2
from sklearn.ensemble import RandomForestClassifier
3
rf = RandomForestClassifier(n_estimators=100, max_depth=None, random_state=42)
4
rf.fit(X_train, y_train)
5
print(rf.feature_importances_)     # 特征重要性
6

7
# GradientBoosting（Boosting：树串行，每棵纠正前一棵的错误，降偏差）
8
from sklearn.ensemble import GradientBoostingClassifier
9
gb = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1)
10
gb.fit(X_train, y_train)

1
Bagging vs Boosting：
2
Bagging（随机森林）：并行训练多个模型投票，降方差，抗过拟合，可并行
3
Boosting（GBDT）：串行训练，后者纠正前者错误，降偏差，精度高，易过拟合
4
工业界更强：XGBoost / LightGBM / CatBoost（GBDT 的高效实现，竞赛常胜）

1
from sklearn.cluster import KMeans
2
from sklearn.datasets import make_blobs
3

4
X, _ = make_blobs(n_samples=300, centers=4, random_state=42)
5

6
kmeans = KMeans(n_clusters=4, random_state=42, n_init=10)
7
kmeans.fit(X)                      # 无需标签 y！
8
labels = kmeans.predict(X)         # 每个点的簇标签
9
print(kmeans.cluster_centers_)     # 各簇中心
10

11
# 用肘部法则选 K（画不同 K 的 inertia，找拐点）
12
inertias = [KMeans(n_clusters=k, n_init=10).fit(X).inertia_ for k in range(1, 10)]

1
KMeans 特点：
2
✅ 简单高效、易实现
3
❌ 需预先指定 K、对初始中心和异常值敏感、只适合凸形簇
4
肘部法则：inertia（簇内平方和）随 K 增大而减小，找"肘部"拐点即最优 K

1
from sklearn.decomposition import PCA
2

3
pca = PCA(n_components=2)          # 降到 2 维
4
X_reduced = pca.fit_transform(X)   # 降维
5
print(pca.explained_variance_ratio_)   # 各主成分解释的方差比例
6
# 若前2个主成分解释 >85% 方差，说明降维损失小

1
降维好处：减少特征数（防维度灾难）、可视化（降到2/3维）、去噪、加速训练
2
PCA 是最常用的线性降维；非线性降维有 t-SNE（可视化神器）、UMAP

1
from sklearn.metrics import (accuracy_score, precision_score, recall_score,
2
                             f1_score, confusion_matrix, classification_report)
3

4
y_true = [0, 1, 1, 0, 1]
5
y_pred = [0, 1, 0, 0, 1]
6

7
print(accuracy_score(y_true, y_pred))     # 准确率 = 对的/总数
8
print(precision_score(y_true, y_pred))    # 精确率 = TP/(TP+FP)  预测为正的里有多少真对
9
print(recall_score(y_true, y_pred))       # 召回率 = TP/(TP+FN)  真正的里找回多少
10
print(f1_score(y_true, y_pred))           # F1 = 精确率和召回率的调和平均
11
print(confusion_matrix(y_true, y_pred))   # 混淆矩阵
12
print(classification_report(y_true, y_pred))  # 综合报告

1
混淆矩阵（二分类）：
2
                预测正    预测负
3
实际正          TP        FN     （漏报）
4
实际负          FP        TN     （误报）
5

6
准确率 Accuracy  = (TP+TN)/总数        整体对的比例（类别不均衡时会骗人！）
7
精确率 Precision = TP/(TP+FP)         预测为正的准不准（重在不冤枉）
8
召回率 Recall    = TP/(TP+FN)         正样本找得全不全（重在不漏掉）
9
F1 = 2 * P*R/(P+R)                   精确率和召回率的平衡

1
from sklearn.model_selection import cross_val_score, GridSearchCV
2

3
# K 折交叉验证（更可靠地评估模型，默认 5 折）
4
scores = cross_val_score(rf, X, y, cv=5, scoring="accuracy")
5
print(scores.mean(), scores.std())      # 5 次准确率的均值和标准差
6

7
# 网格搜索（自动找最优超参数组合）
8
param_grid = {
9
    "n_estimators": [50, 100, 200],
10
    "max_depth": [None, 5, 10],
11
}
12
grid = GridSearchCV(rf, param_grid, cv=5, scoring="accuracy", n_jobs=-1)
13
grid.fit(X, y)
14
print(grid.best_params_)                # 最优参数
15
print(grid.best_score_)                 # 最优得分
16
print(grid.best_estimator_)             # 最优模型

1
交叉验证：把数据分 K 份，轮流用 K-1 份训练、1 份验证，取平均。
2
         好处：充分利用数据、评估更稳定、减少过拟合风险。
3
网格搜索：遍历所有超参数组合，配合交叉验证选最优。
4
         参数多用 RandomizedSearchCV（随机采样，更快）。

1
from sklearn.pipeline import Pipeline
2

3
# 把预处理 + 模型串成一条流水线
4
pipe = Pipeline([
5
    ("scaler", StandardScaler()),          # 先标准化
6
    ("clf", RandomForestClassifier()),     # 再分类
7
])
8
pipe.fit(X_train, y_train)                 # 一起 fit，自动避免数据泄漏
9
pipe.score(X_test, y_test)
10

11
# Pipeline 配合网格搜索（参数名用 "步骤名__参数名"）
12
GridSearchCV(pipe, {"clf__n_estimators": [50, 100]}, cv=5).fit(X, y)

1
人工神经元：输入 x → 加权求和 + 偏置 → 激活函数 → 输出
2
   输出 = activation(w1*x1 + w2*x2 + ... + b)
3

4
激活函数（引入非线性）：
5
- ReLU：f(x)=max(0,x)      最常用，解决梯度消失
6
- Sigmoid：f(x)=1/(1+e^-x) 输出(0,1)，二分类输出层
7
- Softmax：多分类输出层（输出概率和为1）
8
- Tanh：输出(-1,1)
9

10
神经网络 = 多层神经元堆叠（输入层 → 隐藏层 → 输出层）
11
深度学习 = 多层（深层）神经网络

1
from sklearn.neural_network import MLPClassifier
2

3
mlp = MLPClassifier(hidden_layer_sizes=(64, 32),   # 两个隐藏层
4
                    activation="relu",
5
                    max_iter=1000, random_state=42)
6
mlp.fit(X_train, y_train)
7
print(mlp.score(X_test, y_test))

1
sklearn MLP：小数据、快速原型
2
真正的深度学习用专业框架：
3
- PyTorch（学术界主流、动态图、灵活，推荐入门）
4
- TensorFlow/Keras（工业界、生态全、部署方便）
5
应用：CNN（图像）、RNN/LSTM（序列/时间）、Transformer（NLP/大模型）