机器学习 / 深度学习基础速通

先说清这篇写给谁：你会写代码，能调通 LLM API，但没正经上过机器学习课，一到直播讲"损失函数""梯度下降""过拟合"就有点跟不上。这篇不是让你去当算法工程师，是把这块断层补平——带数字、带两段能跑的代码，让你后面学微调、评估、RAG 时心里有底。

说实话，做 AI 应用工程，90% 的时间你不会亲手训模型。但剩下那 10%——看懂一份微调数据该长什么样、判断模型是不是"背答案"了（过拟合）、看懂一份评估报告为什么用 F1 不用 accuracy、跟数据科学同事对话不露怯——全压在这块基础上。

我自己就吃过这个亏。第一次帮客户做分类微调，对方的数据科学家问我"validation loss 收敛了吗"，我含糊了三秒，对方马上换了种口气跟我说话——像跟实习生解释一样。那三秒的含糊，本质上就是这篇要补的东西。

先给一句定心丸：这章只要求初中数学。有加减乘除和平方就够了，没有矩阵求导，放心往下读。

---

为什么 AI 工程师也要懂这个？（不懂会怎样）

• 微调那节课会让你准备"训练集/验证集"，不懂划分，你会用训练数据评估自己，得出一个虚高到离谱的分数，上线就翻车。
• 别人说这个模型"过拟合"了，你得知道那不是骂人，是"背了题库不会举一反三"。
• 一份分类模型报告写着 "accuracy 98%"，你要能一眼看出这可能是个废模型（下面会讲为什么）。
• LLM 的预训练是"自监督"，不懂监督/无监督的分法，你根本听不懂这个词妙在哪。
• 微调面板上那条 loss 曲线突然变 NaN，你要知道第一个该动的参数是什么（剧透：learning_rate）。

---

一句话：机器学习是"喂例子"，不是"写规则"

传统编程你写死规则：if 邮件含"中奖" then 垃圾邮件。规则永远写不全，骗子换个词你就漏了。

术语：机器学习 (Machine Learning, ML)

• 一句话解释：不写规则，给一堆带答案的例子，让程序自己总结规律。
• 形象比喻：教小孩认猫。你不背"猫有四条腿两只尖耳朵……"，你指着一堆图说"这是猫、这是狗"，看多了他自己会认。
• 工作中怎么用：垃圾邮件识别、推荐、风控、以及所有 LLM 的底层训练。
• 最常踩的坑：例子（数据）有偏，模型就学歪。数据里全是橘猫，它可能以为黑猫不是猫——"garbage in, garbage out"。

几个天天要用的词，一次说清：

术语：特征 (Feature) 与标签 (Label)

• 一句话解释：特征=你拿来判断的线索；标签=你想要的答案。
• 形象比喻：判断二手房价。面积、地段、楼层是特征，成交价是标签。
• 工作中怎么用：监督学习就是学"特征 → 标签"这个映射。
• 最常踩的坑：把"能间接泄露答案"的东西混进特征（数据泄漏），训练分高得吓人，上线一塌糊涂。举个真实的坑：预测用户会不会流失，结果特征里混进了"账号注销日期"——那当然百分百准，但上线时你根本没有这个字段。

---

三种学习范式：差别就在"有没有答案"

监督学习（Supervised）——最常见。给"题+答案"让它学。它又分两类：答案是类别（垃圾/正常）叫分类 (Classification)；答案是数值（房价 328 万）叫回归 (Regression)。

无监督学习（Unsupervised）——只给数据不给答案，让它自己找结构。比如把一万个用户自动分成几群（聚类），你事先根本不知道该分几群、每群是啥。

强化学习（Reinforcement）——没有标准答案，靠奖励引导。AlphaGo 下棋赢了加分。你天天用的 ChatGPT 之所以"懂事、不乱说"，背后就有一步叫 RLHF（基于人类反馈的强化学习）——人给回答打分，模型学着往"人类更喜欢"的方向走。

⚡ 划重点串起来：LLM 的预训练属于"自监督"——拿海量文本，遮住下一个词让它猜，答案就是原文里那个词，不需要人工标注就有"标准答案"。这也是为什么能拿整个互联网当训练数据。

---

神经网络怎么"学会"：拧旋钮

术语：神经网络 (Neural Network)

• 一句话解释：一堆能调参数的"数字旋钮"，层层堆起来，把输入慢慢变成输出。
• 形象比喻：一排排调音台旋钮。输入的声音经过层层旋钮，输出你要的音效——训练就是自动找到每个旋钮该拧到哪。
• 工作中怎么用：Transformer 就是一种（带注意力的）神经网络；微调就是在动这些旋钮。
• 最常踩的坑：以为它"理解"了。它只是把旋钮拧到"输入进去、输出刚好对"的位置，没有人类意义上的理解。

学习（训练）的循环，拆成人话就四步，一直转：

① 前向：数据进网络，当前旋钮下吐出一个预测
      ▼
② 算差距：预测 vs 真实答案，差多少 = 损失 (Loss)
      ▼
③ 反向：反推"每个旋钮往哪拧能让差距变小" (反向传播 Backprop)
      ▼
④ 微调旋钮：朝那个方向拧一小步 (梯度下降)
      ▼   (回到①，重复几万~几百万次)

记住这四步。后面的 PyTorch 代码里，每一步都对应一行，一一对得上。

损失函数：先得会"打分错得多离谱"

术语：损失函数 (Loss Function)

• 一句话解释：一个数，衡量"这次预测离正确答案有多远"，越小越好。
• 形象比喻：考试扣分。答得越离谱扣得越多，Loss 就是总扣分。
• 工作中怎么用：训练/微调时你会盯着 loss 曲线，它该往下走并趋平。
• 最常踩的坑：任务用错损失函数。回归任务用 MSE（均方误差），分类任务用 交叉熵 (Cross-Entropy)——LLM 预测下一个词就是个超大分类，用的正是交叉熵。

一个 MSE 的迷你算例（预测房价）：

真实价:  300 万        预测价: 280 万 → 误差 20，平方 = 400
真实价:  500 万        预测价: 520 万 → 误差 20，平方 = 400
真实价:  200 万        预测价: 260 万 → 误差 60，平方 = 3600
MSE = (400 + 400 + 3600) / 3 = 1466.7

注意第三条误差 60、平方后 3600，占了总损失的绝大头——这就是 MSE 的性格：狠狠惩罚离谱的大错。训练就是不断拧旋钮把这个数往下压。

梯度下降：蒙眼下山

术语：梯度下降 (Gradient Descent)

• 一句话解释：顺着"下坡方向"一小步步走到损失最低点的调参办法。
• 形象比喻：蒙眼下山。你感觉哪边是下坡（梯度），就往那边迈一小步，重复，直到脚下最低（Loss 最小）。
• 工作中怎么用：所有神经网络/LLM 训练都靠它；你调的 learning_rate（学习率）就是"步子多大"。
• 最常踩的坑：步子（学习率）太大，一脚跨过山谷来回震荡，loss 不降反跳；太小又慢得要死。微调时 loss 突然飙升或变 NaN，九成是学习率设太大了。

手算一遍：三步逼近正确答案

光说"往下坡走一小步"太玄。来手算一个最小的例子，你会发现整件事就是初中数学。

设定：模型只有一个旋钮 w，预测规则 预测值 = w × x。手里一条数据：x = 2, 真实值 y = 10（所以完美答案是 w = 5）。损失用平方误差，学习率 lr = 0.1。梯度公式是 2x × (wx − y)（不用管怎么推的，知道它指向"上坡"就行，我们往反方向走）：

第 1 步: w = 1.00 → 预测 2.0，差 -8.0  → 梯度 -32.0 → w 更新为 1 + 0.1×32   = 4.20
第 2 步: w = 4.20 → 预测 8.4，差 -1.6  → 梯度 -6.4  → w 更新为 4.2 + 0.64   = 4.84
第 3 步: w = 4.84 → 预测 9.68，差 -0.32 → 梯度 -1.28 → w 更新为 4.84 + 0.128 = 4.97

三步，从 1 走到 4.97，离正确答案 5 只差一点，而且越接近谷底步子自动越小（因为差距小了梯度也小了）。这就是梯度下降的全部气质。

现在把学习率从 0.1 改成 0.6，同一条数据：

第 1 步: w = 1.00  → 梯度 -32.0  → w = 1 + 0.6×32    = 20.20   (一脚跨过了 5)
第 2 步: w = 20.20 → 梯度 121.6  → w = 20.2 − 0.6×121.6 = -52.76 (甩到另一边更远)
第 3 步: w = -52.76 → 梯度继续变大 → w 直接飞向几百……

看到了吗？步子太大不是"收敛慢一点"，是彻底发散——每一步都跨过山谷甩到对面更高的地方。你以后微调看到 loss 曲线不降反升、甚至变 NaN，脑子里要浮现的就是这三行。

我的直白建议：调学习率按 10 倍为单位动（1e-3 → 1e-4 → 1e-5），不要 1e-3 调成 9e-4 这种挠痒痒式微调，浪费时间。

---

训练里天天听到的几个词

跟数据科学同事开会、或者打开任何微调面板，这几个词躲不掉。一张表过完：

区分参数和超参数有个土办法：模型自己拧的叫参数，你在配置文件里写的叫超参数。面试和日常对话里混用这俩会瞬间暴露底子。

训练 vs 推理：别把两件事混着说

还有一对词值得单独掰开：

• 训练 (Training)：拧旋钮的过程。烧 GPU、跑几小时到几个月、做一次就好。
• 推理 (Inference)：旋钮定死，只做"输入进、预测出"。你每次调 LLM API，就是在花钱买别人训好的模型做一次推理。

为什么要分清？因为成本结构完全不同：训练是一次性巨额投入（GPT 级别的预训练烧的是几千万美金量级的算力），推理是按次计费的运营成本。你做 AI 应用工程，日常打交道的 99% 是推理——这也是为什么"会用模型"和"会训模型"是两个工种。等你走到微调，才算轻量地碰了一次"训练"。

---

深度学习：为什么要"深"

深度学习 (Deep Learning) = 层数很多的神经网络。为什么堆深有用？因为每一层学一个抽象层级：

• 认脸的网络：第一层学"边缘和亮暗"，中间层拼出"眼睛、鼻子"，高层拼出"这是谁"。
• 语言模型：低层抓拼写和语法，高层抓语义和逻辑。

你不用手工设计"什么是眼睛"，网络自己从数据里逐层学出来——这叫特征自动学习，是深度学习吊打传统方法的关键。代价是：吃数据、吃算力。数据不够时，老老实实用简单模型往往更稳。

我的直白建议：手里只有几千条表格数据（预测流失、给工单分类），别碰深度学习——LogisticRegression 或梯度提升树十分钟出结果，往往还更准。图像、语音、自由文本这种"人看得懂但说不清规则"的数据，才是深度学习的主场。

一张图看懂从属关系（别再混着叫）：

人工智能 (AI)  ── 让机器干"聪明"的活，最大的圈
   └─ 机器学习 (ML)  ── 靠喂数据学规律，不写死规则
        └─ 深度学习 (DL)  ── 用很深的神经网络
             └─ Transformer / LLM  ── 你天天调的这个

顺着这个从属关系，Transformer 内部到底怎么"注意"到重点，去 Transformer 与注意力机制入门 接着看。

---

⚠️ 过拟合：AI 工程里你最该记住的一个词

术语：过拟合 (Overfitting) 与欠拟合 (Underfitting)

• 一句话解释：过拟合=把训练题背熟了、换新题就傻；欠拟合=连训练题都没学会。
• 形象比喻：过拟合是把练习册答案全背下来、月考换卷就崩的学生；欠拟合是压根没复习、平时考试也不及格的学生。
• 工作中怎么用：所以要留一份模型没见过的数据（验证/测试集）来考它，训练集上的分不算数。
• 最常踩的坑：拿训练数据评估模型 → 分高到离谱 → 上线暴跌。这是新手头号翻车点。

怎么判断？看训练分和验证分的关系：

训练分 低，验证分 低   → 欠拟合(模型太弱/没训够)  → 加大模型/多训
训练分 高，验证分 高   → 刚刚好 ✅
训练分 高，验证分 低   → 过拟合(背题了)          → 加数据/正则化/早停

处理过拟合的三板斧，按性价比排：

1. 加数据——最有效也最贵。数据翻倍，很多过拟合直接消失。
2. 早停 (Early Stopping)——盯着验证 loss，它开始回升就停，别恋战。微调时把 3 个 epoch 砍成 1 个，常常验证分反而更高。
3. 正则化 (Regularization)——给模型加"别把旋钮拧太极端"的约束（如 dropout、weight decay）。微调框架里通常有现成开关。

配套记住数据三分法（微调那节直接要用）：

数据少的时候（比如微调只有几百条），常简化成 90/10 两分：训练 + 验证。但验证集绝不能省——省掉它你就是在裸奔。

---

⚠️ accuracy 会骗你：评估指标必须懂

假设你做一个"癌症筛查"分类器，数据里 99% 的人是健康的。一个啥也不学、永远猜"健康"的傻模型，accuracy 也有 99%——但它一个病人都查不出来，是彻头彻尾的废物。这就是为什么光看 accuracy 会被骗，尤其数据不平衡时。

这不是编的段子。我见过学员拿欺诈检测模型来问我"accuracy 99.2% 为什么老板还不满意"——我让他数了数测试集里的欺诈样本被抓到几条。答案是零。他的模型学会的唯一技能，就是把所有交易都标成"正常"。

四个必须会的分类指标，用"筛查病人"来记：

Precision 和 Recall 常常此消彼长：你把"有病"的门槛调低，能抓到更多病人（Recall↑），但也会误伤更多健康人（Precision↓）。选哪个，取决于你的业务更怕漏还是更怕错。

我的直白建议：垃圾内容过滤、风控拦截这类"误杀会得罪用户"的场景压 Precision；安全审核、疾病筛查这类"漏一个就出大事"的场景压 Recall。两头都想要，就报 F1，然后接受它注定是个折中。

这套思路不只用于传统分类器——你以后给 LLM 应用做评估（答案对不对、有没有幻觉），底层逻辑一模一样，评估与质量监控 那章会直接建立在这上面。

---

上手代码：10 行训练一个真分类器

不用怕，scikit-learn 让"训练+评估"就几行，亲手跑一遍胜过看十页：

# pip install scikit-learn
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report

X, y = load_breast_cancer(return_X_y=True)     # 特征 X，标签 y(良性/恶性)

# 关键：切出模型没见过的测试集(前面讲的三分法)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42)

model = LogisticRegression(max_iter=5000)
model.fit(X_train, y_train)                     # ← 训练：内部就是在做梯度下降降 loss

# 在"没见过的数据"上评估，而不是训练集
print(classification_report(y_test, model.predict(X_test)))
# 输出里会同时给 precision / recall / f1 —— 别只看 accuracy

这段在讲什么：

1. 核心动作：加载真实乳腺癌数据，切训练/测试集，训练一个分类器，再用没见过的数据评估。
2. 先看哪里：先看 train_test_split 那行——这就是防过拟合的核心动作；再看 classification_report 输出的 precision/recall/f1。
3. 关键判断：如果你手贱把 predict(X_test) 改成 predict(X_train)，分数会更好看——但那是自欺欺人，正是新手最常犯的"用训练集自评"。

---

再进一步：15 行 PyTorch，亲眼看到"四步循环"

sklearn 把训练循环藏起来了。想真正看到前面那个"①前向→②算 loss→③反向→④拧旋钮"，PyTorch 十几行就能裸写一遍——让模型从数据里学出 y = 2x + 1 这条直线：

# pip install torch  (CPU 版就够，别去折腾 CUDA)
import torch

X = torch.linspace(0, 10, 100).reshape(-1, 1)
y = 2 * X + 1 + torch.randn(X.shape) * 0.5      # 造数据: y=2x+1 加点噪声

model = torch.nn.Linear(1, 1)                   # 整个模型就俩旋钮: w 和 b
loss_fn = torch.nn.MSELoss()                    # 回归任务 → 用 MSE
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

for epoch in range(200):
    pred = model(X)                             # ① 前向: 当前旋钮下的预测
    loss = loss_fn(pred, y)                     # ② 算差距: loss
    optimizer.zero_grad()                       #   (清掉上一轮的梯度，必写，忘了必翻车)
    loss.backward()                             # ③ 反向传播: 算每个旋钮该往哪拧
    optimizer.step()                            # ④ 梯度下降: 拧一小步

print(model.weight.item(), model.bias.item())   # 会非常接近 2 和 1

跑完你会看到 weight 逼近 2、bias 逼近 1——模型自己从带噪声的数据里把直线找了出来，没人告诉它公式。把 for 循环里那四行和前面的四步图对一下，一行对一步，训练神经网络的全部秘密就这些。7B 的 LLM 只是把"俩旋钮"换成了"70 亿个旋钮"，循环本身没变。

顺手做两个实验：把 lr=0.01 改成 lr=1.0，你会亲眼看到 loss 打印出来越来越大（就是前面手算的发散）；把 range(200) 改成 range(5)，看看训不够是什么样（欠拟合）。

---

loss 不降怎么排查：我的顺序

微调也好、跑 demo 也好，"loss 不降"是你最常见的报警。别乱试，按这个顺序查：

1. 先看形状再看数值。loss 震荡上蹿下跳 → 学习率太大，除以 10；loss 纹丝不动像条直线 → 学习率太小或数据没进去，先乘 10 试试。
2. loss 变 NaN / Inf → 几乎必是学习率太大或数据里混了脏东西（空值、爆炸的数值），先把 lr 砍 10 倍，再检查数据。
3. 做"小样本过拟合"测试——我最爱的一招：只拿 10 条数据训，模型应该能把它们背得滚瓜烂熟（训练 loss 逼近 0）。连 10 条都背不下来？别调参了，你的代码有 bug（数据没对上标签、忘了 zero_grad、loss 函数用错之类）。
4. 训练 loss 降、验证 loss 不降甚至回升 → 这不是"不收敛"，这是过拟合，回去看上面那节：加数据 / 早停 / 正则化。
5. 以上都排除 → 才轮到"模型太小/特征没信息量"这种大动干戈的结论。

这个顺序帮我省过很多个下午。大多数"模型不学习"最后都查到第 2、3 步，真正需要换模型的很少。

---

⚠️ 常见陷阱对比表

把这章所有的坑收进一张表，贴在工位上：

---

这些概念在 LLM 工作里长什么样

学完别觉得这是"传统 ML 的老古董"。你在 LLM 工程里撞见它们的频率比想象中高得多：

所以微调章节（LoRA / QLoRA / PEFT 微调原理与取舍）会默认你懂这章的一切——loss 曲线、epoch、过拟合、验证集，一个都跑不掉。

---

🔧 动手练习

1. 跑通 sklearn 那段代码（本机或 Colab 都行），然后把 test_size 从 0.2 改成 0.5，观察 classification_report 分数变化，体会"训练数据变少"的影响。再故意把 predict(X_test) 改成 predict(X_train)，看看"用训练集自评"能把分数虚高多少。
2. 跑通 PyTorch 那段代码，做两个破坏性实验：lr 改成 1.0（看 loss 发散），range(200) 改成 range(5)（看欠拟合长什么样），把两种情况下最后打印的 weight/bias 记下来对比。
3. 让 ChatGPT/Claude 出 5 个真实场景，你判断各属于监督/无监督/强化哪一种（例："给用户自动分群""预测明天销量""训练机器人走路"），再让它对答案。最后加试一题：用一句话向完全不懂技术的朋友解释"为什么 99% accuracy 的模型可能是废物"——讲不清就回来重看那节。

---

📚 小结

1. 机器学习是喂例子让程序自己找规律，不写死规则——数据有偏或泄漏，模型就废。
2. 三种范式差在"有没有答案"：监督（有）、无监督（没有，自己找结构）、强化（靠奖惩）；LLM 预训练是自监督。
3. 神经网络训练=四步循环拧旋钮（前向→算 loss→反向传播→梯度下降）；回归用 MSE、分类/LLM 用交叉熵，learning_rate 是下山的步子——太大直接发散，调整按 10 倍为单位。
4. 过拟合是头号大坑：看训练分 vs 验证分的关系判断，一定用没见过的验证/测试集评估（三分法 70/15/15）；处理三板斧是加数据、早停、正则化。
5. 别只看 accuracy——不平衡数据里它会骗人；分类要看 precision / recall / F1，按业务"更怕漏还是更怕错"来取舍——这套指标思路会原样用到 LLM 评估上。

---

相关阅读

下一步：Transformer 与注意力机制入门 →

• LoRA / QLoRA / PEFT 微调原理与取舍——这章的 loss、epoch、过拟合、验证集在微调里全要用上
• 评估与质量监控——precision/recall 思路延伸到 LLM 应用评估
• 开源权重模型与本地部署——"7B 参数"到底意味着什么，部署时见分晓
• LLM API 基础——回到应用层，把训练好的模型用起来