返回专栏
· 18 分钟阅读

AI 为什么能够回答问题?从语言建模到知识表达,解析大模型的回答机制


当我们向 AI 提出一个问题,例如:

为什么天空是蓝色的?

AI 能够迅速组织语言,解释光线散射原理,甚至进一步给出公式、实验方法和相关知识。

看起来,它似乎真的理解了问题,并且知道答案。

但从技术角度来看,AI 并不是像人类一样,通过意识和主观经验思考问题。现代大语言模型能够回答问题,主要依赖于训练阶段学习到的语言规律、知识关联和任务模式,以及推理阶段对当前上下文进行计算和生成。

它需要完成一系列过程:

  1. 识别输入内容,将问题转换为 Token。
  2. 将 Token 转换为向量表示。
  3. 通过神经网络提取问题中的语义和上下文信息。
  4. 激活与当前问题相关的内部表示。
  5. 根据上下文计算可能的回答内容。
  6. 通过逐 Token 生成,组织成完整回答。

其中最关键的机制是:模型通过训练学习语言和知识的统计规律,在推理阶段根据输入上下文预测并生成回答。

本文从语言模型、知识学习、上下文理解、概率预测、推理能力和外部知识等角度,分析 AI 为什么能够回答问题,以及它的能力边界在哪里。


一、AI 回答问题的本质是什么?

传统软件通常根据开发人员编写的规则处理输入。

例如:

def add(a, b):
    return a + b

print(add(10, 20))

程序能够回答计算结果,是因为开发人员已经明确编写了计算规则。

但是,如果用户提出:

为什么 Python 使用缩进表示代码块?

传统程序很难仅凭固定规则生成一段完整、合理的技术解释。

大语言模型采用了不同的机制。

它通过大量文本数据进行训练,学习语言结构、知识关联和上下文模式。用户输入问题后,模型根据已经学习到的参数和当前上下文,计算并生成可能的回答。

1.1 从语言建模到问题回答

大语言模型的基础任务通常是语言建模。

以自回归语言模型为例,其核心目标是:

根据前面的 Token,预测下一个 Token。

例如:

输入:人工智能是一种

预测:能够

随后继续预测:

人工智能是一种能够

预测:模拟

最终可能生成:

人工智能是一种能够模拟人类智能行为的技术。

模型并不是预先存储了这句完整的话,而是在生成过程中,根据当前上下文不断计算下一个 Token 的概率分布。

数学上可以表示为:

P(x_1,x_2,\ldots,x_T) = \prod_{t=1}^{T}P(x_t|x_{<t})

其中:

  • x_t:第 t 个 Token。
  • x_{<t}:当前位置之前的 Token。
  • P(x_t|x_{<t}):根据前文预测当前 Token 的条件概率。

这个公式描述了自回归语言模型对序列联合概率的分解方式。

1.2 为什么预测下一个 Token 能够回答复杂问题?

这是理解大语言模型最重要的问题之一。

假设用户提出:

什么是数据库索引?

模型如果想生成一个合理的回答,就需要学习很多相关规律:

  • 数据库是什么。
  • 索引是什么。
  • 索引与查询之间有什么关系。
  • B+ 树是什么。
  • 为什么索引可以提高查询效率。
  • 索引有哪些使用成本。
  • 技术解释通常采用什么样的表达结构。

模型在训练过程中,通过大量文本学习这些知识之间的关联。

因此,当用户提出数据库索引问题时,模型可以根据上下文生成与这些知识关联较强的回答。

预测下一个 Token 是训练目标,但为了完成预测,模型需要学习能够支持预测的语言结构、知识关联和上下文表示。

这也是大语言模型能够表现出复杂问答能力的重要原因。

1.3 问题回答与普通文本生成有什么区别?

从底层生成机制看,问答和普通文本续写都可以使用自回归生成。

但两者的任务目标不同。

对比维度 普通文本续写 问答任务
输入 一段已有文本 一个明确的问题
主要目标 延续已有内容 生成与问题相关的回答
上下文作用 提供续写条件 提供问题、指令和对话信息
输出要求 保持文本连贯 相关性、准确性、完整性
训练支持 语言建模 语言建模、指令微调等

现代大语言模型通常在预训练之后,还会经过监督微调、偏好对齐等训练,使模型更擅长识别问题、遵循指令和组织回答。


二、AI 如何从训练数据中学习知识?

AI 能够回答各种问题,并不是因为它在回答时实时阅读了所有知识,而是因为它在训练阶段已经从大量数据中学习到了有用的信息表示。

2.1 预训练:从海量文本中学习语言和知识

预训练(Pre-training)是大语言模型建立基础能力的重要阶段。

模型通常使用大规模文本、代码以及其他模态的数据进行训练。

常见数据来源包括:

  • 网页文本。
  • 书籍和文档。
  • 学术论文。
  • 技术文档。
  • 代码仓库。
  • 新闻和公开资料。
  • 其他经过处理的数据集。

以自回归语言模型为例,训练样本可以组织为:

原始文本:
数据库索引可以提高查询效率。

训练输入:
数据库索引可以提高查询

预测目标:
效率

模型根据输入上下文预测目标 Token,并通过损失函数衡量预测误差。

典型的训练目标为:

L(\theta)= -\sum_{t=1}^{T} \log P_\theta(x_t|x_{<t})

其中:

  • \theta:模型参数。
  • x_t:真实的目标 Token。
  • P_\theta:由模型参数决定的预测概率。

模型通过反向传播和优化器不断调整参数,使训练目标逐渐得到优化。

2.2 模型到底从数据中学到了什么?

模型学习到的并不只是词语之间的搭配关系。

随着模型规模、训练数据和训练方法的发展,模型可以形成多层次的内部表示。

例如:

语言结构

  • 词语搭配。
  • 句法结构。
  • 语法规则。
  • 语言表达方式。

概念知识

  • 人物、地点和事物。
  • 技术概念。
  • 历史事件。
  • 科学知识。

关系知识

  • 概念之间的上下位关系。
  • 事物之间的关联。
  • 因果关系的语言表达。
  • 技术组件之间的依赖关系。

任务模式

  • 如何解释概念。
  • 如何比较两个技术方案。
  • 如何总结一篇文章。
  • 如何根据要求生成代码。
  • 如何按照指定格式组织内容。

需要注意,模型内部并不是简单地保存了一张人类可读的知识表。

这些信息通常以分布式方式编码在大量模型参数和中间表示中。

2.3 模型参数为什么能够保存知识?

神经网络由大量可学习参数构成。

例如,一个简单的神经网络层可以表示为:

h=f(Wx+b)

其中:

  • x:输入向量。
  • W:权重矩阵。
  • b:偏置。
  • f:激活函数。
  • h:输出表示。

在训练过程中,模型通过调整 W 和 b 等参数,逐渐改变输入信息在网络中的转换方式。

对于大型语言模型来说,参数规模可能达到数十亿甚至更多。

这些参数共同构成模型对训练数据规律的编码。

可以将其理解为:

  • 训练数据提供信息。
  • 神经网络提供表示和计算结构。
  • 参数更新将学习结果编码到模型中。

因此,模型在训练完成后,即使不再访问原始训练数据,也能够利用已经学习到的参数生成回答。

但这并不意味着模型能够完整、准确地回忆训练数据中的所有内容。

2.4 预训练并不等于已经学会回答问题

预训练主要让模型掌握语言建模能力。

一个经过预训练的模型,可能擅长文本续写,但不一定擅长按照用户要求完成问答任务。

例如:

用户:请用三句话解释什么是 Redis。

模型需要知道:

  • 用户正在提问。
  • 用户希望得到解释。
  • 输出长度应该受到限制。
  • 回答应当围绕 Redis。
  • 表达方式应该清晰、直接。

这些能力通常还需要通过指令数据和后训练进一步强化。


三、为什么 AI 能够理解用户的问题?

模型学习了大量知识,并不意味着它可以直接回答任意输入。

它还需要理解当前问题的含义,识别用户想要完成的任务,并结合上下文生成相关内容。

这里涉及 Tokenization、Embedding、Attention 和 Transformer 等核心技术。

3.1 Tokenization:将问题转换为 Token

假设用户输入:

为什么 Redis 的查询速度比较快?

模型首先需要通过 Tokenizer 将文本切分为 Token。

示意:

["为什么", "Redis", "的", "查询", "速度", "比较", "快", "?"]

实际切分结果取决于模型使用的 Tokenizer。

随后,每个 Token 会对应一个 Token ID。

例如:

X=[t_1,t_2,\ldots,t_n]

此时,模型得到的是一个离散的 Token 序列。

3.2 Embedding:将问题转换为向量

Token ID 只是词表索引,无法直接表达完整的语义关系。

模型通过 Embedding 将 Token ID 映射为连续向量:

e_i=W_E[t_i]

其中:

  • W_E:Embedding 矩阵。
  • t_i:Token ID。
  • e_i:Token 对应的向量。

经过这一步,文本就被转换为模型可以进行矩阵运算的数值表示。

3.3 Attention:建立问题内部的关联

用户提出:

为什么 Redis 的查询速度比较快?

模型需要识别其中的关键概念和关系:

  • Redis:讨论对象。
  • 查询速度:关注的性能指标。
  • 为什么:要求解释原因。
  • 比较快:需要分析性能优势。

Attention 机制能够让不同 Token 根据上下文动态聚合其他位置的信息。

其核心计算公式为:

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

其中:

  • Q:Query。
  • K:Key。
  • V:Value。
  • d_k:Key 的维度。

模型通过注意力权重,对不同位置的信息进行加权组合,从而形成上下文相关的表示。

3.4 Transformer:综合处理上下文信息

现代大语言模型通常采用 Transformer 或其变体。

一个典型 Transformer Block 包含:

  • 自注意力机制。
  • 前馈神经网络。
  • 残差连接。
  • 归一化结构。

模型通过多层网络不断处理输入表示,使其逐渐形成更适合当前任务的上下文表示。

可以将这一过程抽象为:

flowchart TB
    A["用户输入问题"] --> B["Tokenization"]
    B --> C["Token ID 序列"]
    C --> D["Embedding"]
    D --> E["加入位置信息"]
    E --> F["Transformer Block"]

    F --> G["Attention"]
    G --> H["前馈神经网络"]
    H --> I["残差连接与归一化"]
    I --> J{"是否还有网络层"}

    J -->|"是"| F
    J -->|"否"| K["最终上下文表示"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style I fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style J fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style K fill:#DCEFE5,stroke:#4F8B70,color:#24563F

需要注意,Transformer 并不是简单地先提取关键词,再去知识库中查找答案。

它通过多层神经网络对输入序列进行计算,形成包含上下文信息的隐藏状态。

3.5 为什么同一个问题在不同上下文中会得到不同回答?

大语言模型的输出受到整个输入上下文影响。

例如:

用户:我正在学习 Java。

用户:什么是接口?

模型结合历史对话,通常会优先从 Java 编程的角度解释接口。

而如果上下文是:

用户:我正在学习网络通信。

用户:什么是接口?

模型就可能从网络接口、通信接口等角度进行解释。

这说明模型并不是只根据当前一句话中的关键词生成回答,而是会利用可用上下文中的信息。


四、AI 如何从知识关联中找到答案?

这是 AI 问答机制中最值得深入理解的部分。

当模型收到问题后,它并不是像传统数据库一样,通过固定查询语句查找一条记录。

它主要依赖训练过程中形成的参数表示,以及当前输入经过神经网络计算得到的上下文表示。

4.1 模型内部的知识不是简单的数据库记录

假设模型学习过以下内容:

Redis 是一种内存数据库。
Redis 支持多种数据结构。
Redis 通常使用内存存储数据。
Redis 支持多种持久化机制。

当用户提出:

为什么 Redis 查询速度比较快?

模型可能会生成:

Redis 将大量数据存储在内存中,
减少了传统磁盘访问带来的延迟。
同时,它采用高效的数据结构和
较为优化的执行机制。

这个过程并不一定对应某一条训练文本的直接检索。

模型可能综合了多条训练信息中学习到的关联模式。

例如:

  • Redis 与内存存储相关。
  • 内存访问通常比机械磁盘访问延迟低。
  • 数据结构会影响查询复杂度。
  • 执行模型和网络开销也会影响实际性能。

模型根据这些关联组织回答。

4.2 参数化知识:知识如何存储在模型中?

大语言模型中的知识通常被称为参数化知识(Parametric Knowledge)。

它指的是模型通过训练,将信息规律编码到模型参数之中。

其特点包括:

  • 不需要每次回答都访问原始训练数据。
  • 可以根据输入上下文生成相关内容。
  • 能够对不同信息进行组合。
  • 知识更新通常需要通过训练、微调或外部信息补充。
  • 难以直接定位某条知识具体存储在哪个参数中。

参数化知识不是传统意义上的关系数据库,也不是可以直接查询的知识图谱。

4.3 知识关联如何支持问题回答?

可以用一个简化的概念关系图理解:

flowchart TB
    A["Redis"] --> B["内存数据库"]
    A --> C["数据结构"]
    A --> D["持久化机制"]

    B --> E["内存访问"]
    C --> F["数据操作效率"]
    D --> G["数据可靠性"]

    E --> H["查询性能"]
    F --> H

    H --> I["回答:Redis 为什么查询速度快"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F

这张图是为了说明知识之间可能存在的关系,并不代表大语言模型内部真的保存了这样一张显式关系图。

模型内部的知识表示通常更加复杂,分布在不同层和参数中。

4.4 为什么模型能够回答没有见过的组合问题?

假设模型分别学习过:

  • Python 的装饰器。
  • 函数。
  • 闭包。
  • 参数传递。
  • 高阶函数。

用户提出:

如何使用装饰器实现一个带参数的函数执行耗时统计?

模型可能没有见过完全相同的问题和代码,但可以结合已经学习到的知识,生成一个新的解决方案。

这种能力与泛化(Generalization)有关。

模型通过训练学习到的规律,不仅能够用于训练样本本身,也可能迁移到新的输入组合中。

不过,泛化能力并不意味着模型可以可靠地解决所有未见过的问题。任务复杂度、知识覆盖、输入条件和推理能力都会影响结果。


五、AI 为什么能够进行推理?

如果 AI 只能记住训练数据中的句子,那么它的能力会非常有限。

但实际的大语言模型能够完成比较、归纳、数学计算、代码分析和多步骤问题处理。

这涉及模型的推理能力。

5.1 什么是推理?

推理是根据已有信息、条件和规则,得出新的结论。

例如:

条件一:所有的 A 都属于 B。
条件二:C 属于 A。
结论:C 属于 B。

这属于典型的演绎推理。

在实际技术任务中,推理可能表现为:

  • 根据错误日志定位故障。
  • 根据代码判断执行结果。
  • 根据多个条件分析方案。
  • 根据已知事实进行数学计算。
  • 根据业务规则判断是否满足条件。

5.2 大语言模型如何表现出推理能力?

模型的推理能力通常与以下因素有关:

1. 训练数据

训练数据中包含大量问题、解释、证明、代码和解决方案。

模型能够从这些样本中学习问题结构和解决模式。

2. 模型规模与表示能力

更大的模型可能拥有更强的表示能力,但能力提升并不只由参数数量决定。

3. 指令微调

通过高质量指令数据,让模型学习如何遵循要求、组织步骤和完成复杂任务。

4. 推理专项训练

部分模型会通过数学、代码、逻辑题和强化学习等方式,进一步优化复杂问题处理能力。

5. 推理时计算

模型在推理阶段可以利用更多计算资源,执行多步骤生成、候选结果比较或其他推理过程。

5.3 多步骤推理

例如,用户提出:

一个服务每秒处理 200 个请求,
每个请求平均消耗 50 毫秒 CPU 时间,
需要多少个 CPU 核心才能满足需求?

模型需要识别:

  • 每秒请求数:200。
  • 单个请求 CPU 时间:50 毫秒。
  • 总 CPU 时间:200 × 50 毫秒。
  • 每秒 CPU 时间总量:10000 毫秒。
  • 一个 CPU 核心每秒提供约 1000 毫秒 CPU 时间。

因此:

200\times50=10000\text{ ms}
\frac{10000}{1000}=10

理论上需要约 10 个 CPU 核心才能满足这一平均计算量。

实际部署还需要考虑峰值流量、并发模型、I/O 等待、CPU 利用率和系统开销。

这个例子展示了模型如何将一个问题拆分成多个计算步骤,再组合得到结果。

5.4 推理能力不等于每次推理都正确

大语言模型的推理能力并不意味着它始终能够正确完成逻辑计算。

可能出现:

  • 中间步骤错误。
  • 条件遗漏。
  • 数学运算错误。
  • 错误地应用某个规则。
  • 将相关性误认为因果关系。
  • 根据不充分的信息得出确定结论。

对于要求高准确性的任务,可以结合代码执行、计算器、数据库查询、专业工具和外部验证机制。

5.5 推理时计算与普通文本生成

普通文本生成通常侧重于根据上下文直接产生后续内容。

推理型任务可能需要更多计算过程,例如:

  • 生成多个候选方案。
  • 对中间结果进行检查。
  • 进行多轮计算。
  • 调用外部工具。
  • 验证某个结论是否满足约束。

不同模型采用的具体机制并不相同。

不能简单认为所有大语言模型都会显式生成完整的思考过程,也不能将模型输出的解释文字直接等同于模型内部真实计算过程。


六、AI 如何组织答案并生成完整内容?

理解问题和找到相关信息之后,模型还需要把信息组织成用户能够阅读的答案。

这一步主要依赖自回归生成机制和解码策略。

6.1 从隐藏状态到概率分布

经过 Transformer 网络处理后,模型得到当前预测位置的隐藏状态:

h_t

随后通过输出投影层得到 Logits:

z_t=h_tW_U+b_U

其中:

  • h_t:当前隐藏状态。
  • W_U:输出投影矩阵。
  • b_U:偏置项。
  • z_t:词表中各 Token 对应的未归一化分数。

然后通过 Softmax 得到概率分布:

P(x_i)= \frac{e^{z_i}}{\sum_j e^{z_j}}

模型根据这个概率分布,选择或采样下一个 Token。

6.2 模型如何决定下一个 Token?

假设模型当前需要生成一个技术解释:

Redis 的主要优势在于

模型可能得到如下示意概率分布:

候选 Token 概率
内存 0.62
高性能 0.18
数据结构 0.12
其他 0.08

这里的概率仅用于说明。

模型根据解码策略选择一个 Token,再将其加入当前上下文。

假设选择了“内存”,上下文就变为:

Redis 的主要优势在于内存

接下来,模型再次计算下一个 Token 的概率分布。

如此反复,最终生成完整回答。

6.3 Temperature:控制生成随机性

Temperature 用于调整 Softmax 前的 Logits:

P_i= \frac{\exp(z_i/T)}

其中:

  • z_i:Token 的 Logit。
  • T:Temperature。

通常:

  • 较低的 Temperature 会让概率分布更加集中。
  • 较高的 Temperature 会让概率分布更加平滑。

Temperature 不会让模型真正增加知识,也不能保证输出更加准确。

它主要影响生成时的随机性和候选 Token 的选择倾向。

6.4 Top-K 与 Top-P

Top-K

只保留概率最高的 K 个候选 Token,再进行采样。

Top-P

保留按照概率从高到低排列后,累计概率达到指定阈值的最小候选集合,再进行采样。

这两种方法都用于限制采样范围,但具体效果还取决于 Temperature 和模型输出分布。

6.5 完整回答是如何生成的?

flowchart TB
    A["问题与上下文"] --> B["Transformer 计算"]
    B --> C["生成隐藏状态"]
    C --> D["输出投影"]
    D --> E["Logits"]
    E --> F["Softmax 概率分布"]
    F --> G["解码策略"]
    G --> H["选择下一个 Token"]
    H --> I{"是否达到停止条件"}

    I -->|"否"| J["加入已有上下文"]
    J --> B
    I -->|"是"| K["形成完整回答"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style I fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style J fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style K fill:#DCEFE5,stroke:#4F8B70,color:#24563F