1
  ┌────────────┬────────────────────┬──────────────────┐
2
  │    类型    │        特征        │       示例       │
3
  ├────────────┼────────────────────┼──────────────────┤
4
  │ 停用词     │ 长度≤2，无语义信息 │ 的、是、在、和   │
5
  ├────────────┼────────────────────┼──────────────────┤
6
  │ 高频通用词 │ 文档频率>阈值      │ 我们、可以、这个 │
7
  ├────────────┼────────────────────┼──────────────────┤
8
  │ 模糊词     │ 单字、无义词       │ 啊、嗯、什么     │
9
  ├────────────┼────────────────────┼──────────────────┤
10
  │ 标点/数字  │ 纯符号或数字       │ 123、@#$         │
11
  └────────────┴────────────────────┴──────────────────┘

1
# 检索前从query中移除短token
2

3
def filter_query(query: str) -> str:
4
    tokens = tokenize(query)
5
    filtered = [t for t in tokens if not is_short_token(t)]
6
    return " ".join(filtered)
7

8
# 例: "Java是什么" → "Java"
9
# 例: "如何在Python中使用多线程" → "Python使用多线程"
10

11
优点：简单直接，检索效率高
12
缺点：可能丢失部分语义（如"不Java"）

1
  def weighted_query(tokens):
2
      """
3
      短token给予极低权重
4
      长token（实体、术语）给予高权重
5
      """
6
      weights = []
7
      for t in tokens:
8
          if is_short_token(t):
9
              weights.append(0.1)   # 短token权重降为0.1
10
          else:
11
              weights.append(1.0)   # 正常token权重1.0
12
      return weights
13

14
  # 向量检索时：query_vector = Σ(token_vector * weight)

1
  命中检测流程
2

3
  Step 1: 从Query中提取短token集合 S = {s1, s2, ...}
4

5
  Step 2: 对每个检索结果R，计算短token命中率
6
          hit_ratio(R) = |S ∩ content(R)| / |S|
7

8
  Step 3: 置信度校准
9
          if hit_ratio > 0.8:  # 几乎所有短token都命中了
10
              confidence *= 0.5  # 降低该结果可信度
11

12
  Step 4: 综合排序
13
          final_score(R) = similarity_score(R) * confidence(R)

1
  代码示例
2

3
  def calculate_short_token_hit_ratio(query: str, doc_content: str) -> float:
4
      """
5
      计算短token命中率
6
      命中率过高说明文档"假相关"
7
      """
8
      query_tokens = set(tokenize(query))
9
      doc_tokens = set(tokenize(doc_content))
10

11
      short_tokens = {t for t in query_tokens if is_short_token(t)}
12
      if not short_tokens:
13
          return 0.0
14

15
      # 命中的短token
16
      hit_tokens = short_tokens & doc_tokens
17
      return len(hit_tokens) / len(short_tokens)
18

19
  def adjust_confidence(sim_score: float, hit_ratio: float) -> float:
20
      """
21
      短token命中过高 → 降权
22
      """
23
      if hit_ratio > 0.8:
24
          return sim_score * 0.3   # 严重降权
25
      elif hit_ratio > 0.5:
26
          return sim_score * 0.7   # 轻度降权
27
      return sim_score

1
  ┌──────────────────┬─────────────┬────────────┬────────────┬───────────────┐
2
  │      Query       │ 短Token集合 │ Doc A 命中 │ Doc B 命中 │     判定      │
3
  ├──────────────────┼─────────────┼────────────┼────────────┼───────────────┤
4
  │ "什么是AI"       │ {什么,是}   │ 100%       │ 60%        │ Doc B更可信   │
5
  ├──────────────────┼─────────────┼────────────┼────────────┼───────────────┤
6
  │ "Java多线程实现" │ {}          │ -          │ -          │ 无短token干扰 │
7
  └──────────────────┴─────────────┴────────────┴────────────┴───────────────┘

1
  ┌─────────────────────────────────────────────────────┐
2
  │                   完整处理流程                         │
3
  ├─────────────────────────────────────────────────────┤
4
  │                                                     │
5
  │   Query: "Java多线程是什么"                           │
6
  │              │                                       │
7
  │              ▼                                       │
8
  │   ┌─────────────────┐                              │
9
  │   │  1. 短Token识别   │ → {什么,是}                   │
10
  │   └────────┬────────┘                              │
11
  │            │                                        │
12
  │            ▼                                        │
13
  │   ┌─────────────────┐                              │
14
  │   │  2. 过滤/降权    │ → query = "Java多线程"        │
15
  │   │                 │   weight = {Java:1, 多线程:1, 什么:0.1, 是:0.1} │
16
  │   └────────┬────────┘                              │
17
  │            │                                        │
18
  │            ▼                                        │
19
  │   ┌─────────────────┐                              │
20
  │   │  3. 向量检索     │ → Top-10 结果                  │
21
  │   └────────┬────────┘                              │
22
  │            │                                        │
23
  │            ▼                                        │
24
  │   ┌─────────────────┐                              │
25
  │   │  4. 命中判定     │ → 计算每个结果的短token命中率    │
26
  │   │  (置信度校准)    │ → 命中过高则降权               │
27
  │   └────────┬────────┘                              │
28
  │            │                                        │
29
  │            ▼                                        │
30
  │         最终结果                                     │
31
  │                                                     │
32
  └─────────────────────────────────────────────────────┘

1
  ┌───────────┬─────────────────────────────────────────┐
2
  │   阶段    │                  原则                   │
3
  ├───────────┼─────────────────────────────────────────┤
4
  │ 识别      │ 长度 + IDF双重判定，不依赖单一标准      │
5
  ├───────────┼─────────────────────────────────────────┤
6
  │ Query改写 │ 短token扩展为相关概念，而非直接删除语义 │
7
  ├───────────┼─────────────────────────────────────────┤
8
  │ 命中判定  │ 用于置信度校准，不是直接过滤结果        │
9
  ├───────────┼─────────────────────────────────────────┤
10
  │ 降权幅度  │ 渐进式（0.3/0.7/1.0），避免过度惩罚     │
11
  └───────────┴─────────────────────────────────────────┘

1
def should_filter(token: str, idf_threshold: float = 0.5) -> bool:
2
    """综合判断是否应过滤"""
3
    # 命中停用词表 -> 直接过滤
4
    if token in STOPWORDS:
5
        return True
6
    # IDF过低且非专业术语 -> 过滤
7
    if get_idf(token) < idf_threshold and not is_domain_term(token):
8
        return True
9
    return False

1
文档 → 分块 → 分词 → 短Token识别 → 过滤规则 → 向量化存储