机器学习三要素完全手册：模型 + 策略 + 算法（10000字深度解析·附 20 段 Python 代码 + 16 张对比表 + 11 张 Mermaid 图表）

机器学习看似深奥，其实所有算法都可以用"三要素"框架解构：模型（要学什么）+ 策略（怎么衡量学得好）+ 算法（怎么高效学出来）。本文 10000 字 + 20 段代码 + 16 张对比表 + 11 个 Mermaid 图表，从李航《统计学习方法》的经典框架出发，把监督学习、无监督学习、强化学习、半监督学习一网打尽。让你彻底搞懂「为什么回归用 MSE、分类用交叉熵」「批量梯度下降和小批量梯度下降的本质区别」「为什么 Adam 比 SGD 收敛快」。

---

📖 目录

1. 机器学习三要素的核心思想
2. 第一要素：模型（要学什么）
3. 监督学习 5 大模型族
4. 无监督学习 4 大模型族
5. 第二要素：策略（怎么衡量学得好）
6. 损失函数 8 大选择
7. 风险函数与正则化
8. 第三要素：算法（怎么高效学出来）
9. 梯度下降 5 大变体
10. 二阶优化：牛顿法与拟牛顿
11. Adam 家族：自适应学习率
12. 学习率调度策略
13. 凸优化与非凸优化
14. 4 大机器学习范式
15. 监督学习实战：房价预测
16. 无监督学习实战：客户分群
17. 强化学习实战：CartPole
18. 半监督学习：自训练与伪标签
19. 常见陷阱与面试 FAQ
20. 参考文献

---

1. 机器学习三要素的核心思想

1.1 李航《统计学习方法》框架

模型（Model）：从输入空间到输出空间的映射关系。学习的假设空间 F。

策略（Strategy）：从假设空间中选择最优模型的评价标准。通常是损失函数 + 风险最小化。

算法（Algorithm）：实现"从假设空间到最优模型"的计算方法。通常是优化算法。

1.2 三要素的相互关系

1.3 4 大类问题对应三要素

问题	模型	策略	算法
监督学习	条件概率 P(Y|X) 或决策函数 Y=f(X)	损失函数 + 风险最小化	梯度下降 / 牛顿法
无监督学习	概率密度 P(X) 或聚类函数	重构误差 / 簇内距离	EM / K-Means
强化学习	策略 π(a|s) 或价值函数 V(s)	累积奖励最大化	Q-Learning / 策略梯度
半监督学习	联合分布 P(X,Y)	标注损失 + 一致性正则	自训练 / Co-Training

---

2. 第一要素：模型（要学什么）

2.1 假设空间的三种形式

形式	表达	例子
概率模型	P(Y|X) 或 P(X,Y)	朴素贝叶斯、GMM、HMM
非概率模型	Y = f(X)	线性回归、SVM、决策树
判别 + 生成	两者结合	GAN、VAE

2.2 模型选择的 4 大原则

2.3 模型复杂度对照

模型	参数量	训练数据需求	解释性
线性回归	d+1	100+	高
决策树	2^depth	1000+	高
随机森林	M × 树	1万+	中
XGBoost	同 RF	1万+	中
MLP（小）	10K	1万+	低
深度网络	1M-1B	10万+	低
Transformer	1B+	百万+	极低

---

3. 监督学习 5 大模型族

3.1 线性模型族

3.2 树模型族

3.3 神经网络族

import torch
import torch.nn as nn

# 简单 MLP
class MLP(nn.Module):
    def __init__(self, input_dim, hidden_dims, output_dim):
        super().__init__()
        layers = []
        prev = input_dim
        for h in hidden_dims:
            layers.extend([nn.Linear(prev, h), nn.ReLU(), nn.Dropout(0.5)])
            prev = h
        layers.append(nn.Linear(prev, output_dim))
        self.net = nn.Sequential(*layers)

    def forward(self, x):
        return self.net(x)

# 使用
model = MLP(784, [256, 128], 10)  # MNIST

3.4 概率模型族

模型	核心	应用
朴素贝叶斯	特征条件独立	文本分类
隐马尔可夫 HMM	状态转移 + 观测	语音、序列
条件随机场 CRF	全局归一化	NER、分词
高斯混合 GMM	多高斯叠加	聚类、密度估计

3.5 实例化代码

from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from sklearn.neural_network import MLPClassifier

models = {
    'Logistic': LogisticRegression(max_iter=1000),
    'Tree': DecisionTreeClassifier(max_depth=5),
    'RF': RandomForestClassifier(n_estimators=100),
    'GBDT': GradientBoostingClassifier(n_estimators=100),
    'SVM': SVC(kernel='rbf'),
    'MLP': MLPClassifier(hidden_layer_sizes=(64, 32), max_iter=500)
}

for name, model in models.items():
    model.fit(X_train, y_train)
    print(f"{name}: {model.score(X_test, y_test):.3f}")

---

4. 无监督学习 4 大模型族

4.1 4 大族

4.2 聚类 vs 降维的本质

• 聚类：把样本分组，输出离散标签
• 降维：把高维映射到低维，输出连续向量

4.3 自编码器实战

import torch
import torch.nn as nn

class AutoEncoder(nn.Module):
    def __init__(self, input_dim, latent_dim=2):
        super().__init__()
        self.encoder = nn.Sequential(
            nn.Linear(input_dim, 128), nn.ReLU(),
            nn.Linear(128, 32), nn.ReLU(),
            nn.Linear(32, latent_dim)
        )
        self.decoder = nn.Sequential(
            nn.Linear(latent_dim, 32), nn.ReLU(),
            nn.Linear(32, 128), nn.ReLU(),
            nn.Linear(128, input_dim), nn.Sigmoid()
        )

    def forward(self, x):
        z = self.encoder(x)
        x_hat = self.decoder(z)
        return x_hat, z

# 训练
ae = AutoEncoder(784, 2)
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(ae.parameters(), lr=1e-3)
# ... 训练循环

---

5. 第二要素：策略（怎么衡量学得好）

5.1 损失函数

损失函数 L(Y, f(X))：单个样本的预测误差。

5.2 风险函数

期望风险：R_exp(f) = E[L(Y, f(X))]
经验风险：R_emp(f) = (1/n) Σ L(y_i, f(x_i))

ERM（经验风险最小化）原则：min R_emp(f) 在大样本下 ≈ min R_exp(f)

5.3 结构风险

R_srm(f) = R_emp(f) + λ J(f) ← J(f) 是模型复杂度

SRM（结构风险最小化）原则：min R_srm(f) 同时考虑拟合和复杂度

---

6. 损失函数 8 大选择

6.1 8 大损失函数

损失函数	公式	适用	特点
0-1 损失	L = I(y≠f)	分类理论	不可导
平方损失 (MSE)	(y-f)²	回归	凸、可导
绝对损失 (MAE)	|y-f|	回归	抗噪声
Huber 损失	分段 MSE+MAE	回归	折中
Hinge 损失	max(0, 1-yf)	SVM	凸
Logistic 损失	log(1+exp(-yf))	分类	凸
交叉熵 (CE)	-Σ y log p	分类	首选
KL 散度	Σ p log(p/q)	概率对齐	非对称

6.2 分类为什么用交叉熵

import torch
import torch.nn.functional as F

# 预测概率
logits = torch.tensor([[2.0, 1.0, 0.1], [0.5, 2.5, 0.3]])
labels = torch.tensor([0, 1])

# 交叉熵
loss = F.cross_entropy(logits, labels)
print(f"交叉熵损失: {loss.item():.3f}")

数学直觉：交叉熵衡量两个概率分布 p 和 q 的距离，最小化它等价于最大化似然。

6.3 回归为什么用 MSE

# 均方误差
loss_mse = ((y_true - y_pred) ** 2).mean()

# 平均绝对误差
loss_mae = (y_true - y_pred).abs().mean()

# Huber 损失（对异常值鲁棒）
delta = 1.0
residual = (y_true - y_pred).abs()
loss_huber = torch.where(residual < delta, 0.5 * residual ** 2, delta * (residual - 0.5 * delta)).mean()

6.4 损失函数选型决策树

任务类型？
├─ 回归 → MSE / MAE / Huber
│   ├─ 有异常值 → Huber / MAE
│   └─ 噪声大 → MAE
└─ 分类
    ├─ 二分类 → BCE（Binary Cross Entropy）
    ├─ 多分类 → CE（Categorical Cross Entropy）
    └─ 多标签 → BCE（每类独立）

---

7. 风险函数与正则化

7.1 L1 vs L2 正则

维度	L1 (Lasso)	L2 (Ridge)
公式	λ Σ |w|	λ Σ w²
稀疏性	强（特征选择）	弱
解	软阈值	缩放
几何	菱形约束	圆形约束
适用	高维稀疏	多重共线性

7.2 其他正则化

方法	公式	思想
Dropout	训练时随机失活	集成效果
BatchNorm	归一化激活	稳定训练
数据增强	加扰动	增加数据
Early Stop	提前停止	防止过拟合
权重衰减	L2 等价	限制权重

7.3 偏差-方差权衡

import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import learning_curve
from sklearn.ensemble import RandomForestClassifier

train_sizes, train_scores, val_scores = learning_curve(
    RandomForestClassifier(n_estimators=100, max_depth=5),
    X, y, cv=5, train_sizes=np.linspace(0.1, 1.0, 10),
    scoring='accuracy'
)
print(f"训练均值: {train_scores.mean(axis=1)}")
print(f"验证均值: {val_scores.mean(axis=1)}")

---

8. 第三要素：算法（怎么高效学出来）

8.1 优化的统一框架

min f(w)  ←  目标函数（损失 + 正则）
迭代：w_t+1 = w_t - α_t ∇f(w_t)  ←  通式

8.2 算法分类

8.3 凸优化 vs 非凸

维度	凸优化	非凸优化
局部最优	= 全局最优	不一定
解的质量	可保证	不保证
例子	线性回归、SVM	神经网络

---

9. 梯度下降 5 大变体

9.1 全量 BGD（Batch Gradient Descent）

# BGD：每次用全量数据
w = np.zeros(d)
for epoch in range(1000):
    grad = (1/n) * X.T @ (X @ w - y)  # 全量
    w = w - lr * grad

特点：稳定，慢，占内存大。

9.2 随机 SGD（Stochastic GD）

# SGD：每次用 1 个样本
w = np.zeros(d)
for epoch in range(100):
    idx = np.random.permutation(n)
    for i in idx:
        x_i, y_i = X[i], y[i]
        grad = x_i * (x_i @ w - y_i)
        w = w - lr * grad

特点：快，震荡，可跳出局部最优。

9.3 小批量 MBGD（Mini-Batch GD）

# MBGD：每次用 batch_size 个样本（**工业标准**）
w = np.zeros(d)
batch_size = 64
for epoch in range(100):
    idx = np.random.permutation(n)
    for i in range(0, n, batch_size):
        batch = idx[i:i+batch_size]
        X_b, y_b = X[batch], y[batch]
        grad = (1/len(batch)) * X_b.T @ (X_b @ w - y_b)
        w = w - lr * grad

特点：SGD + BGD 的折中，是 PyTorch / TF 的默认。

9.4 带动量 SGD

# 动量 SGD
v = 0
beta = 0.9
for epoch in range(100):
    for batch in batches:
        grad = compute_grad(batch)
        v = beta * v + (1 - beta) * grad  # 累积
        w = w - lr * v

直觉：把过去梯度"惯性"叠加，穿越狭窄谷地。

9.5 5 大变体对比

变体	速度	稳定性	内存	收敛性
BGD	慢	高	大	平滑
SGD	快	低	小	震荡
MBGD	中	中	中	折中
动量	中	中高	中	加速
Nesterov	中	高	中	提前看

9.6 PyTorch 一行切换

# PyTorch 内置
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9)  # 带动量
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)  # 不带动量

---

10. 二阶优化：牛顿法与拟牛顿

10.1 牛顿法公式

$$w_{t+1}=w_t-[{\nabla }^{2}f(w_t){]}^{-1}\nabla f(w_t)$$

• H = Hessian 矩阵（n×n）
• 求逆 O(n³)

10.2 拟牛顿法（BFGS / L-BFGS）

# sklearn 默认用 L-BFGS
from sklearn.linear_model import LogisticRegression
lr = LogisticRegression(solver='lbfgs', max_iter=1000).fit(X, y)

方法	内存	大数据
牛顿法	O(n²)	❌
BFGS	O(n²)	❌
L-BFGS	O(n)	✓

10.3 一阶 vs 二阶

维度	一阶（SGD 类）	二阶（牛顿类）
每步速度	快	慢
步数	多	少
适合	大数据 / 神经网络	小数据 / 凸问题
实现	简单	复杂

---

11. Adam 家族：自适应学习率

11.1 Adam 公式

m_t = β1 m_{t-1} + (1-β1) g_t         # 一阶矩
v_t = β2 v_{t-1} + (1-β2) g_t²        # 二阶矩
m_hat = m_t / (1-β1^t)
v_hat = v_t / (1-β2^t)
w_t = w_{t-1} - lr * m_hat / (√v_hat + ε)

11.2 Adam 变体

变体	特点	适合
Adam	标准	通用
AdamW	解耦权重衰减	深度学习
Nadam	Adam + Nesterov	计算机视觉
RAdam	修正方差	训练初期
Lookahead	双权重	稳定收敛

11.3 实战对比

# PyTorch 三种优化器
sgd = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
adam = torch.optim.Adam(model.parameters(), lr=0.001)
adamw = torch.optim.AdamW(model.parameters(), lr=0.001, weight_decay=0.01)

---

12. 学习率调度策略

12.1 6 大策略

12.2 代码实战

from torch.optim.lr_scheduler import (
    StepLR, ExponentialLR, CosineAnnealingLR,
    LinearLR, CyclicLR, ReduceLROnPlateau
)

# 阶梯
scheduler = StepLR(optimizer, step_size=30, gamma=0.1)
# 余弦
scheduler = CosineAnnealingLR(optimizer, T_max=100)
# 预热 + 余弦
warmup = LinearLR(optimizer, start_factor=0.01, total_iters=10)
cosine = CosineAnnealingLR(optimizer, T_max=90)
scheduler = torch.optim.lr_scheduler.SequentialLR(optimizer, [warmup, cosine], milestones=[10])

12.3 经验法则

任务	lr
SGD（图像）	0.1 + Step
Adam（图像）	1e-3
Adam（NLP）	5e-5 ~ 5e-4
LLM 预训练	1e-4 ~ 6e-4
LLM 微调	1e-5 ~ 5e-5

---

13. 凸优化与非凸优化

13.1 凸函数判定

• 海塞矩阵半正定
• 全局最优 = 局部最优
• 线性回归、SVM、逻辑回归都是凸

13.2 非凸问题

• 神经网络、深度学习
• 局部最优很多
• 靠随机性（SGD 噪声）跳出

13.3 鞍点问题

---

14. 4 大机器学习范式

14.1 4 大范式对比

范式	数据	反馈	典型
监督学习	(X, Y)	立即	分类、回归
无监督	X	无	聚类、降维
半监督	少量 (X, Y) + 大量 X	部分	伪标签
强化学习	(s, a, r, s’)	延迟	游戏、机器人

14.2 半监督学习：伪标签

import numpy as np
from sklearn.semi_supervised import SelfTrainingClassifier
from sklearn.ensemble import RandomForestClassifier

# 标记少量数据
rng = np.random.RandomState(42)
n_labeled = 50
labels = np.full(y.shape, -1)  # -1 表示未标记
idx = rng.choice(len(y), n_labeled, replace=False)
labels[idx] = y[idx]

# 自训练
self_training = SelfTrainingClassifier(
    base_estimator=RandomForestClassifier(),
    threshold=0.95
).fit(X, labels)

print(f"自训练准确率: {self_training.score(X_test, y_test):.3f}")

14.3 强化学习：Q-Learning

import gym
import numpy as np

env = gym.make('CartPole-v1')
Q = np.zeros((env.observation_space.shape[0] * 10, env.action_space.n))

def discretize(state):
    upper_bounds = [2.4, 3.0, 0.21, 3.5]
    lower_bounds = [-2.4, -3.0, -0.21, -3.5]
    ratios = [(s - l) / (u - l) for s, l, u in zip(state, lower_bounds, upper_bounds)]
    return tuple(int(r * 10) for r in ratios)

# 训练（简化版）
alpha, gamma, epsilon = 0.1, 0.99, 0.1
for episode in range(1000):
    state = discretize(env.reset()[0])
    done = False
    while not done:
        if np.random.random() < epsilon:
            action = env.action_space.sample()
        else:
            action = np.argmax(Q[state])
        next_state, reward, done, _, _ = env.step(action)
        next_state = discretize(next_state)
        Q[state, action] += alpha * (reward + gamma * np.max(Q[next_state]) - Q[state, action])
        state = next_state

---

15. 监督学习实战：房价预测

15.1 完整流程

import numpy as np
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.metrics import mean_squared_error, r2_score

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

# 2. 划分
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 3. 三种策略对比
models = {
    'Linear (无正则)': LinearRegression(),
    'Ridge (L2)': Ridge(alpha=1.0),
    'Lasso (L1)': Lasso(alpha=0.1),
    'GBDT': GradientBoostingRegressor(n_estimators=100)
}

for name, model in models.items():
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    print(f"{name}: RMSE={np.sqrt(mean_squared_error(y_test, y_pred)):.3f}, R²={r2_score(y_test, y_pred):.3f}")

15.2 关键观察

模型	RMSE	R²	解释
线性回归	0.745	0.576	基线
Ridge	0.745	0.576	L2 几乎不影响
Lasso	0.745	0.576	几乎不稀疏
GBDT	0.535	0.781	非线性更好

---

16. 无监督学习实战：客户分群

from sklearn.cluster import KMeans
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler

# 1. 数据预处理（**必须标准化**）
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# 2. 选 K（肘部法则）
sse = [KMeans(n_clusters=k, n_init=10, random_state=42).fit(X_scaled).inertia_ for k in range(2, 11)]

# 3. 训练
km = KMeans(n_clusters=4, n_init=10, random_state=42)
labels = km.fit_predict(X_scaled)

# 4. 可视化（PCA 降维到 2D）
X_2d = PCA(n_components=2).fit_transform(X_scaled)
import matplotlib.pyplot as plt
plt.scatter(X_2d[:, 0], X_2d[:, 1], c=labels, cmap='tab10', s=10)
plt.title('客户分群')
plt.show()

---

17. 强化学习实战：CartPole

import gymnasium as gym
from stable_baselines3 import DQN

# 1. 创建环境
env = gym.make('CartPole-v1')

# 2. 创建 DQN 模型
model = DQN('MlpPolicy', env, learning_rate=1e-3, verbose=1)

# 3. 训练
model.learn(total_timesteps=10000)

# 4. 测试
obs, _ = env.reset()
for _ in range(1000):
    action, _ = model.predict(obs)
    obs, reward, done, _, _ = env.step(action)
    if done: break

---

18. 半监督学习：自训练与伪标签

from sklearn.semi_supervised import LabelSpreading

# 1. 少量标签
labels_semi = np.full(y.shape, -1)
labels_semi[idx] = y[idx]

# 2. Label Spreading
ls = LabelSpreading(kernel='knn', n_neighbors=7, alpha=0.2)
ls.fit(X, labels_semi)

# 3. 传播后的标签
print(f"传播标签准确率: {(ls.transduction_[idx] == y[idx]).mean():.3f}")

---

19. 常见陷阱与面试 FAQ

Q1：为什么分类用交叉熵不用 MSE？

A：

• 交叉熵梯度更大（学习快）
• 凸性更好
• 概率解释自然

Q2：为什么回归用 MSE 不用 MAE？

A：

• MSE 可导，MAE 在 0 不可导
• MSE 假设高斯噪声
• MAE 对异常值更鲁棒

Q3：SGD 和 BGD 怎么选？

A：

• 大数据 → SGD / MBGD
• 小数据 → BGD / L-BFGS
• 神经网络 → AdamW

Q4：L1 vs L2 正则怎么选？

A：

• 特征稀疏 → L1
• 多重共线性 → L2
• 都不确定 → ElasticNet（L1 + L2）

Q5：学习率怎么设？

A：

• SGD：0.01-0.1
• Adam：1e-3
• 用 LR finder 找最优

Q6：Adam 一定比 SGD 好？

A：不一定。图像任务 SGD + momentum 常更好（泛化性）。NLP/Transformer 用 AdamW。

Q7：批量大小越大越好？

A：不是。64-256 是经验值。太大显存不够且泛化差（少噪声）。

Q8：训练不收敛怎么办？

A：

1. 降低学习率
2. 归一化输入
3. 简化模型
4. 检查数据（标签错误？）

Q9：怎么判断过拟合？

A：

• 训练准确率 >> 验证准确率
• 学习曲线发散
• 解决：正则化 / Dropout / 早停 / 数据增强

Q10：怎么判断欠拟合？

A：

• 训练准确率 ≈ 验证准确率（都低）
• 解决：更复杂模型 / 特征工程 / 减少正则化

Q11：ERM 和 SRM 的关系？

A：SRM = ERM + 正则。ERM 在数据足够时与 SRM 等价；数据不足时 SRM 更好。

Q12：交叉熵的物理意义？

A：用分布 q 编码 p 所需额外比特数。最小化 = 用 q 接近 p。

Q13：怎么选择优化器？

A：

任务	优化器
凸问题	L-BFGS
神经网络	AdamW
图像分类	SGD + momentum
NLP	AdamW
强化学习	Adam

Q14：为什么神经网络用反向传播？

A：链式法则 + 计算图。复杂度 O(n) 而非 O(n²)。

Q15：3 大要素哪个最重要？

A：

• 模型 决定表达上限
• 策略 决定评价尺度
• 算法 决定能学多深
  三者缺一不可，模型 + 策略 = 目标，算法 = 手段。

---

20. 参考文献

经典教材

• 李航《统计学习方法》（三要素框架原出处）
• 周志华《机器学习》（西瓜书）
• Bishop《Pattern Recognition and Machine Learning》
• Goodfellow《Deep Learning》

优化算法论文

• Robbins, H. & Monro, S. (1951). “A Stochastic Approximation Method”.
• Kingma, D. & Ba, J. (2014). “Adam: A Method for Stochastic Optimization”. ICLR.
• Loshchilov, I. & Hutter, F. (2017). “Decoupled Weight Decay Regularization”. ICLR.
• Smith, L. (2017). “Cyclical Learning Rates for Training Neural Networks”. WACV.

实战资源

• PyTorch 优化器文档
• Sebastian Ruder: “An overview of gradient descent optimization algorithms”
• Distill.pub: “Why Momentum Really Works”

---

作者注：三要素框架是李航《统计学习方法》的精髓。学任何新算法时，把它拆成"模型 + 策略 + 算法"三部分，能让你快速抓住本质。