【Elasticsearch】k-NN 搜索深度解析：参数优化与分数过滤实践

在现代搜索和推荐系统中，向量相似性搜索已经成为核心技术之一。Elasticsearch 作为主流的搜索引擎，其 k-NN（k-近邻）功能为开发者提供了强大的向量搜索能力。本文将深入探讨 Elasticsearch k-NN 搜索的核心参数、计算过程，以及如何实现基于分数的结果过滤。

一、k-NN 核心参数详解

在 Elasticsearch 的 k-NN 查询中，有三个关键参数直接影响搜索的性能和准确性：

1. k - 结果数量控制器

k 参数指定最终返回的最近邻文档数量，这是你实际想要获得的搜索结果数。它直接决定了查询返回的文档总数，是整个 k-NN 算法的核心参数。

{
  "knn": {
    "field": "vector_field",
    "query_vector": [0.1, 0.2, 0.3, ...],
    "k": 10  // 返回最相似的10个文档
  }
}

2. num_candidates - 候选池大小

num_candidates 控制每个分片上进行 ANN（近似最近邻）搜索时考虑的候选向量数量。这个参数直接影响搜索的召回率和性能：

• 值越大：搜索越精确，但计算开销越大
• 值越小：搜索越快，但可能遗漏真正的最近邻
• 推荐设置：通常为 k 的 2-20 倍

{
  "knn": {
    "field": "vector_field",
    "query_vector": [0.1, 0.2, 0.3, ...],
    "k": 10,
    "num_candidates": 100  // 每个分片考虑100个候选向量
  }
}

3. window_size - 分布式重排序窗口

在分布式环境下，window_size 控制重新评分窗口的大小。Elasticsearch 会从每个分片获取 window_size 个候选结果，然后进行全局重新排序以确保分布式搜索的准确性。

• 最小值：应该至少等于 k
• 推荐设置：k 的 1.1-1.3 倍
• 影响因素：网络带宽、内存使用、查询延迟

{
  "knn": {
    "field": "vector_field",
    "query_vector": [0.1, 0.2, 0.3, ...],
    "k": 10,
    "num_candidates": 100,
    "window_size": 15  // 全局重排序考虑15个候选结果
  }
}

参数配置建议

对于不同规模的查询，推荐以下配置策略：

基本原则：num_candidates >= window_size >= k

二、Elasticsearch k-NN 计算过程深度解析

2.1 整体架构流程

Elasticsearch 的 k-NN 搜索基于 HNSW（Hierarchical Navigable Small World）算法，整个计算过程可以分为以下几个阶段：

查询请求 → 分片路由 → 各分片ANN搜索 → 候选结果收集 → 全局重排序 → 返回结果

2.2 分片级别的 ANN 搜索

第一步：向量预处理

• 查询向量标准化（如果需要）
• 选择相似度计算方法（cosine、dot_product、l2_norm等）

第二步：HNSW 图遍历

1. 从顶层图开始搜索
2. 逐层向下寻找最近邻节点
3. 在底层进行精确的邻居搜索
4. 收集 num_candidates 个候选向量

第三步：分片结果生成

• 计算每个候选向量与查询向量的精确相似度分数
• 按分数降序排列候选结果
• 选取前 window_size 个结果发送给协调节点

2.3 全局协调和重排序

协调节点处理流程：

# 伪代码展示全局协调过程
def global_coordination(shard_results, k, window_size):
    all_candidates = []
    
    # 收集所有分片的候选结果
    for shard_result in shard_results:
        all_candidates.extend(shard_result[:window_size])
    
    # 全局重新排序
    all_candidates.sort(key=lambda x: x.score, reverse=True)
    
    # 返回top-k结果
    return all_candidates[:k]

2.4 分数计算机制

不同的相似度函数有不同的分数计算方式：

余弦相似度：

score = (1 + cosine_similarity(query_vector, doc_vector)) / 2
范围：[0, 1]，1表示完全相似

点积相似度：

score = 1 / (1 + dot_product(query_vector, doc_vector))
需要向量预先标准化

欧几里得距离：

score = 1 / (1 + l2_distance(query_vector, doc_vector))
范围：(0, 1]，1表示距离为0（完全相同）

三、k-NN 分数过滤实现方案

在实际应用中，我们经常需要返回分数高于某个阈值的文档，而不仅仅是固定数量的top-k结果。以下是几种实现方案：

3.1 方案一：使用 min_score 参数（推荐）

从 Elasticsearch 8.4.0 开始，k-NN 查询支持直接使用 min_score 参数：

GET /vector_index/_search
{
  "knn": {
    "field": "embedding_vector",
    "query_vector": [0.1, 0.2, 0.3, 0.4, 0.5],
    "k": 1000,
    "num_candidates": 2000
  },
  "min_score": 0.8,
  "size": 100
}

优势：

• 性能最佳，在搜索引擎层面直接过滤
• 语法简洁，易于理解和维护
• 减少网络传输开销

适用场景：

• 需要基于固定阈值过滤的场景
• 对性能要求较高的生产环境

3.2 方案二：script_score 查询

对于需要复杂阈值逻辑的场景，可以使用 script_score 查询：

GET /vector_index/_search
{
  "query": {
    "script_score": {
      "query": {
        "bool": {
          "filter": {
            "range": {
              "timestamp": {
                "gte": "2024-01-01"
              }
            }
          }
        }
      },
      "script": {
        "source": """
          double similarity = cosineSimilarity(params.query_vector, 'embedding_vector');
          double score = (1.0 + similarity) / 2.0;
          return score >= params.threshold ? score : 0;
        """,
        "params": {
          "query_vector": [0.1, 0.2, 0.3, 0.4, 0.5],
          "threshold": 0.8
        }
      },
      "min_score": 0.1
    }
  },
  "size": 100
}

优势：

• 极高的灵活性，可以实现复杂的评分逻辑
• 可以结合其他查询条件
• 支持动态阈值计算

劣势：

• 性能开销较大
• 需要遍历更多文档进行脚本计算

3.3 方案三：混合查询过滤

结合 k-NN 查询和布尔过滤器：

GET /vector_index/_search
{
  "query": {
    "bool": {
      "must": {
        "knn": {
          "field": "embedding_vector",
          "query_vector": [0.1, 0.2, 0.3, 0.4, 0.5],
          "k": 1000,
          "num_candidates": 2000
        }
      },
      "filter": [
        {
          "range": {
            "create_time": {
              "gte": "2024-01-01"
            }
          }
        },
        {
          "script": {
            "script": {
              "source": "_score >= params.min_score",
              "params": {
                "min_score": 0.8
              }
            }
          }
        }
      ]
    }
  },
  "size": 100
}

3.4 方案四：应用层后处理

在应用代码中对结果进行过滤：

def filter_by_score_threshold(es_results, threshold=0.8):
    """
    在应用层过滤k-NN搜索结果
    """
    filtered_hits = []
    
    for hit in es_results['hits']['hits']:
        if hit['_score'] >= threshold:
            filtered_hits.append(hit)
        else:
            break  # k-NN结果已按分数排序，可提前退出
    
    return {
        'hits': {
            'total': {'value': len(filtered_hits)},
            'hits': filtered_hits
        }
    }

# 使用示例
knn_query = {
    "knn": {
        "field": "embedding_vector",
        "query_vector": query_embedding,
        "k": 1000,
        "num_candidates": 2000
    },
    "size": 1000  # 获取更多候选结果
}

results = es.search(index="vector_index", body=knn_query)
filtered_results = filter_by_score_threshold(results, threshold=0.85)

四、方案选择指南

性能对比

选择建议

1. 生产环境首选：min_score 参数方案
2. 复杂需求场景：script_score 查询
3. 多维过滤需求：混合查询方案
4. 开发测试阶段：应用层后处理

五、最佳实践总结

参数优化策略

1. 监控召回率：定期评估 num_candidates 设置是否足够
2. 性能测试：根据实际数据量调整 window_size
3. 分数阈值设定：基于业务需求和数据分布确定合理阈值

生产环境建议

// 推荐的生产配置模板
{
  "knn": {
    "field": "embedding_vector",
    "query_vector": "${query_embedding}",
    "k": 100,
    "num_candidates": 500
  },
  "min_score": 0.75,
  "size": 50,
  "_source": ["id", "title", "content_summary"],
  "timeout": "5s"
}

性能优化要点

1. 合理设置候选数量：避免 num_candidates 过大导致性能问题
2. 使用字段过滤：通过 _source 控制返回字段，减少网络传输
3. 设置查询超时：避免长时间查询影响系统稳定性
4. 监控资源使用：关注CPU和内存使用情况

通过合理配置参数和选择适当的分数过滤方案，可以构建高效、精确的向量搜索系统，为推荐系统、相似性检索等应用提供强有力的技术支撑。