从规则到智能：AI 技术演进的脉络与未来

一篇写给工程师的 AI 技术博客——不讲玄学，只讲脉络、原理和工程实践。

目录

1. 引言：我们站在哪里
2. AI 的三次浪潮
3. 机器学习：让机器从数据中学习
4. 深度学习：用神经网络逼近复杂函数
5. 大语言模型：从 GPT 到推理模型
6. AI 工程化：从 Demo 到生产
7. 前沿方向与挑战
8. 写给开发者的建议

1. 引言：我们站在哪里

2025 年，AI 已经不是一个实验室里的概念。它在你手机相册里做图像分类，在你用的 IDE 里做代码补全，在你公司的客服系统里回答用户问题。但"AI 能做什么"和"AI 是怎么做到的"之间，隔着巨大的认知鸿沟。

这篇博客的目的，是把这个鸿沟填上一点——从最基础的概念出发，沿着技术演进的脉络，一直走到今天的大模型和工程实践。

2. AI 的三次浪潮

AI 的历史可以粗略地分为三次浪潮，每一次都伴随着巨大的热情和随后的冷静：

符号主义 vs 连接主义：前者认为智能=规则+推理，后者认为智能=神经元+权重学习。历史证明，连接主义在大规模数据和算力的加持下取得了压倒性胜利，但符号主义的思想仍在知识图谱、形式验证等领域发挥作用。

3. 机器学习：让机器从数据中学习

在谈深度学习之前，先理解传统机器学习。它的核心思想很简单：

给定数据 (X, y)，学习一个函数 f，使得 f(X) ≈ y。

3.1 三种学习范式

# 监督学习：有标签数据，学习输入到输出的映射
# 例：垃圾邮件分类（输入=邮件文本，输出=垃圾/正常）
from sklearn.svm import SVC
model = SVC(kernel='rbf')
model.fit(X_train, y_train)  # X_train 是特征，y_train 是标签

# 无监督学习：无标签数据，发现数据内在结构
# 例：用户聚类、异常检测
from sklearn.cluster import KMeans
kmeans = KMeans(n_clusters=5)
kmeans.fit(X)  # 只有 X，没有 y

# 强化学习：通过试错和奖励信号学习策略
# 例：AlphaGo 下围棋、机器人控制
# 核心循环：观察状态 → 选择动作 → 获得奖励 → 更新策略

3.2 特征工程：传统 ML 的阿喀琉斯之踵

传统机器学习极度依赖特征工程——人工设计、选择、组合输入特征。比如做图像分类，你需要手动设计边缘检测、颜色直方图、纹理特征等。这要求领域专家深度参与，且特征的表达能力有天花板。

深度学习的突破恰恰在于：让模型自己学习特征。你给它原始像素，它通过多层网络逐层提取从低级（边缘）到高级（语义）的特征。这就是"表示学习"（Representation Learning）的核心。

4. 深度学习：用神经网络逼近复杂函数

4.1 神经网络的基本结构

一个神经网络由多层神经元组成，每个神经元做的事情其实很朴素：

输出 = 激活函数(权重 × 输入 + 偏置)
     = σ(W·x + b)

• 权重 W：决定每个输入的重要性，是模型要学习的参数
• 激活函数 σ：引入非线性（没有它，多层网络等价于单层线性变换）
• 偏置 b：平移决策边界

把很多这样的神经元堆叠成层，层与层之间全连接，就得到了一个多层感知机（MLP）。训练过程就是通过反向传播（Backpropagation）和梯度下降（Gradient Descent），不断调整 W 和 b，让预测误差最小。

4.2 三种改变格局的网络结构

CNN（卷积神经网络）—— 视觉的基石

import torch.nn as nn

class SimpleCNN(nn.Module):
    def __init__(self, num_classes=10):
        super().__init__()
        # 卷积层：提取局部空间特征（边缘、纹理、形状）
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        # 全连接层：将特征映射到类别
        self.fc = nn.Linear(32 * 16 * 16, num_classes)

    def forward(self, x):
        x = self.pool(nn.functional.relu(self.conv1(x)))
        x = x.view(x.size(0), -1)
        return self.fc(x)

CNN 的核心洞见：图像具有空间局部性和平移不变性。卷积核在整张图上共享权重，既减少了参数量，又能检测任意位置出现的相同模式。2012 年 AlexNet 在 ImageNet 上的胜利，标志着深度学习时代的开启。

RNN / LSTM —— 处理序列

RNN（循环神经网络）引入了时间维度的隐状态，使得网络能"记住"之前的信息：

h_t = f(W_h · h_{t-1} + W_x · x_t + b)

LSTM（长短期记忆网络）通过门控机制（遗忘门、输入门、输出门）解决了 RNN 的梯度消失问题，能够学习更长的序列依赖。在 Transformer 出现之前，LSTM 是 NLP 领域的王者。

Transformer —— 一切的开端

2017 年，Google 发表了论文 “Attention Is All You Need”，提出了 Transformer 架构。它的核心创新是自注意力机制（Self-Attention）：

$$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right) V$$

• Q（Query）、K（Key）、V（Value）：分别由输入线性变换得到
• QK^T：计算每个位置与其他所有位置的关联度
• softmax：归一化为注意力权重
• 乘以 V：按权重加权求和，得到融合了全局信息的输出

Transformer 相比 RNN 的优势：

这个架构后来成为了 GPT、BERT、LLaMA 等所有大模型的基础。

5. 大语言模型：从 GPT 到推理模型

5.1 LLM 的本质：下一个 Token 预测

大语言模型的训练目标出奇地简单——预测下一个 Token：

给定 "今天天气真"，预测下一个 token
模型输出概率分布：{ "好": 0.6, "热": 0.2, "冷": 0.1, "棒": 0.05, ... }

但当你用数万亿 Token 的语料、数千亿参数的模型、数千张 GPU 训练数月后，这个简单的目标产生了涌现能力（Emergent Abilities）：模型学会了推理、翻译、写代码、做摘要，甚至展现出一定的常识理解。

5.2 训练流程：三步走

┌─────────────────────────────────────────────────────────┐
│  Step 1: 预训练 (Pre-training)                          │
│  数据：数万亿 Token 的互联网文本、代码、书籍             │
│  目标：Next Token Prediction (自监督)                    │
│  产出：基座模型 (Base Model) — 会续写，但不听指令        │
│  成本：最贵，通常数百万到数千万美元                       │
├─────────────────────────────────────────────────────────┤
│  Step 2: 指令微调 (Supervised Fine-Tuning, SFT)          │
│  数据：数万到数十万条 (指令, 回答) 对                    │
│  目标：学会按指令格式回答                                │
│  产出：对话模型 — 能听指令，但可能不够安全/对齐           │
│  成本：相对低，单机或小集群可完成                         │
├─────────────────────────────────────────────────────────┤
│  Step 3: 对齐 (Alignment)                               │
│  方法：RLHF (人类反馈强化学习) 或 DPO (直接偏好优化)      │
│  目标：让回答更符合人类偏好（安全、有用、诚实）           │
│  产出：对齐后的生产模型                                   │
│  成本：中等，需要人类标注或偏好数据                       │
└─────────────────────────────────────────────────────────┘

5.3 推理模型：让 AI 学会"想一想再回答"

2024 年以来，以 OpenAI o1、DeepSeek-R1 为代表的推理模型标志着新的范式转变。传统 LLM 是"快思考"——直接生成回答；推理模型是"慢思考"——先在内部生成一段推理链（Chain of Thought），再给出最终答案。

传统 LLM：
  用户提问 → 直接输出答案

推理模型：
  用户提问 → 生成推理过程（可能数千 Token）
            → 基于推理得出答案
            → 输出答案

关键技术是 RL with Verifiable Rewards——用可验证的奖励（如数学题的正确答案、代码的测试通过）作为强化学习信号，让模型学会更长的推理链。这使得模型在数学、编程、逻辑推理等可验证任务上表现大幅提升。

5.4 RAG：让 LLM 接上你的知识库

LLM 的知识来自训练数据，有截止日期，且容易产生幻觉。RAG（检索增强生成） 是目前最实用的解决方案：

用户提问
   │
   ▼
┌──────────────┐     ┌──────────────────┐
│  Embedding   │────▶│  向量数据库检索   │
│  将问题向量化  │     │  找到最相关的文档  │
└──────────────┘     └────────┬─────────┘
                              │ 相关文档
                              ▼
                    ┌──────────────────┐
                    │  构造 Prompt      │
                    │  问题 + 检索结果   │
                    └────────┬─────────┘
                             │
                             ▼
                    ┌──────────────────┐
                    │  LLM 生成回答     │
                    │  基于检索到的上下文 │
                    └──────────────────┘

# RAG 的核心流程（伪代码）
from sentence_transformers import SentenceTransformer
import faiss

# 1. 离线阶段：将知识库文档向量化并存入向量索引
encoder = SentenceTransformer('bge-large-zh')
doc_embeddings = encoder.encode(all_documents)
index = faiss.IndexFlatIP(dim)
index.add(doc_embeddings)

# 2. 在线阶段：检索 + 生成
def rag_answer(question, llm):
    # 检索
    q_emb = encoder.encode([question])
    scores, indices = index.search(q_emb, k=5)
    context = [all_documents[i] for i in indices[0]]

    # 构造 Prompt
    prompt = f"基于以下信息回答问题：\n\n{context}\n\n问题：{question}"

    # 生成
    return llm.generate(prompt)

6. AI 工程化：从 Demo 到生产

在 Notebook 里跑通一个模型，和把 AI 服务部署到生产环境，是完全不同的事情。以下是工程化中最关键的几个问题：

6.1 推理优化

6.2 模型服务架构

                    ┌─────────────┐
                    │   API 网关   │
                    │  (限流/鉴权)  │
                    └──────┬──────┘
                           │
                    ┌──────▼──────┐
                    │  负载均衡    │
                    └──────┬──────┘
                           │
           ┌───────────────┼───────────────┐
           │               │               │
    ┌──────▼──────┐ ┌──────▼──────┐ ┌──────▼──────┐
    │  GPU Worker  │ │  GPU Worker  │ │  GPU Worker  │
    │  (vLLM/TGI)  │ │  (vLLM/TGI)  │ │  (vLLM/TGI)  │
    └─────────────┘ └─────────────┘ └─────────────┘

关键工程决策：

• 批处理 (Batching)：将多个请求的 Token 拼成一个 batch 一起推理，提高 GPU 利用率
• 流式输出 (Streaming)：逐 Token 返回，降低用户感知延迟
• 自动扩缩容：根据 GPU 利用率/队列长度动态调整 Worker 数量
• 模型多版本管理：支持灰度发布、A/B 测试

6.3 评估与监控

AI 服务的评估比传统软件难得多——没有确定性的"正确答案"。实践中的做法：

# 1. 离线评估：构建评测集，定期跑全量评估
metrics = {
    "accuracy": evaluate_on_test_set(model, test_data),
    "latency_p95": measure_latency(model, sample_queries),
    "hallucination_rate": detect_hallucinations(model, fact_check_set),
    "toxicity_score": safety_evaluator(model, adversarial_prompts),
}

# 2. 在线监控：记录真实请求的指标
# - 响应延迟分布
# - 用户反馈（点赞/点踩）
# - 输出长度/Token 使用量
# - 安全过滤器触发率
# - 人工抽检通过率

7. 前沿方向与挑战

7.1 多模态：不止于文本

GPT-4o、Gemini 等模型已经能同时理解文本、图像、音频、视频。多模态的关键在于统一表示——将不同模态映射到同一向量空间，让模型能在跨模态之间推理。

7.2 AI Agent：从回答问题到完成任务

Agent 是当前最热门的方向之一。与 LLM 被动回答问题不同，Agent 能主动规划、调用工具、与环境交互：

用户目标："帮我分析这份 CSV 的销售数据，画个趋势图"
    │
    ▼
Agent 规划：
  Step 1: 调用 read_file 工具读取 CSV
  Step 2: 调用 pandas 工具做数据清洗和聚合
  Step 3: 调用 matplotlib 工具绘制趋势图
  Step 4: 调用 save_file 工具保存图片
  Step 5: 返回分析摘要 + 图片路径

核心挑战：长程规划、错误恢复、工具选择的可靠性。

7.3 未解难题

• 幻觉问题：模型会自信地生成错误信息，目前没有完美解决方案
• 可解释性：我们仍然无法完全理解模型"为什么"给出某个输出
• 数据效率：人类能从几个例子学会新概念，LLM 需要海量数据
• 对齐问题：如何确保越来越强大的 AI 的目标与人类一致
• 算力民主化：当前最先进的模型训练成本数亿美元，只有少数公司能负担

8. 写给开发者的建议

1. 从 API 开始，不要从训练开始。99% 的应用场景用 API 调用 + Prompt 工程 + RAG 就能解决。不要一上来就想训练模型。

2. 理解 Token，而不是理解"词"。LLM 的基本单位是 Token，不是词。一个中文字大约 1-2 个 Token，一个英文单词大约 1-3 个 Token。Token 数量直接影响成本和延迟。

3. Prompt 工程是真实的工程。不要轻视它。好的 Prompt 包含：明确的任务描述、必要的上下文、输出格式约束、少样本示例（Few-shot）。把它当作写函数的入参文档来对待。

4. 评估驱动开发。传统软件用单元测试，AI 应用用评估集。先建评估集，再改 Prompt/换模型/加 RAG，每次改动都跑评估，用数据说话。

5. 关注成本。LLM 推理按 Token 计费，一个看似简单的功能可能在每次调用中消耗数万 Token。做好 Token 预算和缓存策略。

6. 保持学习，但保持冷静。AI 领域每周都有"颠覆性"的新论文，但真正经得起时间检验的技术并不多。关注基础原理，而不是追逐每一个热点。

结语：AI 技术的演进，从规则系统到统计学习，从深度学习到大语言模型，每一步都在扩展"机器能做什么"的边界。但无论技术如何进步，理解原理的工程师永远比只会调 API 的工程师多一层竞争力。希望这篇博客能帮你建立这层理解。

写于 2026 年 10 月