【lucene核心】impacts的由来

在 Lucene 的 Impact 概念（出现在 `ImpactsEnum` / `Impact` 对象里）中：

字段含义

freq 当前 term 在该文档中出现了多少次（即词频 term frequency）。

norm 当前文档在该字段中的长度因子（即之前 norms 里保存的压缩长度值，用来归一化打分）。

举个例子

文档 7：

字段 `title` 内容：`"lucene lucene search"`
分词后：`lucene`(2 次)、`search`(1 次)
对 term `"lucene"` 的 `Impact`
freq = 2（出现了 2 次）
norm = 压缩后的字段长度 3（3 个 token）

一句话

freq → term 在文档里的出现次数
norm → 文档在该字段的总 token 数（压缩后的长度因子）

/** Get the set of competitive freq and norm pairs, ordered by increasing freq and norm. */

public Collection<Impact> getCompetitiveFreqNormPairs() {

List<Impact> impacts = new ArrayList<>();

int maxFreqForLowerNorms = 0;

for (int i = 0; i < maxFreqs.length; ++i) {

int maxFreq = maxFreqs[i];

if (maxFreq > maxFreqForLowerNorms) {

impacts.add(new Impact(maxFreq, (byte) i));

maxFreqForLowerNorms = maxFreq;

}

if (otherFreqNormPairs.isEmpty()) {

// Common case: all norms are bytes

return impacts;

}

TreeSet<Impact> freqNormPairs = new TreeSet<>(this.otherFreqNormPairs);

for (Impact impact : impacts) {

add(impact, freqNormPairs);

}

return Collections.unmodifiableSet(freqNormPairs);

}

这段代码的作用是：

把当前 term 所有可能出现的 "最大词频 + 对应 norm" 组合，按 freq 升序、norm 升序整理成一条紧凑的 "上限表"（Impact 列表），

供 Block-Max WAND 等跳表算法在查询时快速判断 "剩下这些文档再也不可能超过当前阈值"，从而提前剪枝、加速 Top-k 检索。

背景：为什么要 "competitive pairs"

在 Block-Max WAND / MaxScore 算法里，必须知道 "一个块内最大可能的 score 是多少"。

已知 score 只跟 freq（词频）和 norm（字段长度）有关。
因此把每个 norm level 对应的最大 freq 记录下来 → 形成 `(freq, norm)` 的上限数组。
只要当前阈值大于块内最大的 `(freq, norm)` 上限，整个块即可跳过。

代码拆读

2.1 先把 "简单情况" 处理掉

```java

List<Impact> impacts = new ArrayList<>();

int maxFreqForLowerNorms = 0;

for (int i = 0; i < maxFreqs.length; ++i) {

int maxFreq = maxFreqs[i]; // 对 norm = i 的最大词频

if (maxFreq > maxFreqForLowerNorms) {

impacts.add(new Impact(maxFreq, (byte) i));

maxFreqForLowerNorms = maxFreq; // 保证单调递增

}

```

`maxFreqs[i]` 保存的是 "norm 为 i 的所有文档里，该 term 出现的最大频次"。
通过条件 `maxFreq > maxFreqForLowerNorms` 去掉冗余，确保列表严格按 `(freq ↑, norm ↑)` 排序。

2.2 再合并 "其他 norm"

```java

if (otherFreqNormPairs.isEmpty()) {

return impacts; // 全是 byte 值，直接返回

}

TreeSet<Impact> freqNormPairs = new TreeSet<>(otherFreqNormPairs);

for (Impact impact : impacts) {

add(impact, freqNormPairs);

}

return Collections.unmodifiableSet(freqNormPairs);

```

`otherFreqNormPairs` 里存的是非 byte 型 norm（罕见）或额外手工添加的组合。
用 `TreeSet` 统一排序、去重，最终得到全局有序且无冗余的 competitive 列表。

一句话总结

`getCompetitiveFreqNormPairs()` 生成的就是 "score 上限表"（Impact 列表），

查询阶段用它来快速判定某个文档块是否还有竞争力，从而实现 Block-Max WAND 的提前剪枝与加速。

不是"随着 norm 的增加取最大的 freq"那么简单，而是：

> 对每个 norm level，记录该 level 内出现的最大 freq，然后在所有 level 上再做一个"剪枝"：只有当某 level 的 maxFreq 比之前所有更低 level 的 maxFreq 都大时，才保留这个 (maxFreq, norm) 对。

这样做的目的：

保证最终列表按 freq 严格递增，
保证 norm 也单调递增，
让 Block-Max WAND 在"从低打到高"的顺序里，能直接用最大 freq 作为上限来剪枝。

举个具体数字

假设：

norm (i) 该 norm 内最大 freq

0 3

1 5

2 4

3 6

代码流程：

i=0 → maxFreq=3 > 0 → 保留 (3, 0)
i=1 → maxFreq=5 > 3 → 保留 (5, 1)
i=2 → maxFreq=4 ≯ 5 → 丢弃
i=3 → maxFreq=6 > 5 → 保留 (6, 3)

最终 competitive 列表：

`(3,0), (5,1), (6,3)` ------ 既 freq 递增，norm 也递增。

level 就是 norm 本身的整数值（byte 或 int），

在代码里直接体现为循环变量 `i` 和 `Impact` 构造器里的第二个参数 `norm`：

```java

for (int i = 0; i < maxFreqs.length; ++i) { // i 就是 level

...

impacts.add(new Impact(maxFreq, (byte) i)); // (byte) i 就是 norm level

}

```

`maxFreqs` 数组的下标 `i` 就对应 norm level 0、1、2 ...。
因此 level 没有额外存储，它就是 norm 的数值本身。

这是一种 "分层/分级上限（level-wise upper-bound）思想"，

在 Lucene 里具体对应 Block-Max WAND / MaxScore 这类 Top-k 查询剪枝算法。

核心思想一句话

> 把每级（level = norm 值）内的最大可能得分提前算成一张单调递增的上限表，

搜索时按表从小到大扫描，一旦发现剩余块的上限已经低于当前第 k 个结果的真实得分，就整段跳过，不再计算。

算法家族

名称出处说明

WAND Broder et al. 2003 经典倒排链跳跃算法

Block-Max WAND Ding & Suel 2011 在倒排链的"块"内预存上限，块级跳过

MaxScore Turtle & Flood 1995 类似思路，用于 Lucene 早期

Lucene 8+ 实现 `ImpactsEnum` + `Impact` 把 norm-level 上限预生成，驱动 Block-Max WAND

为什么要"分层"(level = norm)

norm 越小 → 字段越短 → 相同词频的得分越高
因此把 norm 离散化成若干 level，每级算一次 max freq
对 Block-Max WAND：

只要当前阈值 > level L 的 maxScore，所有 norm ≥ L 的文档都可以一次性跳过，节省大量 I/O 与计算。

一句话总结

这段代码体现的算法思想就是 "Block-Max WAND 的分层上限剪枝"，

通过 norm level + max freq 生成单调递增的 Impact 表，实现 Top-k 查询中的早期终止与跳跃。

在同一 term、同一词频（freq）的情况下：

norm 越小 → 字段越短 → 该 term 的权重越大 → 得分越高。

因此，

> 在 `Impact` 表中，相同 freq 时，norm 越小，对应的潜在得分反而越高。

这也是 Block-Max WAND 把 `(freq, norm)` 按 freq 升序 + norm 升序排序后，就能用单调上限剪枝的根本原因：

先处理低频或长字段（高 norm）的块，它们的得分上限低，容易跳过；
后处理高频或短字段（低 norm）的块，上限高，需要真正计算。

对于impacts 跳表的高层是低层impacts的和是吧？

不是简单的"求和"关系，而是 "高层 impact 是对自己管辖区间内所有低层 impact 的最大值的上界"。

高层（higher level）的 `Impact` 只是该层所覆盖文档块内最大的 `(freq, norm)` 对。
它保证：

任何落在这个块里的文档，其真实 `(freq, norm)` 都不会超过这条高层记录的 `(freq, norm)`。

因此搜索时可以用高层 impact 直接做块级剪枝，而不必逐条遍历低层。

类比

高层 impact ≈ 块级"最大值"
低层 impacts ≈ 块内真实值
关系是 "max 覆盖"（max bound），而非 "累加"（sum）。

剪枝流程可以拆成两步：

高层剪枝：一次跳过整块
低层剪枝：在块内再逐条跳过

高层剪枝（先发生）

搜索线程维护一个当前第 k 名的阈值 `minCompetitiveScore`。
从高层 Impact 表顺序扫描 `(maxFreq, maxNorm)`。
把 `(maxFreq, maxNorm)` 代入 BM25 公式得到一个 "这块的最高可能得分" `upperBoundScore`。
如果 `upperBoundScore < minCompetitiveScore` → 整块 4 篇文档直接丢弃，指针跳到下一高层块。

```

高层表顺序：(3,0) (5,2) (6,0) (7,1) ...

↑

只要这个上限 < 阈值，整块 0-3 全跳过

```

低层剪枝（块内发生）

如果 `upperBoundScore ≥ minCompetitiveScore`，说明块里可能还有候选，就进入该块。
用低层的 `ImpactsEnum` 逐条读真正的 `(freq, norm)`；
每读一条就立即计算真实得分；
一旦真实得分 < minCompetitiveScore，就利用低层跳表指针跳到下一个可能大于阈值的文档，继续比较。

流程小结

```

高层 Impact 表

├─ block0 上限 < 阈值 → 整块跳过

├─ block1 上限 ≥ 阈值 → 进入块内

│ ├─ doc4 (7,1) 得分 ≥ 阈值 → 保留

│ ├─ doc5 (2,2) 得分 < 阈值 → 跳到下一条

│ └─ ...

└─ ...

```

高层先快速丢大段，低层再精准丢小段，这就是 Block-Max WAND 的剪枝节奏。

第 0 层（最底层）跳表也是以 block 为单位来剪枝的 ------ 只不过这里的 block 已经是最细粒度的 "文档块"，而不是高层那种更大的逻辑块。

第 0 层的剪枝规则：

第 0 层的每个 block 会提前计算一个该块内最大的 `(freq, norm)` 对（即该块内最高的 Impact）。
这个最大值被用来估算该 block 的最高可能得分 `upperBoundScore`。
只要这个 `upperBoundScore < minCompetitiveScore`，整个 block 就可以直接跳过；
否则，就必须逐文档处理（因为块内可能有文档得分 ≥ 阈值）。

用之前的例子具体说明：

假设第 0 层有 4 个 block（每块 4 篇文档）：

第 0 层 block 该块最大 Impact 估算最高得分

block-0 `(5,2)` `score_upper0`

block-1 `(7,1)` `score_upper1`

block-2 `(6,0)` `score_upper2`

block-3 `(4,3)` `score_upper3`

如果 `minCompetitiveScore = 6.5`，而：
`score_upper0 = 5.1 < 6.5` → 整 block-0 直接跳过
`score_upper1 = 7.2 ≥ 6.5` → 必须逐文档处理 block-1
`score_upper2 = 6.0 < 6.5` → 整 block-2 直接跳过
`score_upper3 = 4.8 < 6.5` → 整 block-3 直接跳过

一句话总结

第 0 层同样以 block 为单位做剪枝；

只要某个最底层 block 的最高可能得分低于当前阈值，就整块跳过，否则逐文档处理。

private float computeMaxScore(List<Impact> impacts) {

float maxScore = 0;

for (Impact impact : impacts) {

maxScore = Math.max(scorer.score(impact.freq, impact.norm), maxScore);

}

return maxScore;

}

这段代码的用途一句话就能说清：

> 把一个 impacts 列表里所有 `(freq, norm)` 对的"最高分"算出来，作为该段（或该 block）的得分上限。

具体过程

遍历列表中的每一条 `Impact`
用 scorer 的公式当场算出这条 `(freq, norm)` 的得分
取最大值 `maxScore` 返回

在算法流程中的位置

上层（高层）

先调 `computeMaxScore(impacts)` 得到 `maxScore`，

然后与当前第 k 名的阈值 `minCompetitiveScore` 比较：

`maxScore < minCompetitiveScore` → 整块/整段直接跳过
否则才继续逐文档精确打分或更细粒度剪枝。

注意点

这里只是 "估算" 上限，不会真的去遍历文档。
由于 `score(freq, norm)` 是单调函数，列表里最大的 `(freq, norm)` 必然给出最大分，所以只需要比较一次即可。