返回专栏
· 14 分钟阅读

Context Window 上下文窗口:大语言模型如何理解和处理有限长度的上下文?


一、什么是 Context Window?

Context Window(上下文窗口) 是大语言模型在一次推理过程中,能够接收和处理的最大上下文 Token 数量。

它通常以 Token 为单位,而不是字符数、单词数或字节数。

例如,一个模型的上下文窗口为 128K Tokens,表示它在一次模型调用中,能够处理的上下文长度上限约为 128,000 个 Token。

上下文通常包含:

  • System Prompt:系统指令。
  • User Prompt:用户当前输入。
  • Conversation History:历史对话。
  • Tool Messages:工具调用及工具返回结果。
  • Retrieved Context:RAG 检索得到的外部资料。
  • Other Metadata:模型接口或对话模板中包含的其他内容。

需要注意:上下文窗口并不等于模型能够生成的最大输出长度。模型通常还会单独设置最大输出 Token 数量,并且输入与输出长度可能共同受到总上下文预算约束。

1. Context Window 的基本组成

一次模型调用的上下文可以抽象为:

System Prompt
    +
Conversation History
    +
Current User Input
    +
Retrieved Context
    +
Tool Messages
    =
Model Context

这些内容经过对话模板组织和 Tokenizer 编码后,形成模型实际处理的 Token 序列。

可以用下面的结构理解:

flowchart TB
    A["一次模型调用"] --> B["System Prompt"]
    A --> C["历史对话"]
    A --> D["当前用户输入"]
    A --> E["外部检索内容"]
    A --> F["工具调用与返回结果"]
    B --> G["对话模板与 Tokenizer"]
    C --> G
    D --> G
    E --> G
    F --> G
    G --> H["Token 序列"]
    H --> I["Context Window"]
    I --> J["Transformer 推理"]

    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:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style H fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style J fill:#E5F0E9,stroke:#83A995,color:#315D49

二、Context Window 的长度如何计算?

上下文窗口的容量由 Token 数量决定。

假设模型的上下文窗口为 32K Tokens,那么一次请求中需要纳入上下文的所有 Token 都必须满足模型的长度限制。

1. Token 不等于字符

Token 是 Tokenizer 根据词表和切分算法生成的离散文本单位。

不同语言、不同文本类型的 Token 密度存在明显差异。

例如:

  • 英文单词可能对应一个或多个 Token。
  • 中文字符可能对应一个或多个 Token。
  • 标点符号可能独立形成 Token,也可能与其他文本合并。
  • 代码中的变量名、运算符和缩进可能被拆分成多个 Token。
  • 特殊 Token 用于表示消息边界、角色、工具调用等结构。

因此,不能简单地通过字符数量计算上下文长度。

假设输入文本经过 Tokenizer 编码后得到:

X=(x_1,x_2,\ldots,x_n)

其中:

  • X:Token 序列。
  • x_i:第 i 个 Token。
  • n:Token 总数。

那么上下文长度就是:

L_{\text{context}}=n

2. 上下文窗口的预算分配

实际推理时,需要考虑输入 Token 和输出 Token 的预算。

一种常见的预算关系是:

L_{\text{input}}+L_{\text{output}}\leq L_{\text{limit}}

其中:

  • L_{\text{input}}:输入上下文长度。
  • L_{\text{output}}:预留的输出长度。
  • L_{\text{limit}}:当前请求允许使用的总长度上限。

例如,假设某模型允许使用 32K Token:

项目 Token 数量
System Prompt 1,000
历史对话 12,000
当前问题 2,000
RAG 检索内容 10,000
输入合计 25,000
预留输出 7,000
总计 32,000

这意味着,如果输入内容继续增长,就必须压缩输入、减少历史记录、减少检索内容,或者调整输出预算。

需要注意,不同模型和 API 对输入上限、输出上限以及两者是否共享上下文预算的定义可能不同,不能把上面的公式当成所有服务的统一接口规则。

3. Context Window 不只是用户输入

一个容易忽略的问题是:

用户看到的文本长度,不一定等于模型实际接收的 Token 数量。

模型实际输入还可能包括:

  • System Prompt 和开发者指令。
  • 消息角色标记。
  • 工具调用协议。
  • 多模态内容对应的内部表示。
  • 历史对话和隐藏的结构化元数据。

因此,不能只统计用户输入文本,就认为已经准确计算了上下文占用。

三、Context Window 在 Transformer 中如何工作?

Context Window 不只是 API 层面的长度限制,它与 Transformer 的序列处理机制密切相关。

以 Decoder-only Transformer 为例,模型接收一段 Token 序列:

X=(x_1,x_2,\ldots,x_n)

首先通过 Embedding 将 Token ID 映射为向量,再经过多层 Transformer Block。

每一层通常包含:

  • Self-Attention:计算序列中 Token 之间的注意力关系。
  • FFN:对每个位置的表示进行非线性变换。
  • Residual Connection:残差连接。
  • LayerNorm 或 RMSNorm:归一化处理。

1. Self-Attention 如何使用上下文?

对于长度为 n 的输入序列,Self-Attention 会计算 Query、Key 和 Value:

Q=XW_Q
K=XW_K
V=XW_V

然后计算注意力:

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

其中:

  • Q:Query 矩阵。
  • K:Key 矩阵。
  • V:Value 矩阵。
  • d_k:Key 向量维度。
  • M:注意力掩码,因果语言模型中用于屏蔽未来位置。

对于 Decoder-only 模型,位置 i 的 Token 通常只能关注当前位置及之前的位置:

Attention(i)\rightarrow \{1,2,\ldots,i\}

这意味着模型可以利用上下文中的历史信息,但不能通过标准因果注意力直接读取未来 Token。

2. 为什么 Context Window 有最大长度?

从数学形式上看,标准 Self-Attention 可以处理不同长度的序列,但实际模型并不是无限长度运行的。

主要受到以下因素限制:

第一,计算复杂度。

标准全注意力中,注意力矩阵的规模与序列长度平方相关:

O(n^2)

当上下文长度增加时,注意力计算量和中间数据规模会快速增长。

第二,显存占用。

输入序列越长,需要处理的激活数据越多。推理阶段还需要为历史 Token 保存 KV Cache。

第三,位置编码与训练配置。

模型的位置编码方案、训练时使用的序列长度以及长上下文扩展方法,都会影响模型能够稳定处理的长度范围。

第四,系统实现限制。

推理框架、硬件显存、批处理策略和服务端配置也可能对实际可用长度形成约束。

因此,Context Window 是模型架构、训练配置和推理系统共同决定的能力边界。

四、Context Window 与 KV Cache 的关系

Context Window 和 KV Cache 是两个密切相关但并不相同的概念。

  • Context Window:决定模型能够处理多长的上下文。
  • KV Cache:保存历史 Token 在各层 Attention 中计算得到的 Key 和 Value,避免 Decode 阶段重复计算。

在自回归生成过程中,模型通常分为 Prefill 和 Decode 两个阶段。

1. Prefill 阶段

模型接收完整 Prompt:

X=(x_1,x_2,\ldots,x_n)

通过 Transformer 各层计算历史 Token 的 K、V,并建立 KV Cache。

2. Decode 阶段

模型每次生成一个新 Token,并将其对应的 K、V 追加到缓存中。

后续 Token 可以复用历史 K、V,而不必重新计算所有历史位置的 K、V 投影。

flowchart TB
    A["输入 Prompt"] --> B["Tokenizer 编码"]
    B --> C["Prefill 阶段"]
    C --> D["处理完整输入序列"]
    D --> E["计算各层 K、V"]
    E --> F["建立 KV Cache"]
    F --> G["Decode 阶段"]
    G --> H["输入当前 Token"]
    H --> I["读取历史 KV Cache"]
    I --> J["计算当前 Token 的 Q、K、V"]
    J --> K["追加当前 K、V"]
    K --> L["生成下一个 Token"]
    L --> M{"是否结束生成"}
    M -->|"否"| G
    M -->|"是"| N["输出完整结果"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    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:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style K fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style L fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style M fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style N fill:#E5F0E9,stroke:#83A995,color:#315D49

3. 上下文越长,KV Cache 越大

假设模型使用标准 Transformer Attention,其 KV Cache 显存占用可以近似表示为:

M_{KV}=2LBT H_{kv}D P

其中:

  • L:Transformer 层数。
  • B:Batch Size。
  • T:缓存 Token 数量。
  • H_{kv}:KV Head 数量。
  • D:每个 Head 的维度。
  • P:每个元素占用的字节数。
  • 2:分别表示 Key 和 Value。

从公式可以看出:

M_{KV}\propto T

在其他条件不变时,上下文长度增加一倍,KV Cache 显存占用也会近似增加一倍。

例如,一个请求的上下文从 8K 增长到 32K,KV Cache 的理论占用会增长到原来的 4 倍。

这也是长上下文推理对 GPU 显存和内存带宽提出更高要求的重要原因。

五、Context Window 越大,模型能力就越强吗?

不一定。

更大的上下文窗口意味着模型能够接收更长的信息,但不代表模型一定能够充分理解和利用这些信息。

需要区分三个概念:

概念 含义
Context Window 模型允许接收的最大上下文长度
Context Utilization 模型对上下文信息的实际利用能力
Long-Context Performance 模型在长上下文任务中的实际表现

例如:

一个模型支持 128K Token,并不意味着它能够准确理解 128K Token 中的所有信息,也不意味着所有位置的信息都能被同等有效地利用。

1. Lost in the Middle:中间信息容易被忽略

长上下文研究中存在一个值得关注的现象:模型对信息的利用效果可能受到信息所在位置的影响。

例如,在一份很长的文档中:

  • 关键信息出现在开头。
  • 关键信息出现在中间。
  • 关键信息出现在结尾。

即使三种情况下的信息内容完全相同,模型回答问题的准确率也可能存在差异。

部分模型在处理长上下文时,对开头和结尾的信息利用效果较好,而对中间位置的信息利用效果下降。

这类现象通常被称为 Lost in the Middle。

它说明:

能够接收信息,不等于能够有效检索、定位和使用信息。

2. 长上下文不等于长文本推理

处理长文档至少涉及几个不同能力:

  • 信息定位:找到相关段落。
  • 信息检索:提取目标内容。
  • 信息整合:关联分散在不同位置的信息。
  • 多步推理:根据多个事实推导结论。
  • 长距离依赖:理解相隔较远的信息之间的关系。

模型即使具备较大的上下文窗口,也可能在上述任务中表现不稳定。

例如,要求模型从一份 100 页的技术文档中找出三个分散的约束条件,并判断它们是否存在冲突。这不仅是长度问题,还涉及跨段落检索和逻辑推理能力。

3. 上下文越长,噪声也可能越多

上下文中并不是所有内容都有价值。

如果输入大量无关内容,可能导致:

  • 重要信息被无关内容稀释。
  • 注意力计算成本增加。
  • KV Cache 占用增加。
  • 检索和信息整合难度提高。
  • 关键约束在大量历史对话中被忽略。

因此,增加上下文长度并不总是提升模型表现的最佳方式。

六、长上下文技术如何扩展?

模型的上下文长度受到位置表示、训练数据、计算资源和推理系统等因素限制。

为了支持更长上下文,研究和工程实践中出现了多种技术。

1. RoPE 位置编码扩展

RoPE(Rotary Position Embedding)通过对 Query 和 Key 进行旋转变换,将位置信息融入注意力计算。

在标准 RoPE 中,位置 m 对应的旋转矩阵可以抽象表示为:

R_m

Query 和 Key 的位置变换为:

Q_m'=R_mQ_m
K_n'=R_nK_n

其重要特性是注意力内积能够体现相对位置信息:

(Q_m')^TK_n' = Q_m^TR_{n-m}K_n

这使模型能够通过相对位置关系建模 Token 之间的距离。

但 RoPE 并不意味着模型天然支持无限长度。

当推理位置远远超出训练时使用的位置范围时,模型可能出现位置分布外推问题。

因此,需要通过位置插值、频率调整等方式扩展可用长度。

2. Position Interpolation(位置插值)

位置插值的核心思想是将较长序列中的位置映射到原本训练时覆盖的位置范围内。

假设原始训练长度为 L,目标长度为 L',且:

L'>L

一种简单的线性位置缩放可以表示为:

m'=m\cdot\frac{L}{L'}

其中:

  • m:原始位置。
  • m':缩放后的位置。

通过压缩位置范围,模型可以在更长序列中使用原有位置编码范围。

但位置插值可能影响模型对短距离和长距离位置差异的表达,因此实际系统通常需要结合训练或微调。

3. NTK-aware RoPE

NTK-aware RoPE 是一类调整 RoPE 频率分布的扩展方法。

其目标不是简单地对所有位置进行相同比例的压缩,而是调整不同频率维度的缩放方式,以改善长上下文场景下的位置表达。

不同模型可能采用不同的频率调整策略,具体实现不能简单视为统一公式。

4. YaRN

YaRN 是一种面向 RoPE 长上下文扩展的技术方案。

它通过对不同频率维度进行调整,并结合温度等机制,改善模型在扩展上下文长度后的表现。

与单纯位置插值相比,YaRN 更强调不同频率成分的差异化处理,并可配合少量长上下文微调。

5. LongRoPE

LongRoPE 通过对位置编码进行更精细的缩放优化,探索更大范围的上下文扩展。

它关注不同维度的频率调整以及长上下文适配问题,具体实现和效果取决于模型架构及训练方案。

6. 技术方案对比

技术 核心思路 主要目标
RoPE 旋转位置编码 表达相对位置信息
Position Interpolation 压缩位置范围 扩展可用位置长度
NTK-aware RoPE 调整频率缩放 改善长距离位置表达
YaRN 分频率调整并配合适配 提升长上下文扩展效果
LongRoPE 优化位置缩放策略 支持更大上下文范围

这些技术并不是简单地扩大一个参数就能让模型获得可靠的长文本理解能力。通常还需要训练数据、微调策略和推理配置配合。

七、如何在工程中管理 Context Window?

在实际应用中,Context Window 管理是构建智能问答、Agent、代码助手和 RAG 系统的重要环节。

如果每次请求都无条件携带全部历史信息,随着对话增长,很快就会触及上下文长度限制。

常见的管理策略包括以下几种。

1. Sliding Window:滑动窗口