理解 AI，掌控未来

技术革命从来不只是技术问题——它重塑产业链、改写财富规则、重构社会秩序。

🏭 AI 产业链全景

💹 经济与社会的重塑

💰 普通人如何攫取利益？

第一层：投资——押注「一定发生」的事

不赌单一技术路线或公司——赌趋势本身。AI 渗透率只会越来越高，算力需求只会越来越大，数据只会越来越值钱。在这个前提下：

第二层：职业——成为「AI 编排者」而非「AI 操作员」

2023 年，会写 Prompt 的人是稀缺人才。2025 年，Prompt Engineering 已经不再是独立岗位——它融入了产品经理、设计师、运营的日常工作中，就像「会用 Excel」一样从简历亮点变成了默认要求。职业红利正在从「会用 AI」向「会设计 AI 工作流」迁移。

三条高确定性路径：
① AI+专业护城河：律师×AI 合同审查、医生×AI 影像辅助、教师×AI 个性化辅导。AI 放大你的专业知识，但专业知识本身仍是壁垒——AI 不会通过法考。
② AI Workflow 设计师：不是写 Prompt，是设计一整条 AI 流水线——数据从哪来、经过哪些模型、输出到哪去、中间怎么做质量把控。这需要系统思维而非单点技能，AI 暂时做不到。
③ 垂直行业 AI 化顾问：成千上万的传统中小企业需要人帮他们理解「AI 能帮我的业务做什么」——不是教他们用 ChatGPT，是帮他们找到 AI 在具体业务流中的切入点。这是未来 3-5 年最大的蓝海。

第三层：创业——抓住「还不够好」的缝隙

当前 AI 产品的共同特征：能力 80 分但体验 30 分。模型的回答质量已经很高了，但产品化的最后一公里——工作流集成、数据安全、团队协作、行业知识定制——几乎空白。这就是机会。

具体方向：① 本地私有化部署：帮律师、医生、政府机构部署本地大模型——数据不出门，但享受 AI 能力。② AI 内容/IP 产品化：AI 生图 + 3D 打印文创（你们已经在做的方向）、AI 生成个性化教育内容。③ AI 培训/咨询：帮传统企业一把手理解 AI 的战略价值——注意不是教写 Prompt，是帮他们看到「AI 怎么改变我的商业模式」。④ Agent 定制开发：为特定行业开发专用 Agent——房产中介 Agent（自动回客户 + 匹配房源 + 预约看房）、餐饮 Agent（库存预测 + 自动订货 + 差评自动回复）。

从「什么是学习」开始，逐步推导到 Transformer、LLM、Agent。重在讲清每个概念的动机（为什么需要它）、思想（怎么工作）、衔接（技术演进的逻辑线）。

零、数学速成：理解 AI 所需的最小数学工具箱

0.1 向量：AI 世界的「原子」

在 AI 中，一切都用向量表示。一个词 → 一个向量（Embedding）。一张图 → 一组向量。一段话 → 一个向量序列。向量就是一列数字，比如一个 3 维向量 v = [2, 5, 1]。每个维度代表一种「属性」——在词向量的世界里，可能第 1 维代表「性别倾向」，第 2 维代表「大小」，第 3 维代表「情感色彩」。你不必知道每个维度具体代表什么——模型自己学会的。

向量的点积衡量两个向量的「相似度」。点积越大，方向越一致。计算：v·w = v₁w₁ + v₂w₂ + ... + v_nw_n。例如 [1,2,3]·[4,5,6] = 1×4 + 2×5 + 3×6 = 4+10+18 = 32。如果两个向量完全相同，点积最大；完全相反，点积为负。

0.2 矩阵乘法：AI 的核心计算原语

神经网络中的每一层，本质上是输入向量 × 权重矩阵 = 输出向量。矩阵乘法规则：A 的列数必须等于 B 的行数。结果矩阵的第 (i,j) 位置 = A 的第 i 行 与 B 的第 j 列的点积。

一个 2×3 矩阵 乘 3×2 矩阵 = 2×2 矩阵。Transformer 的 Self-Attention 中 Q×Kᵀ 就是矩阵乘法——计算每个词与每个词的相似度。GPU 被设计成极其擅长这种运算——这就是为什么深度学习能爆发。

0.3 导数的直觉：变化有多快？

导数回答了「如果我稍微改变输入，输出会变多少」。对于 f(x)=x²，f'(x)=2x。当 x=3 时，f'(3)=6——意味着在 x=3 附近，x 每增加 0.01，f(x) 约增加 0.06。在 AI 中，导数 = 梯度 = 告诉你调整参数的方向和幅度。梯度下降就是沿着「负梯度方向」走——哪个方向让损失下降最快就往哪走。

链式法则：如果 z = g(f(x))，那么 dz/dx = g'(f(x)) × f'(x)。这是反向传播的数学基础——误差从输出层，经链式法则一层层「传」回输入层，算出每一层参数的梯度。

0.4 Softmax：把任意数字变成概率

AI 经常输出一组「分数」（logits），比如 [2.0, 1.0, 0.1]。Softmax 把它们变成概率分布（所有值在 0~1 之间，且加起来 = 1）：

对 [2.0, 1.0, 0.1]：e²=7.39, e¹=2.72, e^0.1=1.11，总和=11.22。结果：[0.66, 0.24, 0.10]——模型认为第一类的概率是 66%。Transformer 的 Attention 用 Softmax 把相似度分数变成注意力权重。

0.5 概率与统计：理解「不确定性」

AI 输出的不是「答案」，是概率分布。分类模型说「90% 概率是猫」——这个 90% 怎么来的、意味着什么，就是概率统计要回答的。

期望（Expectation）：E[X] = Σ x·P(x)。如果你玩一个游戏：80% 概率赢 100 元，20% 概率输 50 元。期望收益 = 0.8×100 + 0.2×(−50) = 70 元。模型训练中，损失的期望值越小越好。
贝叶斯定理：P(A|B) = P(B|A)·P(A) / P(B)。直观含义：在看到新证据 B 之后，你对 A 的信念如何更新。比如：已知「咳嗽的人中有 5% 是肺炎」，但你突然发烧了——发烧+咳嗽同时出现时肺炎概率大幅上升。AI 中的 Naive Bayes 分类器、贝叶斯神经网络都基于此。
交叉熵（Cross-Entropy）：衡量两个概率分布的「距离」。分类任务最常用的损失函数——真实标签是 [1,0,0]（100% 是猫），模型输出 [0.7,0.2,0.1]。交叉熵 = −(1×log0.7 + 0×log0.2 + 0×log0.1) = −log0.7 ≈ 0.36。输出越接近真实，交叉熵越小。这就是为什么分类模型用 CrossEntropyLoss。

一、Python 速成：把数学变成代码

1.1 为什么先学 Python 再学 ML？

前面学的向量、矩阵、导数——在 Python 里几乎都是一行代码。不先掌握 Python，后面的公式只能「看」不能「试」。而且 AI 招聘中 Python 是默认前提——不要求精通 C++，但必须能流畅地用 Python 操作数据和调用模型。本章聚焦于AI 场景中最常用的 Python 能力，不做百科全书。

1.2 NumPy：AI 世界的「计算器」

Python 原生的列表做不了高效数值计算。NumPy 提供了 ndarray（多维数组）——它既是向量、也是矩阵、也是 Tensor。PyTorch 的 Tensor 设计直接沿袭了 NumPy。

import numpy as np

# 向量 = 一维数组
v = np.array([2, 5, 1])
w = np.array([4, 5, 6])
dot = np.dot(v, w)        # 点积 = 2×4+5×5+1×6 = 39

# 矩阵 = 二维数组
A = np.array([[1,2,3], [4,5,6]])   # 2×3
B = np.array([[1,0], [0,1], [1,1]]) # 3×2
C = A @ B                  # 矩阵乘法 @ = 2×2 结果
print(C.shape)             # (2, 2)

# Softmax 实现（3行）
def softmax(z):
    e = np.exp(z - np.max(z))  # 减最大值防溢出
    return e / e.sum()

print(softmax(np.array([2.0, 1.0, 0.1])))  # [0.66 0.24 0.10]

1.3 必备工具链

数学计算：numpy（数组运算）、scipy（科学计算）。数据处理：pandas（DataFrame，类似 Excel）、matplotlib（画图看训练曲线）。模型：scikit-learn（传统 ML）、torch（深度学习）、transformers（HuggingFace）。环境：pip install + 虚拟环境（python -m venv ai_env）——避免项目间依赖冲突。Jupyter Notebook 适合探索，VS Code + Copilot 适合工程。

二、机器学习：从一条直线开始

2.1 一个具体例子：预测房价

假设你有 3 个房屋数据：面积 50m² → 卖 150 万；80m² → 220 万；120m² → 310 万。你想预测 100m² 的房子卖多少钱。人脑会「画一条穿过这些点的直线」——机器学习做的事完全一样，只是用数学来精确做。

我们的模型：房价 = w × 面积 + b。w 是斜率（每平米加多少钱），b 是截距（基础价）。目标：找到最好的 w 和 b，让预测值与真实值的差距最小。

这就是均方误差（MSE）——平方让大误差受到更严厉的惩罚。训练 = 不断调整 w 和 b，让 Loss 越来越小。对于这个简单问题，数学上可以直接解出最优 w≈2.29, b≈32.9。但对于上亿参数的大模型，只能靠梯度下降迭代逼近。

2.2 梯度下降：一步一步走向最优

梯度 = 损失函数对所有参数的偏导数组成的向量。它指向「损失上升最快」的方向。所以我们往反方向走：

η（学习率）是最关键的调参——太大：在山谷两侧震荡不收敛；太小：下山太慢。实际工程中常用 Adam 优化器，它自动调整每个参数的学习率，比手动调靠谱得多。每次处理一小批数据（Mini-batch，如 32 个样本）算梯度更新，称为一个 iteration。遍历完整个数据集称为一个 Epoch。

2.3 从直线到曲线：为什么需要非线性

房价和面积的关系可能不是严格的直线——60m² 以下单价高（小户型抢手），200m² 以上单价也高（豪宅溢价），中间相对便宜。一条直线（线性模型）无法捕捉这种 U 形曲线。我们需要能拟合曲线的模型——这就是神经网络要做的事。

三大学习范式：① 监督学习（有标签数据，如已知房价）——最常见；② 无监督学习（无标签，找隐藏结构，如客户分群）；③ 强化学习（与环境交互试错，如 AlphaGo）。本文后续主要讨论监督学习，因为它覆盖了 90% 的商业 AI 应用。

三、神经网络：多层 + 非线性 = 万能拟合器

3.1 一个神经元做什么？加权求和 + 激活

一个神经元接收 n 个输入 x₁...x_n，各自乘以权重 w₁...w_n，加上偏置 b，再过激活函数 σ：

具体例子：假设权重 w=[0.5, -0.3, 0.8]，偏置 b=0.1，输入 x=[2, 5, 1]，使用 ReLU 激活（σ(x)=max(0,x)）。计算：0.5×2 + (-0.3)×5 + 0.8×1 + 0.1 = 1−1.5+0.8+0.1 = 0.4。ReLU(0.4) = 0.4。如果没有激活函数（σ(x)=x），多层网络退化成一个线性变换——层数再多也没用。激活函数引入非线性，让网络能拟合任意复杂函数。

3.2 多层感知机（MLP）：堆叠出深度

单个神经元只能画一条直线（或一个超平面）。把神经元排成层，层与层之间全连接，前一层的输出作为后一层的输入——这就是多层感知机（MLP）。第 1 层提取简单模式（比如边缘），第 2 层组合成复杂特征（比如「圆形+尖耳=猫脸」），第 3 层进一步抽象……每一层都在对上一层的特征做更高阶的组合。这就是「深度」的含义——不是层数多就叫深度，是特征的抽象层级在增加。

关键认知：一个足够宽的单隐藏层网络已经可以拟合任意连续函数（万能逼近定理）。但「能拟合」和「能高效学习」是两回事——深层网络用更少的参数实现相同的表达能力，因为每一层都在复用前一层的特征，而不是从零拼凑。这就是深度学习比浅层网络好的根本原因。

3.3 反向传播：整个深度学习的发动机

有了网络结构，剩下的核心问题是：怎么让网络知道自己错在哪，并修正？答案是反向传播。

一次训练迭代分两步——前向传播和反向传播。前向传播就是数据从输入层一路流到输出层，算出预测值 ŷ。然后计算损失 Loss(ŷ, y_真实)——一个数字，衡量预测有多差。反向传播要做的是：搞清楚每个参数（W₁、W₂、W₃ 以及对应的偏置）对这个损失「贡献」了多少「责任」。

怎么算？链式法则。想象一排多米诺骨牌：推倒第一块 → 第二块倒 → 第三块倒 → 最后一块。如果你想改变最后一块倒下的速度，你需要知道每一块对下一块的影响有多大，然后反推。链式法则就是数学版的这个逻辑。

以 W₃ 为例：∂Loss/∂W₃ = ∂Loss/∂ŷ × ∂ŷ/∂h₂ × ∂h₂/∂W₃。每个因子都是可计算的（Loss 对 ŷ 的导数、ŷ 对 h₂ 的导数取决于激活函数、h₂ 对 W₃ 的导数就是上一层的输出）。算出梯度后：W₃ ← W₃ − η·∂Loss/∂W₃——往损失减小的方向挪一小步。PyTorch 的 autograd 自动完成这一切：你只写前向传播，它自动追踪所有运算并算出梯度。这是现代深度学习框架最大的便利。

3.4 常用激活函数

四、PyTorch 系统入门：现代深度学习的「操作系统」

4.1 为什么 AI 工程师招聘都要求 PyTorch？

PyTorch 不是众多框架中的一个——它是事实标准。99% 的论文开源代码用 PyTorch，HuggingFace 全系基于 PyTorch，所有大模型（Llama/Qwen/DeepSeek）的训练和推理代码都是 PyTorch。TensorFlow 已退居工业部署场景。学会 PyTorch 意味着你能看懂任何论文的开源实现、能微调任何开源模型、能在招聘中过关。

4.2 Tensor：会算梯度的多维数组

Tensor 本质是 NumPy 数组的「可自动求导版本」。创建、运算、形状操作与 NumPy 几乎一致：

import torch

# 创建 Tensor
x = torch.tensor([2.0, 5.0, 1.0])
W = torch.randn(3, 4)          # 3×4 随机矩阵
b = torch.zeros(4)              # 偏置

# 运算和 NumPy 一样
y = x @ W + b                   # 矩阵乘法 + 广播
print(y.shape)                  # torch.Size([4])

# 搬到 GPU（一行搞定）
if torch.cuda.is_available():
    x, W, b = x.cuda(), W.cuda(), b.cuda()

4.3 Autograd：自动求导——PyTorch 的核心魔法

设置 requires_grad=True 后，PyTorch 记录每一步运算。调用 .backward() 自动算出所有参数的梯度。这就是为什么你不需要手写反向传播：

# 模拟：y = w·x + b，求 ∂Loss/∂w
w = torch.tensor([2.0], requires_grad=True)
x = torch.tensor([3.0])
y = w * x                        # y = 6.0
loss = (y - 10) ** 2             # loss = (6-10)² = 16
loss.backward()                  # 自动计算梯度
print(w.grad)                    # ∂loss/∂w = 2×(6-10)×3 = -24

4.4 nn.Module：搭建网络的乐高积木

所有神经网络层的基类。定义一个模型 = 继承 nn.Module，在 __init__ 中定义层，在 forward 中定义数据流向：

import torch.nn as nn

class SimpleMLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(784, 256)   # 输入→隐藏
        self.fc2 = nn.Linear(256, 10)    # 隐藏→输出(10类)
        self.relu = nn.ReLU()

    def forward(self, x):
        x = self.relu(self.fc1(x))
        return self.fc2(x)              # 输出 logits

model = SimpleMLP()
print(model)  # 打印网络结构

4.5 训练循环：所有深度学习项目的统一模板

无论训练 CNN、Transformer 还是 GPT，训练循环的结构完全一致——理解这一个模板，你就理解了 90% 的 PyTorch 代码：

model = SimpleMLP()
criterion = nn.CrossEntropyLoss()        # 损失函数
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

for epoch in range(10):                  # 遍历数据 10 次
    for x_batch, y_batch in dataloader:  # 每次取一批
        optimizer.zero_grad()            # 清零梯度
        outputs = model(x_batch)         # 前向传播
        loss = criterion(outputs, y_batch) # 算损失
        loss.backward()                  # 反向传播
        optimizer.step()                 # 更新参数
    print(f"Epoch {epoch}, Loss: {loss.item():.4f}")

4.6 常用组件速查

五、卷积神经网络（CNN）：教会机器「看」

5.1 全连接网络为什么搞不定图像？

一张 224×224×3（RGB）的图片 = 150,528 个像素值。如果第一隐藏层有 1000 个神经元，参数量 = 150,528×1000 ≈ 1.5 亿——这只是第一层。更致命的是：全连接把像素当作孤立的数，完全无视「相邻像素更相关」这个空间结构。猫在图的左上角还是右下角，全连接根本不知道——它缺少平移不变性。

5.2 卷积操作：滑动窗口 × 逐元素乘加

卷积的核心：用一个小矩阵（卷积核/Kernel，如 3×3）在输入图像上滑动，每个位置做逐元素乘积累加。一个卷积核检测一种模式——水平边缘、垂直边缘、某种纹理。多个卷积核并行检测多种模式。

具体演算——5×5 输入与 3×3 卷积核：

第 1 步：核放在输入左上角 3×3 区域 [1,2,1; 0,1,2; 1,0,1]，逐元素乘加：1×1+2×0+1×(−1) + 0×1+1×0+2×(−1) + 1×1+0×0+1×(−1) = 1+0−1+0+0−2+1+0−1 = −2。这成为输出矩阵的 (1,1) 位置。
第 2 步：核右移一格到 [2,1,0; 1,2,3; 0,1,2]，同样计算得 −3。滑动到最右下角，最终得到一个 3×3 的输出（特征图）。输出尺寸 = 输入尺寸 − 核尺寸 + 1 = 5−3+1 = 3。

3.3 卷积的两大杀招

① 参数共享：同一个 3×3 核（仅 9 个参数）在整张图上滑动复用。无论猫在左上角还是右下角，「猫耳朵检测器」都能工作——这就是平移不变性的数学实现。② 局部连接（稀疏交互）：输出每个位置只看输入的 3×3 邻域，而非全部像素。参数量从 O(n²) 降到 O(k²)，k 是核大小。

3.4 Pooling（池化）：压缩 + 保留关键信息

卷积后特征图仍然较大，用池化降采样。最常见的 Max Pooling 2×2：把特征图按 2×2 分块，每块取最大值。

作用：① 减小尺寸 → 减少计算量；② 增大感受野（更深层能看到更大的原始图像区域）；③ 轻微平移不变性（池化后轻微位移不改变输出）。

5.5 CNN 完整结构 + 经典架构演进

关键里程碑：LeNet(1998,手写数字)→AlexNet(2012,深度学习爆发)→VGG(2014,更深更规整)→ResNet(2015,残差连接突破152层)→EfficientNet(2019,效率优先)。ResNet 的 Skip Connection（输出=F(x)+x）确保深层至少不比浅层差——这个思想后来启发了 Transformer 的残差连接。

PyTorch 实战：3 行定义一个 CNN

# 一个经典的微型 CNN（CIFAR-10 上能跑出 70%+）
class TinyCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 16, 3, padding=1)   # 3通道→16通道, 保持尺寸
        self.conv2 = nn.Conv2d(16, 32, 3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)                  # 尺寸减半
        self.fc = nn.Linear(32 * 8 * 8, 10)            # 全连接分类(10类)

    def forward(self, x):    # x: (batch, 3, 32, 32)
        x = self.pool(torch.relu(self.conv1(x)))       # → (batch,16,16,16)
        x = self.pool(torch.relu(self.conv2(x)))       # → (batch,32,8,8)
        x = x.view(x.size(0), -1)                       # 拉平 → (batch, 2048)
        return self.fc(x)                               # → (batch, 10)
# 理解了以上代码 = 理解了 CNN 的所有工程实现

六、序列模型：RNN 与 LSTM

6.1 为什么图像模型搞不定文本？

CNN 处理空间结构（相邻像素），但文本有时序依赖：「我昨天去了___，买了很多东西」——空白处填「超市」还是「医院」取决于前面「去了」和后面「买东西」。模型需要记住上文并理解顺序。

6.2 RNN：带循环连接的网络

RNN 在每个时间步做两件事：① 读取当前输入 x_t；② 结合上一时刻的隐藏状态 h_t-1（记忆），产生新的隐藏状态 h_t：

h_t 是整个历史 x₁...x_t 的压缩表示。像边看书边记笔记——每读一句更新笔记。但致命问题：序列长时，反向传播的梯度需要连乘很多次。如果乘数 < 1，梯度指数衰减到 0（梯度消失——第 1 个词对第 100 个词几乎无影响）。

6.3 LSTM：用门控机制控制记忆流

LSTM 引入三个「门」（都是 Sigmoid 函数，输出 0~1，控制信息通过比例）和一个独立的「细胞状态」C_t（高速公路——关键信息可以几乎无损地跨越很长距离）：

LSTM 统治 NLP 近二十年（1997-2017）。但它的根本问题不是「记忆好不好」，而是处理方式串行——必须按顺序一个词一个词读，无法并行。GPU 的大量核心闲置。这就引出了 Transformer。

PyTorch 实战：3 行定义一个 LSTM

# LSTM 在 PyTorch 里是一个现成的模块
lstm = nn.LSTM(input_size=256, hidden_size=512, num_layers=2, batch_first=True)
# input:  (batch, seq_len, 256) → input_size 对应词向量维度
# output: (batch, seq_len, 512) → 每个时间步都输出隐藏状态
# hn, cn: (2, batch, 512)      → 最后一层的最终隐藏状态和细胞状态

# 完整情感分类示例
class SentimentRNN(nn.Module):
    def __init__(self, vocab_size, embed_dim, hidden_dim, num_classes):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        self.lstm = nn.LSTM(embed_dim, hidden_dim, batch_first=True)
        self.fc = nn.Linear(hidden_dim, num_classes)
    def forward(self, x):
        x = self.embedding(x)
        _, (hn, _) = self.lstm(x)        # 只取最后隐藏状态
        return self.fc(hn[-1])            # 用最后一层做分类

七、Transformer：用注意力取代循环

7.1 核心思想：让每个词同时「看到」所有词

RNN：读「猫 追 老鼠 ， 它 跑 得 很快」→ 第 7 个词「它」要和第 1 个词「猫」建立联系，信息需要跨越 6 步。Transformer：所有 8 个词之间直接建立联系，信息距离恒为 1。Self-Attention 就是实现这个「全连接信息交换」的机制。

7.2 Self-Attention 的完整计算过程

输入：n 个词的向量（每个 d 维）。第 1 步：每个词通过三个不同的权重矩阵 W_Q、W_K、W_V 生成 Query、Key、Value 三个向量。第 2 步：用 Q 和 K 计算注意力分数矩阵：

Q_i（词 i 的 Query）与 K_j（词 j 的 Key）做点积——衡量「词 i 对词 j 有多关注」。除以 √d_k 是缩放因子：d_k 太大时点积会很大，导致 Softmax 梯度消失。

具体示例——句子「猫 追 老鼠」（d_k=4，缩放因子=2）：

每行是一个词对所有词的注意力分布（和为 1）。对角线最大——每个词最关注自己（这合理，自己的信息最重要）。注意「追」对「猫」和「老鼠」都有较高关注——因为动词需要主语和宾语的信息。

最后一步：用注意力权重对 Value 加权求和——每个词的输出 = 所有词 Value 的加权混合。

7.3 Multi-Head Attention + Positional Encoding

Multi-Head：并行运行 8 组独立的 Q/K/V 投影，每组关注不同层面——头 1 关注语法结构（主谓宾），头 2 关注语义指代（代词→名词），头 3 关注位置关系（相邻词）。所有头的输出拼接后做一次线性变换。就像多个专家从不同角度分析同一句话。
Positional Encoding：Self-Attention 不管词序——「猫追老鼠」和「老鼠追猫」有相同的注意力分数。所以需要用正弦/余弦函数为每个位置生成唯一编码，直接加到词向量上。

7.4 Transformer 架构总览

GPT 只用了 Decoder（自回归，逐词生成），BERT 只用了 Encoder（双向理解）。现代大模型大多走 GPT 路线——因为「生成」被证明是更通用的能力。

PyTorch 实战：从头写 Scaled Dot-Product Attention

import torch.nn.functional as F

def scaled_dot_product_attention(Q, K, V, mask=None):
    """Q,K,V: (batch, heads, seq_len, d_k)"""
    d_k = Q.size(-1)
    scores = Q @ K.transpose(-2, -1) / (d_k ** 0.5)   # 缩放的矩阵乘法
    if mask is not None:
        scores = scores.masked_fill(mask == 0, -1e9)   # 屏蔽未来词
    attn = F.softmax(scores, dim=-1)                    # Softmax 转概率
    return attn @ V                                      # 加权求和

# 这就是 Attention Is All You Need 的核心——不到 10 行。

八、预训练时代：BERT、GPT 与 Scaling Law

8.1 预训练的核心逻辑

2018 年前：每个 NLP 任务单独收集标注数据、从头训练模型——数据贵、模型弱。预训练范式：先在海量无标注文本（整个维基百科 + 书籍 + 网页）上训练一个通才模型，再针对具体任务微调。就像先博览群书打基础，再针对特定考试突击——效率天差地别。

8.2 两条路线：BERT vs GPT

GPT 路线最终胜出——因为「能生成」意味着理解了（理解了才能输出），而且自回归本质让它可以处理任意任务（只需换 Prompt，不改结构）。

8.3 Scaling Law 与涌现

OpenAI 2020 年发现：模型性能与参数量/数据量/计算量呈幂律关系（对数坐标上是一条直线）——花钱就能可靠预测性能提升。GPT-1 (1.17亿)→GPT-2 (15亿)→GPT-3 (1750亿)→GPT-4 (~1.8万亿)。每次扩大规模，不仅原有能力变强，还会涌现出小模型完全不具备的能力——思维链推理、上下文学习、代码生成——这些能力并没有被专门训练，是规模超过临界点后自发出现的。

九、大模型技术栈：Prompt、RAG、微调、RLHF

9.1 Prompt Engineering——不是玄学，是工程

LLM 不是搜索引擎——你提问的方式直接决定回答质量。想想你和一个知识渊博但缺乏背景信息的同事说话：如果你说「帮我看这个」，他不知道你在说什么；如果你说「你是一位经验丰富的 Python 后端工程师，请审查以下代码的安全漏洞，按严重程度排序」，他能给出高质量回答。Prompt 就是在给 LLM 补上下文。

核心技巧：角色设定（缩小 LLM 的行为空间——「你是一位医生」vs「你是 AI」会得到完全不同的回答风格）、Few-shot（给 2-3 个示例——人类也是这么学新格式的）、Chain-of-Thought（「一步步思考」——强制模型在给出最终答案前先输出推理过程，准确率大幅提升）、结构化输出（指定 JSON 格式——让下游代码能消费）。基本功：理解 token 不是字（一个中文字≈1.5 token，一个英文单词≈1.3 token），上下文窗口（GPT-4 的 128k ≈ 一本中篇小说，Claude 的 200k ≈ 《三体》第一本），以及窗口满了以后「中间的内容被遗忘」的诡异现象。

9.2 RAG——让 LLM 的回答有据可依

Prompt Engineering 解决的是「怎么问」，但没解决两个硬伤：① LLM 的知识停在训练截止日——你问它 2025 年的事，它只能猜；② LLM 会「幻觉」——自信地编造不存在的论文、虚构的法律条文、捏造的历史事件。这些不是 bug，是自回归模型的固有属性——它被训练来预测下一个 token，不是判断事实。

RAG 的解法：用户提问 → 从外部知识库检索相关文档 → 把所有文档拼进 Prompt → LLM 基于「现在你看到了这些资料」来生成回答。关键是：不是让 LLM 记住知识，是让 LLM 在使用知识的那一刻「看到」它。 就像开卷考试——不需要背，但需要知道怎么翻书和怎么用翻到的内容。

RAG 比微调的关键优势：便宜（更新文档即可，不需要重新训练）、可追溯（告诉用户「这句话来自文档 X 第 3 段」）、热更新（知识库加一篇新文章，立即生效）。关键调参：chunk size——太大检索不准（混杂无关内容），太小丢失上下文（「他」指代谁看不到了）。Embedding 模型选择——OpenAI 的 text-embedding-3、BGE、Jina 各有优劣。检索策略——纯语义检索可能漏掉精确关键词（「2025年GDP增长率」这种查询需要 BM25 关键字匹配辅助），理想做法是混合检索 + Rerank 精排。

一句话决策框架：知识经常更新 → RAG。需要学风格/格式/推理方式（比如用你的语气写邮件、按你的风格写代码）→ 微调。两者不互斥——可以先微调让模型学会你的风格，再用 RAG 注入最新事实。

9.3 LoRA 微调——个人也能玩大模型

全量微调千亿参数不切实际——需要几百 GB 显存、几十万条数据、数万美元算力。LoRA（Low-Rank Adaptation）的巧思来自一个数学直觉：模型在下游任务上需要调整的「变化量」ΔW 通常是低秩的——意味着可以用两个小矩阵 A×B 来近似这个大变化量。冻结原有权重 W，只训练 A 和 B。前向传播变成 h = Wx + BAx。训练量降为原来的千分之一（比如 7B 模型只需训练几十 MB 的参数），推理时 BA 可合并回 W 不增加延迟。

这意味着什么：你可以在 RTX 4090（消费级显卡，约 1.5 万元）上微调 Llama-3-8B，用你自己的 1000 条对话数据训练一个具有你个人风格的助手。这在 2023 年之前是无法想象的。LoRA 让「自己训练模型」从一个组织级任务变成了个人项目。

9.4 RLHF——让模型「对齐」人类偏好

预训练模型什么都会说，但不一定让人满意——它可能给出危险建议、使用不礼貌的语气、或回避本应直面的问题。问题根源：预训练的目标是「预测下一个 token」，不是「让人类满意」。RLHF（Reinforcement Learning from Human Feedback）就是弥补这个 GAP 的。

具体怎么做：① 收集人类标注——给标注员看同一个 Prompt 的多个回答，让他们排序「哪个更好」；② 用这些排序数据训练一个「奖励模型」——输入 (Prompt, 回答)，输出一个分数；③ 用强化学习（PPO 算法）微调 LLM，让它生成的回答获得高奖励分。ChatGPT 相对于 GPT-3 的惊艳提升，RLHF 贡献了绝大部分。

深层含义：RLHF 本质上是在用人类价值观「蒸馏」进模型。这个过程决定了模型的政治倾向、道德边界、幽默风格。OpenAI 的模型回答审慎（甚至保守）、Claude 更强调伦理——这些差异主要来自 RLHF 阶段，而非预训练数据。如果你以后做模型产品，RLHF 是你塑造「模型性格」的核心手段。

十、AI Agent：从「回答」到「执行」

10.1 LLM 的局限与 Agent 的突破

GPT-4 能告诉你如何订机票，但它不能自己订——被关在对话框里。Agent = LLM（大脑）+ 工具（手）+ 记忆（经验）+ 规划（思考链）。从「顾问」升级为「执行者」。

10.2 Agent 工作循环

核心是 ReAct 模式（Reasoning + Acting）：Think → Act → Observe → Think → ... 循环直到目标达成。代表性项目：AutoGPT（首个爆火开源 Agent）→ CrewAI（多 Agent 协作）→ CoPaw（Agent 操作系统）→ Devin（AI 软件工程师）→ Manus（通用 Agent 走向消费者）。趋势：2023=LLM 年，2024-2025=Agent 年。

十一、Codex 与 AI 编程

程序员角色从「写代码的人」→「定义需求 + 审查 AI 输出 + 设计架构的人」。贬值：语法记忆。升值：系统设计、需求理解、代码审查。

十二、LangChain（🦞龙虾）

Lang→龙，Chain→虾（中文圈谐音梗）。LLM 应用开发的乐高式框架——把 LLM 调用、工具使用、记忆管理、RAG 串联成工作流。

LangGraph 是其进化版——用有向图取代线性链，支持循环、分支、并行、多 Agent。竞品：LlamaIndex（偏 RAG）、Semantic Kernel（微软/.NET）、DSPy（斯坦福/声明式）。

按字母序排列，覆盖全文所有关键术语。Ctrl+F 或滚动查找。

Agent

LLM + 工具 + 记忆 + 规划的自主执行系统，能从「回答」升级为「执行」

Attention (注意力)

让模型在处理一个词时动态关注其他相关词的机制，Transformer 的核心

Autograd

PyTorch 的自动求导引擎——记录每一步运算，自动算出所有参数梯度

Backpropagation (反向传播)

用链式法则从输出层向输入层逐层计算梯度，深度学习训练的核心算法

Batch Normalization (BN)

对每层输入做标准化，稳定训练、允许更高学习率

Bayes' Theorem (贝叶斯定理)

P(A|B) = P(B|A)·P(A)/P(B)——描述如何根据新证据更新信念

Chain-of-Thought (CoT, 思维链)

让 LLM 在给出最终答案前先输出中间推理步骤，显著提高复杂问题准确率

CNN (卷积神经网络)

用卷积核在图像上滑动提取局部特征，擅长图像识别

Convolution (卷积)

小矩阵（核）在输入上滑动做逐元素乘加，检测特定模式（边缘/纹理）

Cross-Entropy (交叉熵)

衡量两个概率分布差异的指标，分类任务默认损失函数

DataLoader

PyTorch 批量加载数据的工具，支持打乱、多线程预取

Dropout

训练时随机丢弃部分神经元，防止过拟合

Embedding

把离散符号（词/ID）映射到稠密向量，语义相近的词向量也相近

Encoder-Decoder

编码器提取输入表示，解码器生成输出序列——Transformer 的架构骨架

Epoch

遍历完整个训练集一次

Fine-tuning (微调)

在预训练模型基础上用下游任务数据继续训练，适配特定场景

Gradient (梯度)

损失函数对各参数偏导数组成的向量——指向损失上升最快的方向

Gradient Descent (梯度下降)

沿梯度反方向更新参数，逐步逼近损失最小值

GPU

图形处理器，擅长大规模并行矩阵运算——深度学习算力基础

Hallucination (幻觉)

LLM 自信地生成看似合理但事实错误的内容

HuggingFace

AI 模型「应用商店」——开源模型、数据集、训练工具的集中平台

Hyperparameter (超参数)

训练前由人设定的参数——学习率、层数、隐藏维度、batch size 等

Inference (推理)

训练完成后用模型对新数据做预测，不更新参数

LangChain

LLM 应用开发框架——链式串联 LLM 调用、工具、RAG、记忆

Learning Rate (η, 学习率)

梯度下降的步长——太大震荡，太小太慢

LLM (大语言模型)

在超大文本语料上训练的 Transformer 模型——GPT、Claude、Llama 等

Logits

模型最后一层输出的原始分数（未经 Softmax 转换）

LoRA (Low-Rank Adaptation)

冻结原权重、添加低秩可训练矩阵的微调方法——大幅降低训练成本

Loss Function (损失函数)

衡量模型预测与真实值差距的函数——MSE（回归）、Cross-Entropy（分类）

LSTM (长短期记忆)

RNN 升级版——用门控机制控制信息流，缓解梯度消失

MLP (多层感知机)

由多层全连接 + 激活函数组成的神经网络，最基础的形式

Multi-Head Attention

并行运行多组独立的 Q/K/V 投影，每组关注不同信息层面

NumPy

Python 数值计算库——ndarray 是 AI 数据结构的基石

Overfitting (过拟合)

模型对训练数据记得太死，泛化到新数据时表现差

Parameters (参数)

模型中学到的权重和偏置——w 和 b

Pooling (池化)

对特征图降采样——MaxPool 取区域内最大值，减小尺寸、增大感受野

Positional Encoding

为每个词位置注入唯一编码信号，解决 Self-Attention 不感知顺序的问题

Pre-training (预训练)

在海量无标注数据上先训练通才模型，再针对具体任务微调

Prompt Engineering

精心设计输入提示以引导 LLM 产生期望输出的工程技术

PyTorch

深度学习框架事实标准——Tensor + Autograd + nn.Module

RAG (检索增强生成)

检索外部文档→拼入 Prompt→LLM 生成——让 LLM 能回答训练数据外的问题

ReAct

Reasoning + Acting 循环——Agent 的核心工作模式

ReLU

max(0,x)——最常用的激活函数，正区间梯度=1，计算极快

ResNet (残差网络)

引入 Skip Connection（输出=F(x)+x），让深层网络至少不比浅层差

RLHF (人类反馈强化学习)

用人类偏好训练奖励模型，再用强化学习对齐 LLM 输出

RNN (循环神经网络)

带循环连接的序列模型——每个时间步结合当前输入和上一时刻隐藏状态

Scaling Law

模型性能与参数量/数据量/计算量呈幂律关系——可预测性能提升

Self-Attention

序列中每个词同时关注所有词（包括自己），信息距离恒为 1

Softmax

把任意实数向量映射为概率分布（各项>0，和为1）

Tensor

多维数组的统称——标量(0维)→向量(1维)→矩阵(2维)→更高维

Tokenizer

把原始文本切分成 token（词/子词），再映射为整数 ID

Training Loop (训练循环)

forward→loss→backward→optimizer.step() 的四步循环

Transformer

完全基于 Attention 的架构——2017 年提出，此后几乎统治了所有 NLP/AI 任务

Vanishing Gradient (梯度消失)

反向传播时梯度指数衰减——深层几乎学不到任何东西

Vector Database (向量数据库)

存储和检索高维向量的专用数据库——RAG 的检索后端

面向非 CS 科班出身、但能借助 Agent 和 AI 工具解决实际问题、甚至直接上手深度学习的人。不需要成为数学博士——但需要知道「什么工具解决什么问题」以及「出现问题时往哪个方向排查」。

📍 第一阶段：地基能力（所有方向都需要的）

📍 第二阶段：AI 核心能力（能干活了）

📍 第三阶段：深度学习入门（能训练模型了）

📍 第四阶段：生产化与进阶

🧰 核心工具栈速查

⚡ 非科班选手的独特优势