企业官网建设流程全解析

简介：《走进人工智能2.0》是2025年北京大学出品的主题报告PDF，面向希望系统梳理人工智能发展脉络的高校师生、技术从业者与转型学习者。内容以时间轴为线索，把1956年至2025年的人工智能划分为规则与知识、机器学习、深度学习、大模型四个时代，逐层说明从符号主义、连接主义到Transformer架构的演进逻辑。重点章节讨论大模型的原理与能力边界，涵盖预训练、注意力机制、多模态与生成式人工智能，并延伸至MaaS模型服务、Agent自主代理架构以及传媒、教育、医疗等行业的落地现状与人才能力要求。资源包仅含1个PDF文档，约36.84MB，页面完整、图表与幻灯片结构清晰，便于通读浏览或按主题检索重点章节。目前已有136人学习，适合作为人工智能通识入门、课程备课以及团队内部分享讨论的参考材料。

1. 从规则推理到 Agent：这份 2025 年北大讲义串起了什么

2025 年 8 月 14 日杭州的那场分享，没有按模型名字排时间线，而是给人工智能编了版本号：0.0 是规则和知识，0.1 是机器学习，1.0 是深度学习，2.0 是大模型，2.x 是 Agent。这个分法对工程实践有直接价值——拿到一个需求，你会先判断它落在哪一段：确定性的流程交给代码，不确定性的判断才交给数据模型。

讲义分三块：人工智能的前世今生、大模型的原理和能力边界、大模型的现状与发展及人才要求。它把 1956 年达特茅斯会议到 2025 年的技术栈压缩成一张可对照的表，中间夹着 NTP、Transformer、Token、注意力机制这些能直接落到接口参数上的概念。

适合两类人读：正在把大模型往业务系统里塞、却说不清 token、温度、上下文窗口和 Agent 之间关系的开发者；以及带团队做技术选型、需要一份能对齐内部概念的人。下面按技术栈分层往下拆。

2. AI 0.0 到 2.0：四个时代的技术栈分层与可解释性代价

版本号分法的好处是把"智能"从玄学拉回工程。每一代 AI 的能力边界，其实都由它的建模范式决定，而不是由算力决定的。看清这一点，选型时就不会拿大模型去解一个规则引擎能解的问题。

2.1 古代（1956—1996）：规则推理与专家系统的两次浪潮

第一次浪潮是 1956 到 1968 年，思想准备来自冯·诺依曼计算机体系、机器思考的设想和图灵测试，哲学基础是唯理论，主要原理是制定规则做数理推理，确定性和概率分支都要显式写出来。代表成果是下棋程序、定理机器证明和 MIT 的搬箱机器人。

第二次浪潮从 1986 年延续到 1996 年之后，哲学基础上加了经验论，核心方法是知识工程——知识抽取加知识表达，产物是专家系统，也就是知识库加推理机。落地场景是石油勘探、气象预报、军事决策、经济预测，1996 年之后的深蓝和 Watson 也属于这一路。这一代 AI 与普通软件没有本质差别，AI 等于 IT：规则可读、可审计、可写测试用例，代价是长尾场景覆盖不了。

2.2 近代（1996—2006）：模型、目标、策略三要素与特征工程

第三次浪潮转向统计学习，三个核心要素是模型、目标、策略，其中模型是核心：逻辑回归、决策森林、支持向量机、马尔可夫链、人工神经元。建模方法从数学模型（分析数学）转向数据模型（计算数学），能力边界也随之明确——数据模型可以模拟世界，但"以史为鉴"成立的前提是 IID，即训练数据和线上数据同分布。分布一变，模型就退化，这是整套方法最硬的约束。

同期的连接主义属于机器学习的一种方法，模型采用人工神经网络。有个判断值得记住：人工神经网络与人脑最大的共同点是名字，原理、机制和架构并不一样，它本质上是拿神经网络去表达数学模型。霍普菲尔德网络、玻尔兹曼机属于传统神经网络，2006 年 Hinton 把网络加深才有了深度学习。讲义把这一代的软件称为软件 2.0——人工智能是数学、物理学、计算机科学的混合体。

2.2.1 手工特征与端到端的第一次分家

把"特征谁来挑"变成可测量的数字，比概念争论有用得多。

# AI 0.1 与 AI 1.0 的分界线：特征是人挑的，还是模型自己学的 import numpy as np from sklearn.datasets import load_digits from sklearn.linear_model import LogisticRegression from sklearn.model_selection import cross_val_score from sklearn.pipeline import make_pipeline from sklearn.preprocessing import StandardScaler X, y = load_digits(return_X_y=True) # 8x8 灰度图，展平成 64 维 # 路线 A：人工特征工程，只保留"笔迹密度"和"上下半场差值"两个特征 feat = np.c_[X.mean(axis=1), (X[:, :32].sum(axis=1) - X[:, 32:].sum(axis=1))] # 路线 B：端到端，原始 64 维像素直接喂进去 for name, data in [("hand-crafted", feat), ("end-to-end", X)]: clf = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000)) score = cross_val_score(clf, data, y, cv=5).mean() print(f"{name:>12} 特征维度={data.shape[1]:>3} 准确率={score:.3f}")

逻辑说明：路线 A 只有 2 维，训练快、可解释，但丢掉了局部纹理；路线 B 保留原始像素，可线性模型在像素空间里学不到平移不变性，准确率同样上不去。真正的跃升要等 CNN 把特征抽取也塞进可导的端到端链路。这段代码的意义是把"特征工程交给谁"变成一行可比数字。

参数说明：cv=5 是五折交叉验证，样本量小时方差大，建议同时看每折分数；max_iter=1000 提高迭代上限，避免标准化后的数据上出现不收敛告警；StandardScaler 两条路线都要加，否则量纲差异会让梯度下降走偏。

2.3 现代到当代：Transformer 解码器路线为什么赢了

AI 1.0（2006—2020）是传统深度学习：深度神经网络、中数据集、端到端。模型家族包括 DBN、CNN、RNN、ResNet、Inception、RWKV。里程碑有三个：AlphaGo 2016 年超过人类棋手，ImageNet 2017 年超过人眼，AlphaFold 2022 年超过人类科学家并于 2024 年获诺贝尔奖。落地覆盖人脸识别、图像识别、语言翻译、语音识别和物理建模。

2017 年的 Transformer 把数据规模推到海量、把注意力机制做成大规模并行，分出三种架构：编码器（BERT 一路，做 embedding）、混合网络（T5、早期 GLM）、解码器（GPT 一路，生成式 AIGC）。工程上解码器胜出的原因很朴素：并行矩阵计算能吃满 GPU，堆叠架构容易横向扩展，预训练目标是预测下一个 token，不需要人工标注。这就是"大力出奇迹"的工程底座。

2020 年后进入 AI 2.0，模型以服务形态交付（MaaS），架构几乎全是 Transformer 解码器，参数量进入 B 级（Billion，十亿）。模型分语言、视觉、多模态三类；按用途又分通用模型和垂直模型——传媒、广告、编码、电商接近成熟，教育、医疗、金融、工业、农业仍在发展中。

2.4 四个时代的对照表和选型判断

对照这张表，选型顺序通常是：需求是否确定，确定就用 IT 方案；不确定但样本少，用 AI 0.1；要处理图像语音且样本充足，用 AI 1.0；需要跨模态、通用、少样本，才上 AI 2.0。还有一条容易忽略的分水岭：互联网时代用户使用系统的边际成本接近零，大模型时代每一次调用都要消耗 GPU 算力，边际成本实打实存在，这直接决定了产品能不能免费铺量。

3. NTP 与 Transformer：一次 token 预测到底算了什么

大模型的"思考"被拆开后其实只有一件事：给定上下文，预测下一个 token 的概率分布，然后按分布采样，再把采样结果拼回上下文，重复。理解这条链路，参数调节和故障排查才有落脚点。

3.1 分词：提示词进入模型前的第一道工序

提示词"今天天气不错，我决定"进模型后会被切成["今天","天","气","不","错",",","我","决定"]。这里处理的不是"字"，是 token——可做语义计算的最小单位。中文一个字常占 1 到 2 个 token，标点、换行、Markdown 符号往往各占 1 个。

# 估算一次请求的输入长度：token 数直接决定成本和上下文占用 import tiktoken enc = tiktoken.get_encoding("cl100k_base") # 常见编码表，实际以所用模型为准 prompt = "今天天气不错，我决定去公园散步，请用三句话说明选择路线时需要考虑的因素。" ids = enc.encode(prompt) print("token 数:", len(ids)) print("前 10 个 token:", [enc.decode([i]) for i in ids[:10]]) # 粗算成本：单价按每百万 token 计，数值须替换为实际报价 price_per_million = 0.0 print("单次输入成本:", len(ids) / 1_000_000 * price_per_million)

逻辑说明：分段结果会暴露两件事——中文的实际 token 消耗常比字符数少，但标点和 Markdown 符号会额外吃预算；同一段文本在不同分词器下长度可能差两成以上，做成本建模必须用目标模型自己的分词器。

参数说明：cl100k_base 只是一种编码表，换模型要换对应编码名，否则算出来的长度对不上账单。多轮场景要把系统指令、历史对话、工具返回全部计入，只统计用户那一句是最常见的低估来源。

3.2 概率、温度与 top-p：采样参数改的是什么

NTP 的流程是：收到提示词 → 拆 token → 交给 Transformer 识别 token 之间的关系和整体含义 → 为下一个 token 分配概率 → 按概率选一个 → 自回归重复直到句子结束。示例里的分布是{"去":0.7, "停":0.2, "站":0.1}，选中"去"就得到"今天天气不错，我决定去公园"。

import math def softmax(logits, temperature=1.0): """temperature 越小分布越尖锐，越大越平坦""" scaled = [x / max(temperature, 1e-6) for x in logits] m = max(scaled) exps = [math.exp(x - m) for x in scaled] # 减最大值防溢出 s = sum(exps) return [e / s for e in exps] def top_p_filter(probs, top_p=0.9): """按概率从大到小累加，截到累计概率刚好超过 top_p 的位置""" pairs = sorted(enumerate(probs), key=lambda kv: kv[1], reverse=True) kept, acc = [], 0.0 for idx, p in pairs: kept.append((idx, p)); acc += p if acc >= top_p: break total = sum(p for _, p in kept) return {idx: p / total for idx, p in kept} logits = [3.2, 2.1, 0.4, -1.0, 0.9] # 假想 5 个候选 token 的原始分数 for t in (0.2, 1.0, 1.8): probs = softmax(logits, t) sampled = top_p_filter(probs, 0.9) print(f"T={t:<4} 最高概率={max(probs):.3f} 截断后候选数={len(sampled)}")

逻辑说明：温度不改排序，只改分布陡峭程度。T 趋近 0 时几乎等价于每个位置取最大概率，输出稳定但容易重复；T 大于 1 时低概率 token 被抬起来，输出多样但容易跑题。top-p 负责砍长尾，两个参数组合是工程上最常用的写法。

参数说明：需要确定性输出（结构化抽取、代码生成、字段填充）时用 T=0 或 0.1、top_p=1.0；需要发散（文案、起名）时 T 取 0.8 到 1.2、top_p 取 0.9 到 0.95。温度不是"智能旋钮"，调高只会让模型更愿意赌低概率分支。

3.3 预训练—后训练—推理：三段的产物和成本结构

模型训练分预训练和后训练，推理是另一件事。预训练是自监督，学的是下一个 token 的分布，相当于打基础；后训练包含监督微调和基于人类反馈的强化学习等，相当于给专业结构；微调和 Prompt 相当于入职实习，让它能干活。

推理阶段四步：接收输入（提示词）、处理输入（上下文）、进行推理（测试时计算 TTC）、生成输出。生成模型和推理模型在推理阶段的差别在于，前者直接出答案，后者先展开一段较长的思考过程再出答案，输出 token 常高出一个量级，成本结构随之改变。

讲义列了十条关键要素，可以直接当检查表：Token、Attention（熵减即智能）、GPT（大力出奇迹）、Data（以古鉴今）、RL（决策、探索未知、生成数据）、优化（卷 Infra 和算法）、FT（后训练的艺术）、TTC（测试时计算）、Prompt（有话好好说）、Agent（最后的筐）。

3.4 用 logprobs 验证：把黑盒打开一条缝

排查"模型答错了"时，光看答案没用，看关键位置的概率分布能区分三种病因。

注意：logprobs 只能告诉你模型对某个位置的确定程度，不能当成事实校验器。高概率输出照样可能是幻觉，关键业务字段必须走外部校验。

4. 能力边界：幻觉、上下文窗口与 Prompt/CoT/RAG/微调的取舍

大模型落地的绝大多数问题，本质是没分清"能力不足"和"边界如此"。分清之后，解决方案的优先级会变得很清楚：先用提示词和思维链榨干现有模型，再考虑外挂知识，最后才动微调。

4.1 三类边界：语言、知识、推理

语言能力负责理解和生成，这是大模型最稳的部分。知识能力问题最多：知识量大但缺少内在关联，且受三重限制——知识库限制（公开知识容易，私有知识和即时信息很难）、上下文窗口限制（既是记忆问题也是成本问题）、幻觉（生成不符合事实的内容）。幻觉的根源有两条，一是训练数据对世界是有损压缩，二是 NTP 的采样机制本身带随机性，温度越高越明显。

推理能力则涉及多轮对话的产品设计和计算成本取舍：让模型先想再答能提升准确率，但输出 token 和延迟同步上涨。讲义给的解决路径有五条：提示词、思维链、搜索增强、知识图谱、模型微调。这五条的排序不是随意的，成本从低到高，生效速度从快到慢。

4.2 Prompt 与 CoT：先改输入，别急着动模型

# 同一道题，两种提示词写法：直接问答 vs 先列条件再求解 DIRECT = """{q} 只输出最终答案。""" COT = """{q} 按下面步骤作答： 1. 列出题目给出的已知条件和单位； 2. 写出用到的公式； 3. 逐步代入计算，保留中间结果； 4. 最后一行以「答案：」开头输出结论。 每一步都要写出理由，不要跳步。""" q = ("某模型输入每百万 token 收费 3 元，输出每百万 token 收费 9 元。" "一次请求输入 1200 token、输出 800 token，一万次请求的总费用是多少元？") print(DIRECT.format(q=q)) print("-" * 40) print(COT.format(q=q))

逻辑说明：CoT 把一次性的模式匹配拆成多次中间生成，每一步输出都进入下一步上下文，相当于用 token 换准确率。它在多步运算和条件判断任务上收益明显；对纯记忆型问题，加 CoT 只是多花钱。

参数说明：第 4 步强制"答案："前缀，是为了后续用正则抽取，属于结构化输出的低成本替代。接口支持 JSON Schema 约束时优先用原生结构化输出，比让模型自觉写格式稳得多。CoT 步骤不是越多越好，超过 6 到 8 步后模型容易中途自造条件。

4.3 RAG 最小链路：切块、召回、拼上下文

import math, re from collections import Counter def tokenize(text): # 中文按字切、英文按词切，零依赖 return re.findall(r"[a-zA-Z0-9]+|[\u4e00-\u9fa5]", text.lower()) def chunk(doc, size=200, overlap=40): """按字符滑窗切块，overlap 防止答案被切断""" out, i = [], 0 while i < len(doc): out.append(doc[i:i + size]) i += size - overlap return out def bm25_lite(query, chunks, k1=1.5, b=0.75): """简化版 BM25：不接向量库也能先跑起召回基线""" tfs = [Counter(tokenize(c)) for c in chunks] df = Counter() for tf in tfs: df.update(tf.keys()) n, avgdl = len(chunks), sum(len(c) for c in tfs) / len(chunks) q = set(tokenize(query)); scores = [] for tf, c in zip(tfs, chunks): dl, s = sum(tf.values()), 0.0 for term in q: if term not in tf: continue idf = math.log(1 + (n - df[term] + 0.5) / (df[term] + 0.5)) s += idf * tf[term] * (k1 + 1) / (tf[term] + k1 * (1 - b + b * dl / avgdl)) scores.append((s, c)) return sorted(scores, key=lambda x: -x[0])[:3] doc = "把计费说明、限额说明、错误码说明拼成一段长文本放进来。" * 30 chunks = chunk(doc) for score, c in bm25_lite("输出 token 怎么计费", chunks): print(round(score, 3), c[:60])

逻辑说明：先用零依赖的 BM25 把召回基线跑通，再决定要不要上向量检索。不少团队一上来就搭向量库，结果召回质量还不如关键词，问题往往出在切块——块太大会稀释关键词权重，块太小会把一个完整结论切成两半，overlap 就是让边界处的句子在两块里都出现。

参数说明：size=200、overlap=40 是中文技术文档的经验起点；k1 控制词频饱和速度，越大高频词权重越高；b 控制长度归一化，b=0 不归一化，b=1 完全归一化。拼上下文时给每个片段带上来源标识和块序号，模型引用时才有据可依。

4.4 微调的适用条件与常见误用

微调解决的是格式和风格，不是知识更新。知识更新首选 RAG 或把文档塞进上下文；改格式、改语气、固化领域术语，才轮到微调。

提示：遇到模型答错，按 Prompt → CoT → RAG → 微调的顺序排查。跳过前三步直接微调，通常是拿高成本去补一个改提示词就能解决的问题。

5. Agent 工程：感知—决策—行动的闭环怎么落地

大模型的应用已经从对话工具进化为任务导向、直接交付结果的 Agent。落到工程上，Agent 不是新模型，而是一套围绕大模型的循环结构，难点全在循环的退出条件、上下文拼装和工具设计上。

5.1 Embedding、Copilot、Agent：三种人机分工

讲义把三种模式的分工讲得很清楚。Embedding 是助手模式：人类完成绝大部分工作，AI 提供信息或建议，人类自主结束。Copilot 是伙伴模式：人类设立任务目标，AI 对其中某几个流程提供资源或初稿，人类修改调整确认。Agent 是代理模式：任务拆分、工具选择、进度控制都由 AI 完成，人类只设立目标并监督结果。

核心架构三件套是感知（多模态输入）、决策（LLM，加上记忆、检索、上下文）、动作（具身驱动、工具调用）。核心特征只有一个词：自主，即从 human in the loop 走向 human on loop。工程上的分界线也在这里——Agent 每一步都要花钱，所以"能不能不让人盯"和"值不值得不让人盯"是两个独立问题。

5.2 上下文工程：记忆、检索、上下文怎么排

上下文拼装要按稳定到变化的顺序，方便命中缓存：系统指令（角色、边界、输出格式）→ 长期记忆（用户偏好、历史结论）→ 检索结果（带来源标注）→ 工具返回（截断加摘要）→ 当前任务。这个顺序不是形式主义，前缀越稳定，缓存命中率越高，成本越低。

工具返回是最容易撑爆窗口的一环。一条日志查询返回几万字符是常态，先在工具层截断再进上下文，比事后让模型总结可靠得多。记忆也不能无脑全塞：多轮对话的历史要么做摘要压缩，要么只保留结论行，否则第三轮之后每次请求都在为前两轮的废话付费。

5.3 工具调用循环的最小实现

import json TOOLS = [{ "type": "function", "function": { "name": "query_order", "description": "按订单号查询订单状态，只返回状态和更新时间", "parameters": { "type": "object", "properties": {"order_id": {"type": "string", "description": "订单号，纯数字"}}, "required": ["order_id"], }, }, }] def run_agent(client, question, max_steps=6): messages = [ {"role": "system", "content": "你是订单助手。需要数据时调用工具，不要凭记忆回答。"}, {"role": "user", "content": question}, ] for step in range(max_steps): resp = client.chat.completions.create( model="<你的模型名>", messages=messages, tools=TOOLS, temperature=0, # 决策步骤要确定性 ) msg = resp.choices[0].message messages.append(msg) if not msg.tool_calls: # 不再请求工具即认为给出最终答案 return msg.content, step + 1 for call in msg.tool_calls: args = json.loads(call.function.arguments) # 参数可能缺失或类型不对 result = query_order(**args) if "order_id" in args else "参数缺失：order_id" messages.append({ "role": "tool", "tool_call_id": call.id, "content": str(result)[:2000], # 截断，防止撑爆窗口 }) return "已达最大步数，未得到结论", max_steps

逻辑说明：循环的退出条件必须有两个——模型不再请求工具，或者步数触顶。第二个条件是硬性保护，否则参数格式反复出错时模型会一直重试。temperature=0 是因为决策步骤要的是稳定复现，不是创意。

参数说明：max_steps=6 是常见起点，步数越多上下文越长、成本越高；超过十步还没结论，通常是工具设计有问题而不是模型不行。工具返回截断到 2000 字符是底线保护，返回体里塞整张表或整页 HTML 是最常见的翻车点。工具描述里写明"只返回状态和更新时间"，等于给工具本身加了一层输出约束，比事后求模型总结可靠。

5.4 自主性带来的故障面与验收指标

死循环的兜底思路是做参数指纹，同一个工具同样的参数第二次出现就直接返回错误让模型换路。越权的原则是把写操作拆成生成待确认计划和实际执行两段，Agent 只能碰前一段。成本失控要给会话设 token 预算，不是给单次请求设，因为多步循环的问题恰恰出在单次看着都不贵。

验收指标建议记四个：任务完成率、平均步数、单次任务 token 成本、人工接管率。前两个衡量能力，后两个衡量能不能规模化。

6. 生成模型与推理模型：用一批题压出选型结论

生成模型和推理模型的差别不只是"想不想"，而是成本结构不同。生成模型定位在通用自然语言处理，多模态能力突出，适合日常对话、内容生成、翻译以及图文音视频处理，日常语言任务表现均衡，但复杂逻辑推理准确率偏低，交互流畅、界面友好。推理模型侧重复杂推理与逻辑能力，擅长数学、编程和自然语言推理，适合高难度问题求解和专业领域应用，会展示部分链式思考过程，交互节奏偏慢。

有个判断值得抄在本子上：生成模型是玩知识和文字的，推理模型是玩逻辑和推理的，至于计算问题，还是找计算器。推理模型也不是万能的，它的幻觉通常比生成模型更大，很多不需要强推理的场合，传统生成模型更合适。

# 选型压测：同一批题跑两个模型，看正确率、延迟和 token 成本三条曲线 import time def bench(client, model, cases, temperature=0): rows = [] for q, gold in cases: t0 = time.time() r = client.chat.completions.create( model=model, messages=[{"role": "user", "content": q}], temperature=temperature, ) dt = time.time() - t0 ans = r.choices[0].message.content.strip() rows.append({ "model": model, "latency_s": round(dt, 2), "in_tokens": r.usage.prompt_tokens, "out_tokens": r.usage.completion_tokens, # 关键：输入输出分开记 "correct": int(gold in ans), # 宽松判分可用包含匹配 }) return rows cases = [ ("一个数除以 7 余 3，除以 5 余 2，最小的正整数是多少？", "17"), ("把这句话改成 20 字以内的标题：促销活动即日起开始，数量有限。", "促销"), ]

逻辑说明：输入输出 token 必须分开记录，推理模型的输出 token 常是生成模型的好几倍，按总量算会低估差距。延迟也要区分首 token 时间和总时长，取决于产品是流式还是批处理。

参数说明：正确率判定用包含匹配只适合有唯一答案的题，开放式任务换小模型判分时要保证所有对比模型用同一套判分逻辑，否则对比不成立。样本量每类任务不少于 30 条，覆盖正常、边界、超纲三类。

落地结论可以这样压：日常对话、内容生成、多模态处理走生成模型；数学、代码、复杂逻辑、方案性输出走推理模型；需要精确计算的一律外挂计算器或代码执行工具。把同一批题在两个模型上各跑两遍，再用输出 token 的差值乘以各自单价，选型表基本会自己浮出来。

本文还有配套的精品资源，点击获取