第7章 AI 核心要素：产品经理的算法与算力课

很多产品经理一听"算法"两个字就条件反射地想跑，觉得那是工程师的地盘，自己不需要懂。

但我在大厂做了四年开发，后来转产品，最大的体会是：不懂算法的产品经理，和不懂业务的工程师一样危险。你不懂算法，就没法评估需求的技术可行性，没法和开发团队有效沟通，没法做出合理的成本预估，甚至没法判断竞品的技术优势到底在哪。

这章不是让你去写代码，而是让你具备"算法素养"——知道背后的原理是什么，知道各种技术的边界在哪，知道该用什么不该用什么。就像你不需要会造发动机，但你得懂发动机的工作原理，才能判断一辆车到底好不好。

我是怕浪猫，这章咱们从算法原理一路聊到算力成本，最后还补一课产品基本功——因为很多做AI产品的人，基本功反而最差。

7.1 算法原理：从机器学习到大模型

7.1.1 人工智能主流理论流派

人工智能不是一条路走到今天的，而是几条路并行发展、相互碰撞、最终融合的结果。了解这些流派，你才能理解为什么今天的AI是这样的形态，以及未来可能往哪个方向走。

符号主义（Symbolism）

这是最早的人工智能流派，核心思想是：智能的本质是对符号的逻辑操作。人脑思考就是做逻辑推理，那机器也可以用逻辑规则来模拟思考。

符号主义的代表作是专家系统。上世纪80年代很火，比如医疗诊断专家系统MYCIN，它用一系列"如果...那么..."规则来判断病人可能得了什么病。听起来很合理，但问题在于：现实世界的知识太复杂了，你根本不可能把所有规则都写出来。写了一万条规则，第十一万条怎么办？而且很多知识本身就不是规则化的，比如"这幅画好不好看"——你没法用规则描述审美。

符号主义在2010年之后基本退出了主流舞台，但它的遗产还在。今天的知识图谱、规则引擎、逻辑推理模块，本质上都是符号主义的思路。在大模型时代，有人提出"神经符号融合"——让大模型做模糊的感知和生成，让符号系统做精确的推理和验证。这个方向值得关注。

连接主义（Connectionism）

连接主义的核心思想是：智能来自大量简单单元的连接和交互。人脑有860亿个神经元，每个神经元很简单，但它们连接起来就能产生复杂的智能行为。所以我们应该模拟这种连接结构。

连接主义就是今天深度学习的基础。神经网络、反向传播、卷积网络、Transformer——这些全部都是连接主义的产物。可以说，今天你看到的所有AI突破，从图像识别到语音合成到大语言模型，底层都是连接主义。

连接主义曾经被符号主义压制了很长时间。上世纪60年代到80年代，神经网络研究几乎停滞，因为当时的算力根本不足以训练足够大的网络。到了2000年代，GPU的出现让连接主义重新崛起，2012年AlexNet在ImageNet比赛中的突破性表现标志着连接主义的全面胜利。

行为主义（Behaviorism）

行为主义的核心思想是：智能不需要理解内部机制，只需要对外部刺激做出正确的响应。就像进化论——生物不需要"理解"环境，只需要适应环境。智能是在与环境的交互中涌现的。

行为主义的代表作是强化学习。AlphaGo就是强化学习的经典应用——它不需要理解围棋的"策略"，只需要通过大量自我对弈来学习什么样的动作能赢。自动驾驶也大量使用强化学习——车不需要"理解"交通规则，只需要学会在各种场景下做出安全的动作。

行为主义在今天的地位不如连接主义，但在特定领域（机器人控制、游戏AI、决策优化）仍然是主流。

流派对比

流派	核心思想	代表技术	优势	局限
符号主义	逻辑推理	专家系统、知识图谱	可解释、精确	知识难以穷尽
连接主义	神经连接	深度学习、Transformer	学习能力强	不可解释、需要大量数据
行为主义	交互适应	强化学习	能解决决策问题	需要大量试错、难以迁移

今天的AI主流是连接主义主导，行为主义辅助，符号主义在边缘但正在被重新关注。大模型的"涌现能力"是连接主义的巅峰体现——你不需要显式地教模型做推理，只要网络足够大、数据足够多，推理能力自己就出来了。但这种涌现也带来了不可解释性，这正是符号主义可以补充的地方。

产品经理理解这些流派的意义在于：当你评估一个AI需求时，你应该知道它更适合用哪种方法来解决。需要精确推理的（比如法律条文分析），符号主义可能更合适；需要感知和生成的（比如图像生成、文本创作），连接主义是首选；需要决策优化的（比如资源调度），行为主义更有优势。现实中往往是混合方案。

7.1.2 机器学习与神经网络基本原理

机器学习是连接主义的具体实现方式。它的核心逻辑非常简单：给机器大量数据，让它自己从中找出规律，而不是人工编写规则。

三种学习范式

监督学习：给模型标注好的数据，告诉它"这是猫""这是狗"，让它学会区分。就像老师带着答案教学生做题。绝大多数实际应用都是监督学习——图像分类、文本分类、语音识别，都需要标注数据。

无监督学习：给模型数据但不给标签，让它自己发现数据中的结构。就像给学生一堆题目但没有答案，让他们自己归纳规律。聚类是最典型的无监督学习——把相似的数据自动分组。推荐系统中经常用无监督学习来发现用户群体。

强化学习：不给模型数据，而是给它一个环境和一个目标，让它通过试错来学习。就像学生通过不断做题和看分数来调整学习策略。前面说的AlphaGo就是强化学习。

学习范式	输入	适用场景	数据需求
监督学习	标注数据	分类、预测	需要大量标注
无监督学习	无标注数据	聚类、降维	只需原始数据
强化学习	环境+奖励	决策、控制	不需要数据但需要试错

神经网络的基本结构

神经网络是机器学习中最重要的模型形式。理解它的基本结构，是理解所有后续技术的基础。

一个最简单的神经网络（叫前馈神经网络）是这样的：

输入层 → 隐藏层 → 输出层

每一层由多个"神经元"组成。每个神经元做的事情很简单：把输入乘以权重，加起来，再通过一个激活函数输出。

用代码表示：

python

# 一个神经元的计算过程
def neuron(inputs, weights, bias, activation):
    # 1. 加权求和
    z = sum(x * w for x, w in zip(inputs, weights)) + bias
    # 2. 通过激活函数
    output = activation(z)
    return output

# 激活函数示例：ReLU（最常用的激活函数）
def relu(z):
    return max(0, z)

# 示例：3个输入的神经元
inputs = [0.5, 0.3, 0.8]
weights = [0.2, -0.5, 0.1]
bias = 0.1
output = neuron(inputs, weights, bias, relu)
# output = relu(0.5*0.2 + 0.3*(-0.5) + 0.8*0.1 + 0.1)
# = relu(0.1 - 0.15 + 0.08 + 0.1) = relu(0.13) = 0.13

就这么简单。一个神经元就是加权求和再过个激活函数。但当你把几百万个这样的神经元连接在一起，组成几十层的网络，就能产生极其复杂的能力。

训练过程：反向传播

神经网络怎么学习？通过"反向传播"算法。

流程是这样的：

正向传播：输入数据，网络计算出预测结果
计算损失：预测结果和真实标签之间的差距
反向传播：从输出层往回，逐层计算每个权重对损失的贡献
更新权重：根据贡献调整每个权重，让下次预测更准确

这个过程反复进行数百万次，网络的预测就会越来越准确。

python

# 简化的训练循环
for epoch in range(num_epochs):
    # 1. 正向传播
    predictions = model(inputs)
    
    # 2. 计算损失
    loss = loss_function(predictions, true_labels)
    
    # 3. 反向传播（计算梯度）
    gradients = compute_gradients(loss, model.parameters)
    
    # 4. 更新权重
    model.parameters -= learning_rate * gradients

产品经理不需要会写这些代码，但需要理解几个关键概念：

损失函数：衡量模型预测有多差的指标。训练的目标就是让损失尽可能小。不同任务用不同的损失函数——分类任务用交叉熵，回归任务用MSE。

学习率：每次更新权重的幅度。太大容易震荡，太小收敛慢。调学习率是训练模型最重要的超参数之一。

过拟合：模型在训练数据上表现很好，但在新数据上表现差。就像学生把考试题背下来但不理解原理，换套题就不会了。防止过拟合的方法：增加数据量、使用正则化、早停（训练到一定程度就停止）。

欠拟合：模型连训练数据都学不好。就像学生根本没学到知识。原因通常是模型太小或训练不够。

问题	表现	原因	解决方法
过拟合	训练好但测试差	模型太复杂/数据太少	加数据、正则化、简化模型
欠拟合	训练和测试都差	模型太简单/训练不够	加大模型、加训练轮数

理解过拟合和欠拟合对产品经理特别重要。当你的团队报告"模型准确率98%"时，你应该问的第一个问题就是：这是训练集还是测试集的准确率？如果是训练集，很可能就是过拟合，实际效果远达不到98%。

7.1.3 深度学习简介：AI 能力爆发的引擎

深度学习就是"很深的"神经网络。这里的"深"指的是隐藏层的数量——从几层增加到几十层甚至上百层。

为什么加深网络就能带来质变？直觉上很好理解：浅层网络只能学习简单的模式，深层网络可以学习层次化的模式。比如图像识别：第一层学边缘，第二层把边缘组合成形状，第三层把形状组合成物体部件，第四层把部件组合成完整物体。每一层都在上一层的基础上构建更抽象的表示。

深度学习的三波浪潮

第一波（2012-2015）：CNN时代。AlexNet在2012年ImageNet比赛中将错误率从26%降到15%，证明了深度神经网络+GPU的威力。之后VGGNet、ResNet不断刷新记录，图像识别从此不再是难题。

第二波（2016-2019）：RNN和序列模型时代。语音识别、机器翻译、文本生成开始突破。2016年AlphaGo击败李世石，标志着强化学习+深度学习的组合威力。2017年Transformer论文发表，但当时还没引起广泛关注。

第三波（2020至今）：大模型时代。GPT系列、BERT、DALL-E、Stable Diffusion——这些模型的参数量从百万级增长到千亿级，能力从单一任务扩展到通用任务。2022年ChatGPT发布是第三波浪潮的标志性事件。

为什么前两波没有产生如此广泛的影响？因为前两波的模型都是"窄域专家"——一个模型只能做一件事，换个任务就得重新训练。大模型打破了这个限制：一个模型可以做很多事，而且做得都不差。这才是真正改变产品形态的关键。

深度学习 vs 传统机器学习

维度	传统机器学习	深度学习
特征提取	需要人工设计特征	自动学习特征
数据量需求	小数据也能用	需要大量数据
算力需求	低	高
模型可解释性	较好	差
适用任务	结构化数据、简单模式	非结构化数据、复杂模式
迁移能力	弱	强（预训练+微调）

产品经理的选择依据：如果你的数据是结构化的（表格数据），特征清晰，数据量不大，传统机器学习（比如随机森林、XGBoost）往往比深度学习更合适——更快、更便宜、更可解释。如果你的数据是非结构化的（图像、文本、音频），或者模式很复杂，深度学习是更好的选择。

别觉得深度学习就一定比传统方法好。很多AI产品失败的原因就是：明明用简单的模型就能解决的问题，非要搞深度学习，结果成本高、效果差、还不可解释。

7.1.4 视觉模型：CNN 卷积神经网络

卷积神经网络（CNN）是处理图像最有效的神经网络结构。理解CNN，你就理解了所有AI视觉产品背后的核心算法。

CNN的核心创新：卷积操作

传统神经网络处理图像的方式是：把图像的每个像素都作为一个输入。一张224x224的彩色图片有150528个像素，那就需要150528个输入。这意味着第一层的权重数量巨大，训练困难，而且完全忽略了图像的空间结构——相邻像素之间的关系被丢弃了。

卷积操作解决了这个问题。它的思路是：用一个小的"滤镜"（叫卷积核）在图像上滑动，每次只看一小块区域，提取局部特征。

python

# 卷积操作的简化示意
# 卷积核大小：3x3
# 在图像上滑动，每次计算一个局部区域的加权求和

kernel = [
    [1, 0, -1],
    [1, 0, -1],
    [1, 0, -1]
]  # 这个核可以检测垂直边缘

image_patch = [
    [255, 240, 200],
    [255, 240, 200],
    [255, 240, 200]
]

# 卷积计算：对应位置相乘再求和
conv_result = sum(
    image_patch[i][j] * kernel[i][j]
    for i in range(3) for j in range(3)
)
# = 255*1 + 240*0 + 200*(-1) + 255*1 + 240*0 + 200*(-1) + 255*1 + 240*0 + 200*(-1)
# = 255 - 200 + 255 - 200 + 255 - 200 = 165

不同的卷积核可以提取不同的特征：边缘、纹理、形状。CNN在训练中自动学习这些卷积核——不需要人工设计。

CNN的完整结构

一个典型的CNN由几种层交替堆叠组成：

卷积层：提取局部特征
池化层：降低特征维度（最大池化就是取一小块中最大的值）
卷积层：提取更高层特征
池化层：继续降维
全连接层：把提取的特征映射到最终输出

早期层提取低级特征（边缘、角点），中间层提取中级特征（纹理、形状），后期层提取高级特征（物体部件、整体物体）。

CNN的重要变体

模型	年份	创新点	影响
AlexNet	2012	8层CNN+GPU训练	开启深度学习时代
VGGNet	2014	用小卷积核堆叠代替大卷积核	证明"更深就是更好"
ResNet	2015	残差连接（跳层连接）	解决深层网络训练退化问题
EfficientNet	2019	系统化缩放（宽度、深度、分辨率同时调整）	用更少参数达到更高精度

ResNet的残差连接是特别值得理解的创新。之前人们发现：网络越深，训练越难，甚至比浅层网络效果更差。这看起来不合理——更复杂的模型应该至少不比简单模型差。ResNet用一个简单的方法解决了这个问题：加一条"捷径"，让信号可以跳过某些层直接传递。

python

# 残差连接的核心思想
# 普通层：output = activation(conv(x))
# 残差层：output = activation(conv(x) + x)  # 加上了原始输入x

def residual_block(x, conv_weights):
    # 常规卷积路径
    conv_output = conv(x, conv_weights)
    # 残差连接：把原始输入加回来
    return activation(conv_output + x)

这个看似简单的改动解决了深层网络的训练难题，让网络可以做到上百层甚至上千层。ResNet的思想后来被广泛借鉴——Transformer中的残差连接也是同样的思路。

CNN在产品中的应用场景

场景	应用	代表产品
图像分类	识别图中是什么	Google Photos分类
目标检测	识别图中物体的位置和类别	自动驾驶感知
人脸识别	检测和识别人脸	FaceID、门禁系统
医学影像	检测病变区域	AI辅助诊断
OCR	把图片中的文字转为文本	扫描文档识别

产品经理需要知道的CNN边界：

CNN擅长识别已有类别的物体，但不擅长理解图像的语义关系（"猫坐在桌子上面"这种空间关系CNN处理不好）
CNN需要大量标注数据来训练，数据不够效果会很差
CNN对图像的旋转、缩放有一定鲁棒性，但极端变形还是会认不出来

7.1.5 序列问题：RNN 循环神经网络

不是所有数据都是图像那样的"空间结构"。语言、语音、股票价格——这些数据是"时间结构"的，一个元素接着一个元素，前后有关联。处理这类序列数据，需要不同的网络结构。

RNN的核心思想：记忆

循环神经网络（RNN）的核心创新是：网络有"记忆"。每个神经元不仅接收当前输入，还接收上一时刻的自己输出的状态。这样网络就能记住之前看过什么，结合当前输入来做出判断。

python

# RNN的计算过程
def rnn_step(current_input, previous_hidden_state, weights):
    # 把当前输入和上一步的记忆结合起来
    new_hidden = activation(
        weights_input * current_input + 
        weights_hidden * previous_hidden_state
    )
    # 输出基于当前记忆
    output = weights_output * new_hidden
    return output, new_hidden

# 处理一个序列：逐个元素处理，每步更新记忆
hidden_state = initial_state
for input_element in sequence:
    output, hidden_state = rnn_step(input_element, hidden_state, weights)

这个结构看起来很合理，但在实践中遇到了严重的问题。

RNN的致命缺陷：梯度消失和梯度爆炸

RNN在训练时需要对整个序列做反向传播。如果序列很长（比如一段1000字的文本），梯度在反向传播的过程中会不断被乘以相同的权重。如果权重小于1，梯度会越来越小，最终趋近于0——前面的信息根本传不到后面，网络就"忘记"了开头的内容。如果权重大于1，梯度会越来越大，最终数值溢出——网络崩溃。

这就是"梯度消失"和"梯度爆炸"问题。它让RNN无法处理长序列——大概超过20步就开始出问题。

LSTM：给RNN加了选择性记忆

1997年提出的LSTM（长短期记忆网络）解决了梯度消失问题。它的思路是：不让信息无条件地衰减，而是让网络自己决定什么信息该记住、什么该忘记。

LSTM引入了三个"门"：

遗忘门：决定从之前的记忆中丢弃什么输入门：决定把当前信息中的什么存入记忆输出门：决定基于当前记忆输出什么

python

# LSTM的核心机制（简化版）
def lstm_step(x, h_prev, c_prev):
    # 遗忘门：决定丢弃什么旧记忆
    forget_gate = sigmoid(W_f * x + U_f * h_prev)
    # 输入门：决定存入什么新信息
    input_gate = sigmoid(W_i * x + U_i * h_prev)
    # 新信息的候选值
    candidate = tanh(W_c * x + U_c * h_prev)
    # 更新记忆：旧记忆*遗忘门 + 新信息*输入门
    c_new = c_prev * forget_gate + candidate * input_gate
    # 输出门：决定输出什么
    output_gate = sigmoid(W_o * x + U_o * h_prev)
    # 输出基于更新后的记忆
    h_new = output_gate * tanh(c_new)
    return h_new, c_new

LSTM让RNN能够处理几百步的序列，这在当时是巨大的进步。语音识别、机器翻译、文本生成，这些领域在2010年代的主要突破都基于LSTM。

但LSTM也有局限：序列太长（超过500步）还是会有问题，而且LSTM是逐步计算的，没法并行——必须先算第一步才能算第二步，训练速度很慢。这个并行性的限制，正是Transformer要解决的问题。

RNN/LSTM在产品中的应用

场景	应用	说明
语音识别	把语音转为文字	Apple Siri早期版本
机器翻译	把一种语言翻译成另一种	Google翻译早期版本
文本生成	生成连续文本	早期聊天机器人
时间序列预测	预测股票、天气等	金融预测系统

产品经理需要知道：RNN/LSTM在今天已经不是主流了。2017年之后，序列建模几乎全面转向Transformer。但理解RNN有助于理解Transformer为什么更好——Transformer正是为了解决RNN的缺陷而设计的。

7.1.6 Transformer 与 GPT

这是当前AI最重要的架构。理解Transformer，你就理解了大模型时代的底层逻辑。

Transformer要解决的问题

RNN有两个致命缺陷：

梯度消失导致无法处理长序列
逐步计算导致无法并行训练

Transformer的解决方案是：彻底抛弃RNN的逐步计算结构，改用一种叫"自注意力"（Self-Attention）的机制来处理序列。

自注意力机制：让每个词都看到所有其他词

自注意力的核心思想是：对于序列中的每个位置，直接计算它和所有其他位置的关系，而不是像RNN那样只能一步步传递信息。

比如处理句子"猫坐在桌子上面"，当模型处理"上面"这个词时：

RNN只能通过逐步传递来获得"猫""坐""桌子"的信息，传递过程中信息会衰减
自注意力直接让"上面"同时看到"猫""坐""桌子"，一步到位

自注意力的计算过程：

python

# 自注意力计算（简化版）
def self_attention(query, key, value):
    # 1. 计算注意力分数：query和每个key的相似度
    scores = query @ key.T  # 矩阵乘法
    # 2. 缩放（防止数值过大）
    scores = scores / sqrt(key.shape[-1])
    # 3. 转为概率分布（softmax）
    attention_weights = softmax(scores)
    # 4. 用注意力权重加权value
    output = attention_weights @ value
    return output

# 在实际Transformer中，每个词都有三个向量：
# Query（查询）："我要找什么信息"
# Key（键）："我有什么信息可以被找"
# Value（值）："我的实际信息内容"

用一个更直觉的类比：假设你在一个图书馆找书。Query是你想找的主题，Key是每本书的标签，Value是每本书的内容。自注意力就是：用你的Query去和所有书的Key对比，找到最相关的几本书，然后根据相关性权重把这几本书的Value混合起来，作为你的输出。

多头注意力

Transformer不只用一次注意力，而是同时用多次（叫多个"头"），每个头关注不同的方面。比如一个头关注语法关系，另一个头关注语义关系，另一个头关注位置关系。最后把所有头的结果合并。

这就像你阅读一段文字时同时关注多个维度——谁做了什么（语法）、表达了什么意思（语义）、发生在什么时间（时序）。多头注意力让模型能同时从多个角度理解文本。

Transformer的完整结构

一个完整的Transformer由多个"Transformer Block"堆叠组成，每个Block包含：

多头自注意力层
残差连接 + 层归一化
前馈神经网络（两层全连接）
残差连接 + 层归一化

编码器版本（BERT用的）：只有上述结构解码器版本（GPT用的）：在自注意力之前还有一个"掩码"，防止看到未来的词（因为生成文本时你不能看到还没生成的词）

Transformer vs RNN对比

维度	RNN/LSTM	Transformer
长序列能力	受限（梯度消失）	强（自注意力直接连接）
并行训练	不行（必须逐步计算）	完全并行
计算复杂度	O(n)（序列长度线性）	O(n²)（序列长度平方）
位置信息	自然包含（逐步处理）	需要额外编码（位置编码）
训练速度	慢	快

Transformer的O(n²)复杂度是个问题——序列越长，计算量增长得越快。这就是为什么早期GPT模型的最大上下文长度只有512或1024。后来的各种优化（FlashAttention、稀疏注意力）在缓解这个问题，当前最先进的模型已经可以处理128K甚至1M的上下文。

GPT：Transformer解码器的产物

GPT（Generative Pre-trained Transformer）只用Transformer的解码器部分，核心任务是：根据前面的词，预测下一个词。

训练方式很简单：给模型大量文本，让它学会"看到前面的词后，下一个词最可能是什么"。这个过程叫"语言建模"。

python

# GPT的训练目标（简化）
# 输入："猫坐在桌子"
# 目标：预测下一个词是"上"的概率最高

# 训练数据构造方式：
# 原文："猫坐在桌子上面睡觉"
# 训练样本1：输入"猫" → 预测"坐"
# 训练样本2：输入"猫坐" → 预测"在"
# 训练样本3：输入"猫坐在" → 预测"桌子"
# 训练样本4：输入"猫坐在桌子" → 预测"上"
# 训练样本5：输入"猫坐在桌子上" → 预测"面"

就这么简单的训练目标，但模型大到一定程度后，出现了"涌现能力"——模型突然能做推理、做翻译、做代码生成，这些能力不是显式训练的，而是从"预测下一个词"中涌现出来的。

为什么预测下一个词能涌现出这些能力？因为要准确预测下一个词，模型必须真正理解上下文的含义。预测"猫坐在桌子___"的下一个词，你必须理解"猫""坐""桌子"的含义和它们之间的关系，才能得出"上"是最可能的下一个词。当训练数据足够多、模型足够大，这种理解就越来越深入，最终涌现出通用能力。

GPT的发展历程

版本	年份	参数量	关键突破
GPT-1	2018	1.17亿	证明预训练+微调范式可行
GPT-2	2019	15亿	证明大模型可以零样本完成任务
GPT-3	2020	1750亿	证明规模带来质变，少样本学习
GPT-3.5	2022	未公开	ChatGPT，对话能力爆发
GPT-4	2023	未公开	多模态，推理能力大幅提升

每次参数量增长大约10倍，能力就有一个质变。这不是偶然——大量研究表明，语言模型的能力和参数量/数据量之间存在可预测的"缩放定律"（Scaling Law）。

产品经理视角：Transformer为什么改变了产品形态

Transformer和大模型对产品的影响是根本性的：

从"窄域专用"到"通用多能"：以前每个功能需要单独训练模型，现在一个大模型能做多种任务
从"需要标注数据"到"少样本甚至零样本"：以前需要几万条标注数据才能训练，现在给几个示例就能工作
从"固定能力"到"可指令驱动"：以前模型能力在训练时就固定了，现在通过提示词可以灵活调整行为
从"一次性交付"到"持续迭代"：模型可以通过微调、RAG等方式持续改进，不需要从头训练

这些变化直接改变了AI产品的开发模式、成本结构和迭代节奏。理解了Transformer的原理，你才能理解为什么今天的AI产品可以做以前做不了的事。

7.1.7 MoE 与大模型架构

大模型越来越大的趋势下，一个矛盾越来越突出：更大的模型能力更强，但推理成本也更高。每次调用175B参数的模型，所有参数都要参与计算，即使大部分参数对当前任务并没有贡献。

MoE（Mixture of Experts，混合专家）架构试图解决这个矛盾：让模型的总参数量很大（保证能力），但每次推理只激活一部分参数（降低成本）。

MoE的基本原理

MoE的核心思想是：把一个大模型拆成多个"专家"（小的子网络），每次推理时根据输入内容选择最合适的几个专家来处理，其他专家不参与计算。

python

# MoE的简化示意
class MoELayer:
    def __init__(self, num_experts=8, top_k=2):
        self.experts = [Expert() for _ in range(num_experts)]
        self.gate = GateNetwork()  # 路由网络，决定选哪个专家
        self.top_k = top_k  # 每次激活几个专家
    
    def forward(self, x):
        # 1. 路由网络计算每个专家的适合度
        gate_scores = self.gate(x)  # [8个分数]
        
        # 2. 选择分数最高的top_k个专家
        selected_experts = topk(gate_scores, self.top_k)  # 选2个
        
        # 3. 只用选出的专家计算
        outputs = []
        for expert_idx in selected_experts:
            expert_output = self.experts[expert_idx](x)
            weight = gate_scores[expert_idx]
            outputs.append(weight * expert_output)
        
        # 4. 合并选中专家的输出
        return sum(outputs)

直觉类比：你去医院看病，不需要所有科室的医生都给你诊断。导诊台（路由网络）根据你的症状，把你分到最相关的2-3个科室（专家），只有这几个科室的医生会处理你的病例。其他科室的医生不需要参与，但他们存在，随时可以为其他类型的病人服务。

MoE的关键设计决策

决策	说明	常见选择
专家数量	拆成多少个子网络	8、16、64、128
Top-K	每次激活几个专家	通常2，偶尔1或3
路由策略	怎么决定选哪个专家	Top-K gating、hash routing
负载均衡	怎么防止某些专家被过度使用	辅助损失、容量因子
专家粒度	专家是整个层还是部分参数	层级MoE、细粒度MoE

负载均衡是个特别重要的问题。如果路由网络总是选择同样的几个"热门"专家，那些专家会被过度训练，其他专家则几乎没有训练机会。这会导致模型能力下降——大量参数浪费了。

实际产品中的MoE模型

模型	总参数	激活参数	专家数量	Top-K
Mixtral 8x7B	46.7B	12.9B	8	2
DeepSeek-V2	236B	21B	160	6
GPT-4（推测）	约1.8T	约220B	约16	约2

注意DeepSeek-V2的数据：总参数236B但只激活21B——这意味着每次推理只用约9%的参数，推理成本比同等能力的稠密模型低很多。

MoE对产品的影响

同等推理成本下获得更强能力：用MoE，你可以在2x7B的推理成本下获得接近13B稠密模型的水平
更灵活的能力扩展：增加专家数量比增加单个模型的参数更灵活
推理延迟可能略高：路由决策和专家切换带来少量额外开销
训练更复杂：负载均衡和路由策略需要额外处理

产品经理在评估技术方案时，应该关注"激活参数量"而不是"总参数量"。总参数量决定模型的潜在能力，但激活参数量决定实际的推理成本。DeepSeek-V2的236B总参数听起来吓人，但21B的激活参数意味着它的推理成本和20B左右的稠密模型差不多。

7.1.8 扩散模型（Diffusion Model）

前面讲的模型都是处理"理解"类任务——识别图像内容、理解文本含义。扩散模型处理的是"生成"类任务——创造全新的图像、音频、视频。

扩散模型的核心原理

扩散模型的思路非常巧妙，分为两个过程：

前向过程（加噪）：从一张清晰的图片开始，逐步添加随机噪声，直到图片变成纯噪声。这个过程是确定性的、预先定义的。

反向过程（去噪）：训练一个神经网络，学会从纯噪声中逐步去除噪声，还原出清晰的图片。这就是生成过程——你给模型一段噪声，它一步步去噪，最终生成一张全新的图片。

python

# 扩散模型的简化示意

# 前向过程：逐步加噪
def add_noise(image, step, total_steps):
    noise_level = step / total_steps
    noise = random_noise(image.shape)
    noisy_image = image * (1 - noise_level) + noise * noise_level
    return noisy_image

# 反向过程：逐步去噪（这就是生成过程）
def generate(total_steps=1000):
    # 从纯噪声开始
    current = random_noise(image_shape)
    
    # 逐步去噪
    for step in reversed(range(total_steps)):
        # 模型预测当前步骤应该去除的噪声
        predicted_noise = model(current, step)
        # 去除预测的噪声
        current = current - predicted_noise * noise_schedule[step]
    
    return current  # 最终得到清晰图片

直觉类比：想象你有一张照片，往上面泼泥巴，泼100次后照片完全看不见了。扩散模型学会了"反向泼泥巴"——从完全被泥巴覆盖的状态开始，一步步把泥巴擦掉，还原出照片。但这里的关键是：每次"擦泥巴"不是还原原来的照片，而是创造一张新的照片——因为去噪网络学到的不是"怎么还原某张特定照片"，而是"什么样的清晰图片是合理的"。

扩散模型的关键改进

技术	说明	意义
DDPM	最早的扩散模型框架	建立理论基础
DDIM	加速采样，减少去噪步数	从1000步降到50步
Stable Diffusion	在潜空间而非像素空间做扩散	大幅降低计算成本
Classifier-Free Guidance	无需额外分类器的条件引导	用文本精确控制生成内容
DALL-E 2/3	CLIP+扩散模型	文本到图像的端到端生成

Stable Diffusion的"潜空间"创新特别重要。最早的扩散模型直接在像素空间操作——一张512x512的图片有786432个像素，每次去噪都要处理这么多值。Stable Diffusion先用一个编码器把图片压缩到潜空间（大小只有像素空间的1/48），在潜空间做扩散，最后再用解码器还原到像素空间。这让扩散模型可以在普通GPU上运行，而不是需要几万美金的专业设备。

扩散模型在产品中的应用

场景	代表产品	说明
文本生图	Midjourney、DALL-E	用户输入文字描述，生成图片
图片编辑	Photoshop Generative Fill	选中区域，用文字描述替换内容
图生图	ControlNet	基于轮廓图、深度图等生成新图
视频生成	Sora、Runway	生成短视频
3D生成	Point-E、Shap-E	生成3D模型
音频生成	AudioLDM	生成音频和音乐

扩散模型的产品考量

生成速度：扩散模型需要多步去噪，即使优化后也需要20-50步，单张图片生成需要几秒到十几秒。对于需要实时响应的产品（比如视频通话中的实时特效），这个速度可能不够
生成质量 vs 速度的权衡：步数越多质量越好但越慢，需要根据场景选择
可控性：纯扩散模型生成的图片不太可控，需要配合条件引导（文本、轮廓、风格）来实现精确控制
版权和伦理：扩散模型的训练数据来自互联网图片，生成的图片可能无意中模仿了特定艺术家的风格，这带来版权风险

产品经理在设计AI生成类产品时，需要特别关注生成速度和可控性。用户对"等待5秒才看到结果"的容忍度远低于"等待0.5秒"——如果产品响应超过3秒，用户会开始流失。可控性则是用户留存的关键——如果生成结果总是"惊喜"但不是用户想要的，用户很快就会放弃。

7.2 模型微调与算力

7.2.1 大模型微调训练方法

大模型的训练分为两个阶段：预训练和微调。

预训练是"通识教育"——给模型海量数据，让它学会语言的通用规律。这个阶段用整个互联网的文本数据，成本极其高昂（GPT-3的预训练估计花费超过1000万美金），只有大公司才能做。

微调是"专业培训"——在预训练模型的基础上，用特定领域或特定任务的数据继续训练，让模型在某个方向上更专业。这个阶段成本远低于预训练，是大多数公司和产品团队可以做的。

微调的三种主流方法

方法	全称	核心思想	参数更新量	适用场景
全参数微调	Full Fine-Tuning	更新模型所有参数	100%	数据充足、需要大幅改变模型行为
SFT	Supervised Fine-Tuning	用标注数据做监督微调	100%或部分	让模型学会特定格式/任务
RLHF	Reinforcement Learning from Human Feedback	用人类偏好反馈做强化学习微调	100%	让模型输出更符合人类偏好

全参数微调

最直接的微调方式：把预训练模型的全部参数都更新。效果最好但成本最高——需要更新所有参数的梯度，需要大量GPU内存来存储参数和梯度。

一个7B参数的模型，全参数微调需要至少4张A100 GPU。一个70B的模型，全参数微调需要至少8-16张A100。这不是普通团队能承受的成本。

SFT：监督微调

SFT是让模型学会"按特定格式回答"的关键步骤。ChatGPT之所以能像对话而不是像百科全书一样回答问题，就是因为做了SFT——用人工标注的对话数据训练模型，让它学会对话格式。

SFT数据的核心是"指令-回答"对：

json

// SFT训练数据示例
{
  "instruction": "请用简洁的语言解释什么是机器学习",
  "input": "",
  "output": "机器学习是一种人工智能方法，通过给计算机大量数据，让它自动从中发现规律和模式，而不是人工编写规则。就像教小孩认猫——不是告诉他'猫有四条腿、尖耳朵'，而是让他看很多猫的图片，他自己就能归纳出猫的特征。"
}

// 更复杂的数据示例
{
  "instruction": "帮我写一封请假邮件",
  "input": "原因：家里有急事，需要请假2天，明天和后天",
  "output": "尊敬的领导：\n因家中突发急事，我需要请假2天（明天及后天），预计于XX日返岗。期间工作已与同事XX交接，如有紧急事项可通过手机联系我。恳请批准，谢谢。\n此致\n敬礼"
}

SFT的数据质量比数量更重要。几百条高质量的标注数据，效果往往比几千条低质量数据更好。这在产品上意味着：与其花大钱收集大量标注数据，不如精心设计少量高质量数据。

RLHF：让模型更"像人"

RLHF是让模型输出更符合人类偏好的方法。它分三个步骤：

SFT：先做监督微调，让模型有基本的对话能力
训练奖励模型：让人类标注员对不同回答打分（哪个回答更好），训练一个"奖励模型"来预测人类的偏好
强化学习微调：用奖励模型作为"裁判"，让生成模型通过强化学习来优化自己的回答，让奖励模型的评分越来越高

python

# RLHF流程简化示意

# 步骤2：训练奖励模型
# 人类标注数据：
# prompt = "解释量子计算"
# answer_A = "量子计算是..." (人类评分：8分)
# answer_B = "量子计算就是..." (人类评分：3分)
# 奖励模型学会：A比B更好

# 步骤3：用奖励模型指导生成模型
for step in training_steps:
    # 生成模型产出回答
    answer = policy_model.generate(prompt)
    # 奖励模型评分
    reward = reward_model.score(prompt, answer)
    # 根据评分更新生成模型（高分的行为被强化）
    update_policy_model(answer, reward)

RLHF让模型变得更"有用"和"安全"——有用是因为模型学会了给出人类更喜欢的回答，安全是因为人类标注员会给有害回答打低分。

但RLHF也有问题：人类偏好是不一致的、有偏见的。不同标注员可能对同一个回答给出截然不同的评分。这会导致模型学到的是"讨好标注员"而不是"给出真正好的回答"。

产品经理需要理解的是：RLHF不是万能的。它让模型更像人类标注员认为的好助手，但人类标注员的偏好可能不代表你的目标用户的偏好。如果你的用户是程序员，而标注员是普通用户，RLHF后的模型可能在编程问题上表现不如预期。

7.2.2 LoRA 微调原理

全参数微调太贵了，LoRA（Low-Rank Adaptation）是目前最受欢迎的低成本微调方法。它让7B模型的微调成本降到单张GPU就能跑的程度。

LoRA的核心思想

LoRA的发现基于一个关键观察：模型在微调时，参数的变化其实集中在"低秩"方向上——也就是说，参数变化可以用很少的维度来表示。

数学上，假设模型原始权重矩阵W的大小是d×d（比如4096×4096），微调时这个矩阵的变化ΔW也是d×d。但LoRA发现：ΔW可以分解为两个小矩阵的乘积：ΔW = A × B，其中A是d×r，B是r×d，r远小于d（比如r=8或16）。

python

# LoRA的核心数学
# 原始权重：W (d x d)，比如 4096 x 4096 = 16,777,216 个参数
# LoRA分解：ΔW = A x B
# A: d x r (4096 x 8 = 32,768 个参数)
# B: r x d (8 x 4096 = 32,768 个参数)
# LoRA参数总量：65,536，是原始参数量的 0.39%！

# 微调时的计算：
# y = (W + ΔW) * x = W * x + A * B * x
# 先用原始权重计算（不变）
# 再用LoRA的小矩阵计算增量
# 两部分加起来就是微调后的输出

这个分解让微调的参数量从几千万降到几万——降低了几个数量级。

LoRA的实际使用

python

# 使用LoRA微调的典型流程

# 1. 加载预训练模型（冻结原始参数）
model = load_pretrained_model("llama-7b")
for param in model.parameters():
    param.requires_grad = False  # 不更新原始参数

# 2. 为需要微调的层添加LoRA适配器
lora_config = LoraConfig(
    r=8,              # LoRA秩，越小参数越少
    lora_alpha=16,    # 缩放因子
    target_modules=["q_proj", "v_proj"],  # 只在注意力层加LoRA
    lora_dropout=0.05
)
model = get_peft_model(model, lora_config)

# 3. 训练（只更新LoRA参数）
trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
all_params = sum(p.numel() for p in model.parameters())
print(f"可训练参数比例：{trainable_params/all_params*100:.2f}%")
# 输出：可训练参数比例：0.39%

# 4. 训练完成后，LoRA参数可以合并回原始权重
# 或者保持分离，推理时动态加载不同的LoRA适配器

LoRA的关键参数

参数	说明	推荐值	影响
r（秩）	LoRA分解的中间维度	8-64	越大表达能力越强但参数越多
alpha	缩放系数	通常2x r	控制LoRA更新的影响力
target_modules	哪些层加LoRA	注意力层	覆盖越多层效果越好但参数越多
dropout	随机丢弃率	0.05	防过拟合

r的选择是个权衡：r=8最省参数，适合简单任务（格式调整、风格微调）；r=32或64效果更好，适合需要较大行为改变的复杂任务。

LoRA vs 全参数微调对比

维度	全参数微调	LoRA微调
参数更新量	100%	0.1%-1%
GPU内存需求	4-16张A100	1张A100甚至RTX 3090
训练速度	慢	快（3-10x）
效果	最好	接近全参数微调（差距通常<5%）
多任务支持	每个任务一个完整模型	每个任务一个LoRA适配器（几十MB）
存储成本	每个副本14GB+	每个LoRA几十MB

LoRA最后一条优势特别重要：多任务支持。用全参数微调，每个任务需要一整套模型参数（7B模型就是14GB）。用LoRA，你只需要一个基础模型+每个任务一个小适配器。这意味着你可以用一个基础模型服务多个产品线，每个产品线加载不同的LoRA适配器，存储成本和部署成本大幅降低。

LoRA的产品应用场景

风格定制：让模型用特定品牌语气回答（比如银行的正式语气、时尚品牌的活泼语气）
领域增强：让模型在特定领域更专业（比如法律、医疗、金融）
格式控制：让模型按特定格式输出（比如JSON格式、表格格式）
语言适配：让模型在特定语言或方言上表现更好

产品经理在设计微调方案时，LoRA应该是首选——除非你的需求确实需要大幅改变模型行为，才考虑全参数微调。LoRA的低成本和灵活性让迭代变得快速，你可以很快地尝试不同方向，找到最优方案。

7.2.3 大模型时代的金铲子：GPU 与 TPU

训练和运行大模型需要大量计算资源，这些资源主要来自两种芯片：GPU和TPU。

GPU：从游戏显卡到AI算力引擎

GPU（Graphics Processing Unit）最初是为图形渲染设计的。图形渲染的特点是：大量相同的简单计算同时执行（每个像素都要算颜色）。这种"大量简单计算并行执行"的特点，恰好和神经网络的计算模式高度吻合——神经网络也是大量简单的矩阵乘法并行执行。

2012年AlexNet首次用GPU训练神经网络，把训练时间从几周缩短到几天。此后GPU成为AI训练的标准硬件。

关键GPU型号

GPU型号	显存	FP16算力	市场定位	大约价格
RTX 4090	24GB	82.6 TFLOPS	个人/小团队	$1,600
A100	40GB/80GB	312 TFLOPS	企业级训练	$10,000-15,000
H100	80GB	990 TFLOPS	最新旗舰	$25,000-40,000
H200	141GB	990 TFLOPS	大显存版	约$40,000

H100是目前AI训练最热门的GPU。2023-2024年H100一度严重缺货，所有大公司都在抢购。Meta购买了35万张H100用于训练Llama系列模型。

TPU：Google的自研AI芯片

TPU（Tensor Processing Unit）是Google专门为AI计算设计的芯片。和GPU相比，TPU更专一——它只优化矩阵乘法（神经网络的核心运算），不关心图形渲染等其他功能。

芯片	类型	优势	劣势
GPU	通用并行处理器	生态完善（CUDA）、灵活	部分算力浪费在非AI功能
TPU	专用AI处理器	矩阵计算效率极高	生态封闭、只适合Google云

TPU在Google内部大量使用——所有Google的AI产品（搜索、翻译、Gemini）都跑在TPU上。但对外部用户来说，TPU只能通过Google Cloud使用，而且软件生态不如GPU（CUDA）完善。所以大多数公司还是选择GPU。

GPU显存：AI工程师最焦虑的数字

训练和推理大模型，最重要的约束不是算力而是显存。显存决定了你能训练多大的模型、能处理多大的批次、能运行多长的上下文。

不同模型的显存需求：

模型大小	推理显存需求（FP16）	推理显存需求（INT8量化）	训练显存需求
7B	~14GB	~7GB	~28GB（全参数微调）
13B	~26GB	~13GB	~52GB
70B	~140GB	~70GB	~280GB
175B	~350GB	~175GB	~700GB

注意量化带来的差异：INT8量化把显存需求减半，代价是精度略微下降。INT4量化进一步把显存需求降到1/4，代价更大但很多场景仍然可用。

产品经理需要知道的：7B模型推理需要14GB显存，一张RTX 4090（24GB）就够了。70B模型推理需要140GB，至少需要2张H100（80GB×2=160GB）。这就是为什么7B模型成为开源模型的主流尺寸——它在成本和能力之间找到了最好的平衡点，一张消费级GPU就能跑。

算力成本计算

操作	模型大小	GPU需求	单次成本估算
推理（单次请求）	7B	1张RTX4090	约$0.001
推理（单次请求）	70B	2张H100	约$0.01
LoRA微调	7B	1张A100	约$50-200（几小时）
全参数微调	7B	4张A100	约$500-2000
全参数微调	70B	16张H100	约$10,000-50,000
预训练	7B	8张A100×7天	约$50,000
预训练	175B	1000张A100×月	约$10,000,000+

这些数字对产品经理来说是做成本预估的基础。你的产品用什么模型、服务多少用户、需要多少GPU、每月算力成本多少——这些都应该在产品设计阶段就考虑清楚。

7.2.4 模型算力成本的权衡

算力成本是AI产品最独特的成本项。传统软件的成本主要是研发人力和服务器，AI产品额外有一大块算力成本——而且这块成本和用户量成正比（每个用户每次调用都消耗算力）。

推理成本的三种优化策略

策略一：模型选择——用最合适的而不是最强的

很多产品的推理成本高是因为用了超出需求的大模型。一个客服问答场景，7B模型可能就够了，但团队用了70B模型——推理成本翻了10倍，效果可能只好了5%。

模型选择原则：

场景	推荐模型大小	理由
简单分类/提取	1-3B	任务简单，小模型就够了
通用对话/问答	7-13B	性价比最高
复杂推理/代码	30-70B	需要更强推理能力
高精度专业领域	70B+或API调用	需要最强能力

策略二：量化——降低精度换取更低成本

量化是把模型的参数从高精度（FP16，每个参数2字节）转为低精度（INT8，每个参数1字节；INT4，每个参数0.5字节），从而降低显存需求和计算量。

量化方法	参数精度	显存降低	速度提升	质量损失
FP16	16位浮点	基准	基准	无
INT8	8位整数	约50%	约2x	极小（<1%）
INT4	4位整数	约75%	约3-4x	中等（3-8%）
GPTQ	4位+补偿	约75%	约3x	较小（1-3%）
AWQ	活跃权重保护	约75%	约3x	最小

INT4量化在大多数场景下质量损失可以接受，但关键任务（比如法律文书生成、医疗诊断建议）可能需要INT8甚至FP16来保证精度。

策略三：架构优化——用更高效的模型架构

MoE（前面讲的混合专家）就是一种架构优化——总参数多但激活参数少。还有一些其他方法：

方法	说明	成本降低	代价
MoE	只激活部分专家	50-80%	训练更复杂
KV Cache优化	减少注意力计算的缓存	20-50%	实现复杂
FlashAttention	更高效的注意力计算	20-30%	需要特定硬件支持
Speculative Decoding	小模型预测+大模型验证	20-40%	需要额外小模型
批处理推理	多个请求合并处理	50-70%	延迟略增

推理成本预估方法

产品经理应该学会估算推理成本。核心公式：

单次推理成本 = 模型显存占用 × GPU小时价格 × 推理时间 / 批处理效率

更实用的估算：
月推理成本 = 日活用户 × 日均调用次数 × 平均token数 × 每千token价格

举例：一个AI写作助手产品

参数	值
日活用户	10,000
每用户日均调用	5次
平均每次token数	输入500+输出1000=1500
每千token价格（自部署7B）	约$0.0005
每千token价格（API调用GPT-3.5）	约$0.002
每千token价格（API调用GPT-4）	约$0.03

月成本估算：

7B自部署：10000 × 5 × 1500 × 0.0005 / 1000 × 30 = $1,125/月 GPT-3.5 API：10000 × 5 × 1500 × 0.002 / 1000 × 30 = $4,500/月 GPT-4 API：10000 × 5 × 1500 × 0.03 / 1000 × 30 = $67,500/月

差距巨大。这就是为什么很多产品选择自部署开源模型而不是调用商业API——成本差几倍到几十倍。但自部署需要运维成本和GPU采购成本，这些也要算进去。

自部署 vs API调用的决策框架

维度	自部署	API调用
算力成本	低（只付GPU费用）	高（按token计费）
启动成本	高（采购GPU+运维）	低（按用付费）
数据安全	完全可控	数据经第三方
定制能力	高（可微调、量化）	低（只能用提供的模型）
可用性	需要自己保障	服务商保障
扩展性	需要额外采购GPU	自动扩展
适用阶段	产品成熟期	产品探索期

我的建议：MVP阶段用API调用（快速验证需求，低成本启动），产品成熟后评估自部署（降低长期成本，增加定制能力）。不要在MVP阶段就投入大量GPU采购——需求还没验证就砸钱买硬件是最亏的。

成本与质量的平衡矩阵

在做技术决策时，产品经理应该同时考虑成本和质量，找到平衡点：

决策	低成本选项	高成本选项	建议
模型大小	7B	70B	先试7B，不够再升级
精度	INT4量化	FP16	非关键场景INT4
部署方式	API调用	自部署	MVP用API，成熟后自部署
微调方法	LoRA	全参数微调	先LoRA，效果不够再全参数
上下文长度	4K	128K	按实际需求选

每个决策都是"先用低成本选项试，不够再升级"——这和做产品的思路一样：先MVP，验证后再投入更多资源。

7.3 产品基本功

聊完了算法和算力，最后一节补一课产品基本功。这一节看起来和AI没啥关系，但我见过太多AI产品经理——算法懂一堆，基本功一塌糊涂。PRD写不清楚，需求排不明白，原型画不出来。这些基本功不扎实，算法再懂也做不出好产品。

7.3.1 产品类文档简介

产品经理的日常产出主要是文档。不同的文档有不同的用途和受众。

核心文档一览

文档	用途	受众	产出时机
BRD	商业需求文档，论证做不做	决策层	项目立项前
MRD	市场需求文档，论证市场空间	决策层+市场团队	BRD通过后
PRD	产品需求文档，定义做什么怎么做	设计+开发+测试	项目启动后
竞品分析报告	分析竞争对手	产品团队+决策层	随时，项目前尤为重要
需求池	管理所有需求及其优先级	产品团队	随时维护

BRD：做不做的决策依据

BRD回答的核心问题是：这个产品值不值得做？它要论证的是商业价值。

BRD的核心内容：

市场机会：市场有多大、增长多快、趋势是什么
用户痛点：目标用户最头疼的问题是什么
解决方案：我们打算怎么解决
商业模式：怎么赚钱
ROI预估：投入多少、预期回报多少、周期多长
风险评估：可能遇到什么风险、怎么应对

BRD不需要写得很长，10页以内，重点是逻辑清晰、数据扎实。决策层最讨厌看到的是：一堆定性描述没有定量数据、只有乐观预测没有风险分析。

MRD：市场怎么打的路线图

MRD回答的核心问题是：如果决定做，市场怎么切入？它要论证的是市场策略。

MRD的核心内容：

目标市场细分：把大市场拆成具体可操作的细分市场
用户画像：每个细分市场的典型用户是什么样
竞品格局：现有竞品怎么分布、我们切入的差异化在哪
GTM策略（Go To Market）：怎么推向市场、渠道、定价
成功指标：用什么指标衡量市场进展

PRD：做什么怎么做的执行蓝图

PRD是产品经理最重要的文档。它回答的核心问题是：具体做什么功能、怎么做、怎么验收？

后面单独一节详细讲PRD的撰写实战。

文档之间的关系

BRD（做不做？）
  → 通过 → MRD（市场怎么打？）
    → 通过 → PRD（产品怎么做？）
      → 开发执行

现实中很多团队跳过BRD和MRD直接写PRD。在小团队或探索性项目中可以，但在需要大投入的项目中，跳过前两步的风险很大——你可能花了几个月做完一个产品，才发现市场根本不需要它。

AI产品特别容易犯这个错误。因为AI技术很酷，团队很容易被技术驱动而非市场驱动。"我们有个很酷的AI能力"→直接开始做→做完发现没人用。这就是跳过BRD和MRD的后果。

7.3.2 实战：PRD 撰写实战演示

PRD不是模板填充，而是思考的外化。写PRD的过程就是梳理思路的过程——写不清楚就是想不清楚。

我用一个实际案例来演示：AI智能客服产品的PRD撰写。

PRD的核心结构

一份完整的PRD包含以下部分：

文档信息（版本、作者、日期）
产品概述（背景、目标、范围）
用户场景与需求分析
功能需求详细描述
非功能需求（性能、安全、可用性）
交互设计与原型
数据指标与埋点
里程碑与排期
风险与依赖
附录

实战案例：AI智能客服PRD

markdown

# AI智能客服 PRD v1.0

## 文档信息
- 版本：1.0
- 作者：怕浪猫
- 日期：2025-03-15
- 状态：评审中

## 1. 产品概述

### 1.1 背景
当前客服团队50人，日均处理咨询8000条，平均响应时间12分钟，
用户满意度72%。人力成本每月约80万元，且高峰期（促销日）
咨询量翻倍，人力不足导致响应时间飙升到30分钟。

### 1.2 目标
- 日均自动处理60%的咨询（4800条），剩余40%转人工
- 平均响应时间降到2分钟以内
- 用户满意度提升到85%
- 人力成本降低40%（减少20人，月节省约32万元）

### 1.3 范围
一期范围：售前咨询（产品介绍、价格查询、优惠活动）
二期范围：售后咨询（退换货、物流查询、投诉处理）
不在范围内：电话客服、VIP专属客服

## 2. 用户场景

### 场景1：价格查询
用户："XX产品的价格是多少？"
当前流程：客服手动查询商品库→回复价格→可能还要回答优惠信息
AI流程：意图识别（价格查询）→自动查商品库→回复价格+优惠信息

### 场景2：产品推荐
用户："我想买个适合送礼的护肤品，预算500左右"
当前流程：客服根据经验推荐→可能不准确或不全面
AI流程：意图识别（推荐）→解析预算和需求→查商品库匹配→
       生成个性化推荐+理由

### 场景3：复杂投诉
用户："我收到的产品和描述不一样，要退货，而且物流很慢，等了10天"
当前流程：客服需要处理多个问题→容易遗漏某个诉求
AI流程：意图识别（投诉+退货+物流）→拆解多个诉求→
       逐个处理→生成完整回复→同时标记优先级建议人工跟进

## 3. 功能需求

### F1: 意图识别模块
- 输入：用户文本消息
- 输出：意图类别+置信度
- 意图类别：价格查询、产品推荐、优惠咨询、物流查询、退换货、投诉、其他
- 置信度阈值：<0.7时转人工，>=0.7时自动处理
- 目标指标：准确率>90%，响应时间<500ms

### F2: 知识检索模块（RAG）
- 输入：意图+用户查询
- 输出：相关商品/政策/FAQ信息
- 知识来源：商品数据库、售后政策文档、FAQ库
- 更新机制：商品数据实时同步，政策文档每周更新
- 目标指标：召回率>85%，响应时间<1s

### F3: 回复生成模块
- 输入：意图+检索结果+对话历史
- 输出：自然语言回复
- 要求：语气友好、信息准确、引导下一步
- 安全要求：不生成虚假优惠信息、不承诺超出政策的条件
- 目标指标：用户满意度>80%（评分收集）

### F4: 人工转接模块
- 触发条件：意图置信度<0.7、用户明确要求人工、投诉类意图
- 转接方式：无缝转接，人工客服能看到AI之前的对话历史
- 优先级：投诉优先，其他按排队顺序

## 4. 非功能需求

### 性能
- 单次响应总时间<3s（意图识别+检索+生成）
- 并发支持：500用户同时在线
- 可用性：99.9%（全年宕机<8.76小时）

### 安全
- 用户数据加密存储
- AI回复内容安全过滤（不输出有害内容）
- 对话日志保留6个月（合规要求）
- 数据不用于模型训练（隐私保护）

### 可观测性
- 意图识别准确率实时监控
- AI自动处理率实时监控
- 人工转接率实时监控
- 用户满意度实时监控
- 异常回复自动告警

## 5. 数据指标

| 指标 | 定义 | 目标 | 埋点位置 |
|------|------|------|---------|
| 自动处理率 | AI直接解决的咨询比例 | >60% | 对话结束状态 |
| 平均响应时间 | 从用户发送到收到回复的时间 | <2min | 每次回复 |
| 意图识别准确率 | 人工标注vsAI识别的一致率 | >90% | 每次意图识别 |
| 用户满意度 | 用户对回复的评分（1-5分） | >4.0 | 对话结束时 |
| 人工转接率 | 转人工的咨询比例 | <40% | 转接事件 |
| 幻觉率 | AI回复包含虚假信息的比例 | <2% | 人工抽检 |

## 6. 里程碑

| 阶段 | 内容 | 周期 |
|------|------|------|
| M1: 基础能力 | 意图识别+价格查询 | 4周 |
| M2: 知识增强 | RAG检索+回复生成 | 3周 |
| M3: 完整流程 | 全意图+转接+满意度 | 3周 |
| M4: 优化上线 | 性能优化+安全加固+灰度 | 2周 |

## 7. 风险

| 风险 | 影响 | 应对 |
|------|------|------|
| AI幻觉导致虚假承诺 | 高：可能造成经济损失 | 安全过滤+人工抽检+置信度阈值 |
| 意图识别准确率不足 | 中：自动处理率达不到目标 | 兜底转人工+持续微调 |
| 知识库更新不及时 | 中：回复信息过期 | 自动同步机制+人工定期审核 |
| 用户不接受AI客服 | 中：满意度下降 | 渐进式引入+明确标识AI+便捷转人工 |
| 大模型API成本超预期 | 低：运营成本增加 | 自部署备选方案+成本监控 |

## 8. 技术方案概要

- 大模型：7B开源模型+LoRA微调（成本可控）
- RAG：向量数据库+商品/政策知识库
- 部署：私有化部署（数据安全要求）
- 监控：意图识别准确率+幻觉率+满意度实时监控
- 迭代：每周微调更新，每月评估指标

PRD撰写的常见错误

错误	表现	为什么有问题
没有数据指标	只描述功能不定义成功标准	无法衡量做得好不好
功能描述模糊	"做一个AI客服"而不是具体拆解	开发无法执行
忽略非功能需求	不写性能、安全、可用性要求	做出来可能不可用
没有兜底方案	AI可能失败的情况没考虑	失败时用户体验极差
范围不明确	什么都想做	周期无限延长
不写风险	假设一切顺利	出问题时没有预案

AI产品的PRD特别容易犯的错误是：过度乐观地描述AI能力，不写AI可能失败的情况和兜底方案。AI一定会犯错，你的PRD必须写清楚：AI犯错时怎么办、AI不确定时怎么办、AI回答有害内容时怎么办。这些兜底方案不是可选的，是必须的。

7.3.3 实战：MasterGo AI 生成产品原型

原型是PRD的可视化版本。以前画原型是产品经理最耗时间的手工活，现在AI能帮你大幅加速这个过程。

MasterGo是国内主流的设计工具之一，它的AI功能可以帮你从文字描述快速生成界面原型。

使用流程

步骤1：打开MasterGo，进入AI生成模式

步骤2：输入页面描述

请生成一个AI客服对话界面，要求：
- 左侧是聊天对话区，显示用户消息和AI回复
- 右上角有意图识别结果标签（显示当前识别的意图类别）
- 右侧有知识库匹配结果面板（显示检索到的相关信息）
- 底部有快捷操作栏：转人工、重新生成、满意度评分
- 整体风格简洁专业，蓝色为主色调

步骤3：AI生成初版原型，你在此基础上调整

步骤4：根据PRD中的功能需求逐项检查原型是否覆盖

步骤5：标注交互逻辑（点击"转人工"后怎样、评分后怎样）

AI生成原型的好处和局限

维度	AI生成	手工绘制
速度	几分钟出初版	小时到几天
视觉质量	较好（AI有设计审美）	取决于个人设计能力
定制化	需要多轮调整才能精确	可以直接精确绘制
交互逻辑	不包含（只有静态布局）	可以完整标注
组件一致性	可能不一致	可以用组件库保证

AI生成的原型不是最终版本，而是起点。它的核心价值是：帮你快速从文字变成可视化界面，让团队更快看到产品的样子，加速讨论和决策。但交互逻辑、细节调整、组件标准化这些工作，AI还做不好，需要你手动完善。

从原型到开发交付的关键步骤

原型评审：和设计、开发团队一起看原型，确认功能覆盖和交互逻辑
设计规范：把原型交给设计师，产出设计规范（颜色、字体、间距、组件）
前端开发：开发根据设计规范实现界面
后端开发：开发根据PRD的功能描述实现逻辑
联调测试：前后端联调，验证功能完整性

AI帮你在步骤1加速了，但步骤2-5仍然需要扎实的产品基本功来驱动。原型只是起点，不是终点。

7.3.4 需求池管理与优先级排列原则

需求永远比资源多。产品经理最核心的能力不是想出需求，而是决定先做什么后做什么。

需求池的结构

需求池不是随便堆需求的清单，而是有结构的管理工具：

markdown

# 需求池

## P0 - 必做（不做产品不能上线）
| ID | 需求 | 来源 | 预估工作量 | 状态 |
|----|------|------|-----------|------|
| R001 | 意图识别模块 | PRD F1 | 2周 | 开发中 |
| R002 | 价格查询功能 | 用户访谈top1痛点 | 1周 | 待开发 |
| R003 | 人工转接 | 安全兜底 | 1周 | 设计中 |

## P1 - 应做（做了体验显著提升）
| ID | 需求 | 来源 | 预估工作量 | 状态 |
|----|------|------|-----------|------|
| R004 | 产品推荐功能 | 竞品差异化 | 2周 | 待排期 |
| R005 | 对话满意度评分 | 数据指标收集 | 3天 | 待排期 |
| R006 | 知识库自动同步 | 运维效率 | 1周 | 待排期 |

## P2 - 可做（做了锦上添花）
| ID | 需求 | 来源 | 预估工作量 | 状态 |
|----|------|------|-----------|------|
| R007 | 多语言支持 | 国际化规划 | 3周 | 需求分析 |
| R008 | 对话情感分析 | 创新探索 | 2周 | 需求分析 |

## P3 - 暂缓（当前不合适）
| ID | 需求 | 来源 | 暂缓原因 |
|----|------|------|---------|
| R009 | 语音客服 | 用户反馈 | 技术成熟度不够 |
| R010 | VIP专属AI | 业务方 | 当前用户量不够 |

优先级排列的核心原则

原则一：用户价值优先

需求的优先级首先取决于它对用户的价值。用户价值 = 痛点严重度 × 受影响用户比例。

痛点严重度：这个需求解决的是用户"必须要"的问题还是"想要"的问题？必须解决的问题优先级更高。

受影响用户比例：这个需求影响多少用户？影响80%用户的需求比影响5%用户的需求优先级更高。

原则二：商业价值辅助

纯用户价值不考虑商业是不够的。有些需求用户很想要但不贡献商业价值，有些需求用户不那么想要但对商业很重要。两者都要考虑，但用户价值应该优先——没有用户就没有商业。

原则三：技术可行性约束

有些需求用户很想要、商业也很有价值，但当前技术做不了或者成本太高。这类需求要标注技术风险，可能需要降级处理或者暂缓。

AI产品特别容易遇到这个问题：用户想要AI做到100%准确，但技术上做不到。这时候优先级排列的策略是：先做AI能做到90%准确的功能（用户价值高、技术可行），再逐步提升准确率（迭代改进）。

原则四：依赖关系排序

有些需求是其他需求的前提。比如"知识库检索"是"回复生成"的前提——没有知识库数据，回复生成就做不了。这种依赖关系必须在排序时考虑。

优先级排列实战方法

RICE评分法是一种量化排序方法：

因素	定义	评分方式
Reach（覆盖面）	多少用户会受益	预估用户数量或百分比
Impact（影响力）	对每个用户的影响程度	0.25=微小，1=中等，2=巨大，3=极大
Confidence（信心）	你对以上评估的确信度	50%=低，80%=中，100%=高
Effort（工作量）	完成需要多少资源	预估人周数

RICE得分 = (Reach × Impact × Confidence) / Effort

得分越高优先级越高。

举例计算：

需求	Reach	Impact	Confidence	Effort	RICE得分
价格查询	80%	2	100%	1周	160
产品推荐	30%	3	80%	2周	36
多语言	10%	1	50%	3周	1.7
情感分析	5%	0.25	50%	2周	0.6

价格查询的RICE得分最高，应该最优先。产品推荐得分中等，第二优先。多语言和情感分析得分很低，暂缓。

RICE不是完美的方法——它的评分有主观性。但它的价值在于：把优先级决策从"我觉得应该先做这个"变成"让我们按统一标准评估每个需求"。量化比直觉更不容易出错。

AI产品需求排序的特殊考虑

AI产品的需求排序有两个额外维度需要考虑：

维度一：AI能力边界

有些需求在RICE评分上很高，但当前AI做不到。比如"AI自动处理退货"可能Reach很高、Impact很大，但AI在判断退货条件上准确率不够。这时候的策略是：把需求拆分成AI能做的部分和需要人工的部分，先做AI能做的部分。

维度二：数据准备度

有些功能需要特定的数据才能实现。比如"个性化推荐"需要用户行为数据，但新产品还没有积累这些数据。这时候的策略是：先做不需要大量数据的版本（基于热门商品的推荐），等产品运行一段时间有了数据后再升级。

需求池的维护节奏

需求池不是一劳永逸的文档，它需要持续维护：

每周更新：新需求加入、已有需求状态更新、优先级重新评估
每月复盘：回顾已完成的需求效果、调整未完成需求的优先级
每季度清理：删除不再合适的需求、合并重复需求、调整分类

需求池的健康指标：

指标	健康值	不健康值
P0完成率	>90%	<70%
需求平均等待时间	<2周	>4周
需求变更率	<20%	>40%
废弃需求比例	<10%	>30%

需求变更率超过40%说明需求分析不够扎实——很多需求进了池子又被推翻。废弃需求比例超过30%说明需求收集太随意——不加筛选就往池子里扔。

产品基本功说白了就是：想清楚做什么（PRD）、做出来给人看（原型）、决定先做什么后做什么（需求池）。这三件事看起来简单，做起来难。很多AI产品经理沉迷于算法讨论，忘了这些基本功才是决定产品能不能做出来的关键。

本章小结

主题	核心要点
AI理论流派	符号主义（逻辑推理）、连接主义（神经网络）、行为主义（强化学习），当前以连接主义为主
机器学习基础	监督/无监督/强化三种范式，神经网络=加权求和+激活函数，核心概念：损失函数、学习率、过拟合
深度学习	深层网络学习层次化特征，三波浪潮：CNN→RNN→大模型，传统ML和DL各有适用场景
CNN	卷积操作提取局部特征，从AlexNet到ResNet，擅长视觉任务但不擅长语义关系
RNN/LSTM	处理序列数据的网络，梯度消失是核心缺陷，LSTM用门机制缓解，已被Transformer替代
Transformer	自注意力机制直接计算全局关系，可并行训练，是GPT系列的基础架构
GPT	Transformer解码器+语言建模训练，参数增长带来能力质变，改变了AI产品开发模式
MoE	混合专家架构，总参数大但激活参数少，同等推理成本下更强能力
扩散模型	前向加噪+反向去噪，文本/条件引导生成，潜空间创新降低成本
微调方法	全参数微调/SFT/RLHF，SFT数据质量比数量重要，RLHF让模型更符合人类偏好
LoRA	低秩分解大幅降低微调参数量（0.1%-1%），支持多任务多适配器，是微调首选
GPU/TPU	GPU是AI算力主流，显存是最关键约束，7B模型单卡可推理，70B需要多卡
算力成本	推理成本和用户量成正比，量化/架构优化/模型选择是三大降成本策略
自部署vsAPI	MVP用API快速验证，成熟后自部署降成本，数据安全是自部署的关键考量
PRD撰写	必须写清楚功能拆解、数据指标、兜底方案、风险预案，AI产品尤其要写AI失败时的处理
AI原型	MasterGo AI可快速生成静态布局，交互逻辑和细节仍需手动完善
需求池	P0/P1/P2/P3分级，RICE评分量化排序，AI需求额外考虑能力边界和数据准备度

算法和算力是AI产品的基础设施，产品基本功是把这些基础设施变成实际产品的施工图纸。懂算法让你知道能做什么，懂算力让你知道成本多少，懂产品基本功让你把"能做"变成"做成"。

下章预告： 第8章数据驱动，从数据采集到分析决策，AI产品如何用数据验证效果、驱动迭代。

第7章 AI 核心要素：产品经理的算法与算力课 ​

7.1 算法原理：从机器学习到大模型 ​

7.1.1 人工智能主流理论流派 ​

7.1.2 机器学习与神经网络基本原理 ​

7.1.3 深度学习简介：AI 能力爆发的引擎 ​

7.1.4 视觉模型：CNN 卷积神经网络 ​

7.1.5 序列问题：RNN 循环神经网络 ​

7.1.6 Transformer 与 GPT ​

7.1.7 MoE 与大模型架构 ​

7.1.8 扩散模型（Diffusion Model） ​

7.2 模型微调与算力 ​

7.2.1 大模型微调训练方法 ​

7.2.2 LoRA 微调原理 ​

7.2.3 大模型时代的金铲子：GPU 与 TPU ​

7.2.4 模型算力成本的权衡 ​

7.3 产品基本功 ​

7.3.1 产品类文档简介 ​

7.3.2 实战：PRD 撰写实战演示 ​

7.3.3 实战：MasterGo AI 生成产品原型 ​

7.3.4 需求池管理与优先级排列原则 ​

本章小结 ​

第7章 AI 核心要素：产品经理的算法与算力课

7.1 算法原理：从机器学习到大模型

7.1.1 人工智能主流理论流派

7.1.2 机器学习与神经网络基本原理

7.1.3 深度学习简介：AI 能力爆发的引擎

7.1.4 视觉模型：CNN 卷积神经网络

7.1.5 序列问题：RNN 循环神经网络

7.1.6 Transformer 与 GPT

7.1.7 MoE 与大模型架构

7.1.8 扩散模型（Diffusion Model）

7.2 模型微调与算力

7.2.1 大模型微调训练方法

7.2.2 LoRA 微调原理

7.2.3 大模型时代的金铲子：GPU 与 TPU

7.2.4 模型算力成本的权衡

7.3 产品基本功

7.3.1 产品类文档简介

7.3.2 实战：PRD 撰写实战演示

7.3.3 实战：MasterGo AI 生成产品原型

7.3.4 需求池管理与优先级排列原则

本章小结