@Service
public class BM25IndexService {
    
    private static final double K1 = 1.2;  // 词频饱和参数
    private static final double B = 0.75;  // 文档长度归一化参数
    
    private Map<String, Map<Integer, Double>> invertedIndex;  // 倒排索引
    private Map<Integer, Integer> docLengths;                 // 每篇文档的词数
    private Map<String, Integer> docFrequency;               // 词文档频率
    private double avgDocLength;                              // 平均文档长度
    private int totalDocs;
    
    private Analyzer analyzer;  // 分词器（使用Lucene或HanLP）
    
    @PostConstruct
    public void init() {
        invertedIndex = new HashMap<>();
        docLengths = new HashMap<>();
        docFrequency = new HashMap<>();
        analyzer = new SmartChineseAnalyzer();  // 中文智能分词
    }
    
    /**
     * 构建BM25索引
     */
    public void buildIndex(List<IndexedDocument> documents) {
        // 第一遍：统计词频和文档长度
        Map<Integer, List<String>> docTokens = new HashMap<>();
        
        for (IndexedDocument doc : documents) {
            List<String> tokens = tokenize(doc.getContent());
            docTokens.put(doc.getId(), tokens);
            docLengths.put(doc.getId(), tokens.size());
            
            // 统计词在哪些文档中出现（用于计算IDF）
            new HashSet<>(tokens).forEach(token -> 
                docFrequency.merge(token, 1, Integer::sum)
            );
        }
        
        totalDocs = documents.size();
        avgDocLength = docLengths.values().stream()
            .mapToInt(Integer::intValue)
            .average()
            .orElse(100);
        
        // 第二遍：构建倒排索引
        for (Map.Entry<Integer, List<String>> entry : docTokens.entrySet()) {
            int docId = entry.getKey();
            List<String> tokens = entry.getValue();
            
            // 统计词频
            Map<String, Long> termFrequency = tokens.stream()
                .collect(Collectors.groupingBy(t -> t, Collectors.counting()));
            
            termFrequency.forEach((term, tf) -> {
                invertedIndex
                    .computeIfAbsent(term, k -> new HashMap<>())
                    .put(docId, tf.doubleValue());
            });
        }
        
        log.info("BM25索引构建完成：{}篇文档，{}个词项", totalDocs, invertedIndex.size());
    }
    
    /**
     * BM25查询
     * 返回文档ID和BM25分数的有序列表
     */
    public List<ScoredDocId> search(String query, int topK) {
        List<String> queryTokens = tokenize(query);
        Map<Integer, Double> scores = new HashMap<>();
        
        for (String term : queryTokens) {
            if (!invertedIndex.containsKey(term)) continue;
            
            // IDF计算（BM25版本）
            int df = docFrequency.getOrDefault(term, 0);
            double idf = Math.log(1 + (totalDocs - df + 0.5) / (df + 0.5));
            
            // 对每个包含该词的文档计算得分
            invertedIndex.get(term).forEach((docId, tf) -> {
                int docLen = docLengths.getOrDefault(docId, (int) avgDocLength);
                
                // BM25 TF归一化公式
                double normalizedTF = tf * (K1 + 1) / 
                    (tf + K1 * (1 - B + B * docLen / avgDocLength));
                
                scores.merge(docId, idf * normalizedTF, Double::sum);
            });
        }
        
        // 排序，取Top-K
        return scores.entrySet().stream()
            .sorted(Map.Entry.<Integer, Double>comparingByValue().reversed())
            .limit(topK)
            .map(e -> ScoredDocId.of(e.getKey(), e.getValue()))
            .collect(Collectors.toList());
    }
    
    /**
     * 中文分词（使用Lucene SmartChineseAnalyzer或HanLP）
     */
    private List<String> tokenize(String text) {
        List<String> tokens = new ArrayList<>();
        
        try (TokenStream tokenStream = analyzer.tokenStream("content", text)) {
            CharTermAttribute termAttr = tokenStream.addAttribute(CharTermAttribute.class);
            tokenStream.reset();
            
            while (tokenStream.incrementToken()) {
                String term = termAttr.toString().toLowerCase();
                if (term.length() >= 2) {  // 过滤单字词
                    tokens.add(term);
                }
            }
            tokenStream.end();
        } catch (IOException e) {
            log.error("分词失败", e);
        }
        
        return tokens;
    }
}

三、SPLADE——神经稀疏检索

BM25是基于统计的稀疏检索，现在还有一种神经网络版本的稀疏检索——SPLADE（Sparse Lexical and Expansion）。

它用BERT来学习一个稀疏向量表示，词汇维度和BM25一样，但权重是神经网络学出来的，还能做词汇扩展（"增加"可以扩展到包含"提升"）。

@Service
public class SPLADEEncoderService {
    
    @Autowired
    private OrtEnvironment ortEnvironment;
    
    private OrtSession session;
    
    // 词表大小（BERT-base）
    private static final int VOCAB_SIZE = 30522;
    
    @PostConstruct
    public void loadModel() {
        // 加载SPLADE ONNX模型
        try {
            session = ortEnvironment.createSession(
                "models/splade-cocondenser-self.onnx",
                new OrtSession.SessionOptions()
            );
        } catch (OrtException e) {
            throw new RuntimeException("SPLADE模型加载失败", e);
        }
    }
    
    /**
     * 用SPLADE编码文本为稀疏向量
     * 返回非零位置和对应权重的Map
     */
    public Map<Integer, Float> encode(String text) {
        try {
            // 1. Tokenize
            long[] inputIds = tokenize(text);
            long[] attentionMask = new long[inputIds.length];
            Arrays.fill(attentionMask, 1);
            
            // 2. 运行SPLADE模型
            OnnxTensor inputIdsTensor = OnnxTensor.createTensor(
                ortEnvironment, new long[][]{inputIds}
            );
            OnnxTensor maskTensor = OnnxTensor.createTensor(
                ortEnvironment, new long[][]{attentionMask}
            );
            
            OrtSession.Result result = session.run(Map.of(
                "input_ids", inputIdsTensor,
                "attention_mask", maskTensor
            ));
            
            // 3. 获取logits，通过ReLU+log(1+x)激活
            float[][] logits = (float[][]) result.get(0).getValue();
            float[] activations = logits[0];
            
            // 4. 取最大激活值（沿token维度）得到稀疏表示
            Map<Integer, Float> sparseVector = new HashMap<>();
            for (int i = 0; i < Math.min(activations.length, VOCAB_SIZE); i++) {
                float activated = (float) Math.log(1 + Math.max(0, activations[i]));
                if (activated > 0.01) {  // 只保留显著非零值
                    sparseVector.put(i, activated);
                }
            }
            
            return sparseVector;
            
        } catch (Exception e) {
            log.error("SPLADE编码失败", e);
            return Collections.emptyMap();
        }
    }
    
    private long[] tokenize(String text) {
        // 调用BERT tokenizer，这里省略具体实现
        // 实际中用HuggingFace的Tokenizers库
        return new long[]{101, 1234, 5678, 102};  // 占位
    }
}

四、RRF算法详解与实现

有了稀疏检索和稠密检索的结果，如何融合？

Reciprocal Rank Fusion（RRF） 是目前实践中最简单有效的融合算法，计算公式非常简洁：

\text{RRF}(d) = \sum_{r \in R} \frac{1}{k + r(d)}

其中：

$r(d)$ 是文档 $d$ 在某个检索结果列表中的排名（从1开始）
$k$ 是一个平滑常数（通常取60）
$R$ 是所有检索结果列表的集合

直觉理解：一个文档在多个检索系统里都排名靠前，它的RRF分数就高；只在一个系统里靠前，分数就低。

@Service
public class ReciprocateRankFusionService {
    
    private static final int K = 60;  // RRF平滑常数
    
    /**
     * RRF融合多个检索结果列表
     */
    public List<FusedResult> fuse(List<List<RankedResult>> resultLists) {
        Map<String, Double> fusedScores = new HashMap<>();
        Map<String, RankedResult> docRegistry = new HashMap<>();  // 存储文档信息
        
        for (List<RankedResult> resultList : resultLists) {
            for (int rank = 0; rank < resultList.size(); rank++) {
                RankedResult result = resultList.get(rank);
                String docId = result.getDocId();
                
                // RRF得分：1/(k + rank)，rank从0开始所以用rank+1
                double rrfScore = 1.0 / (K + rank + 1);
                
                fusedScores.merge(docId, rrfScore, Double::sum);
                docRegistry.putIfAbsent(docId, result);
            }
        }
        
        // 按RRF得分排序
        return fusedScores.entrySet().stream()
            .sorted(Map.Entry.<String, Double>comparingByValue().reversed())
            .map(e -> FusedResult.builder()
                .docId(e.getKey())
                .rrfScore(e.getValue())
                .originalDoc(docRegistry.get(e.getKey()).getDocument())
                .build())
            .collect(Collectors.toList());
    }
    
    /**
     * 演示K值对排序的影响
     * K越大，排名差距带来的分数差越小（更平滑）
     * K越小，第1名和第2名的分数差越大（更陡峭）
     */
    public void demonstrateKEffect() {
        // k=60（默认）：rank1=0.0164, rank2=0.0160, rank10=0.0143
        // k=1：rank1=0.5, rank2=0.33, rank10=0.09（差距很大）
        // k=100：rank1=0.0099, rank2=0.0098, rank10=0.0091（差距很小）
        
        for (int k : new int[]{1, 20, 60, 100}) {
            System.out.printf("k=%d: rank1=%.4f, rank2=%.4f, rank10=%.4f%n",
                k, 1.0/(k+1), 1.0/(k+2), 1.0/(k+10));
        }
    }
}

五、完整的混合检索系统

把稀疏检索、稠密检索、RRF融合组合成完整系统：

@Service
public class HybridRetrievalService {
    
    @Autowired
    private VectorStore vectorStore;           // 稠密检索
    
    @Autowired
    private BM25IndexService bm25Service;      // BM25稀疏检索
    
    @Autowired
    private SPLADEEncoderService spladeEncoder; // SPLADE稀疏检索（可选）
    
    @Autowired
    private ReciprocateRankFusionService rrfService;
    
    @Autowired
    private DocumentRepository documentRepo;
    
    /**
     * 混合检索主入口
     */
    public List<Document> hybridSearch(String query, HybridSearchConfig config) {
        int retrievalSize = config.getTopK() * config.getOversampling();  // 多取一些，融合后再截断
        
        // 并行执行稀疏和稠密检索
        CompletableFuture<List<RankedResult>> denseFuture = CompletableFuture.supplyAsync(() ->
            executeDenseSearch(query, retrievalSize)
        );
        
        CompletableFuture<List<RankedResult>> sparseFuture = CompletableFuture.supplyAsync(() ->
            executeSparseSearch(query, retrievalSize)
        );
        
        List<RankedResult> denseResults;
        List<RankedResult> sparseResults;
        
        try {
            denseResults = denseFuture.get(5, TimeUnit.SECONDS);
            sparseResults = sparseFuture.get(5, TimeUnit.SECONDS);
        } catch (Exception e) {
            log.error("检索超时或失败", e);
            // 降级：只用稠密检索
            return vectorStore.similaritySearch(
                SearchRequest.query(query).withTopK(config.getTopK())
            );
        }
        
        // RRF融合
        List<List<RankedResult>> allResults = Arrays.asList(denseResults, sparseResults);
        List<FusedResult> fusedResults = rrfService.fuse(allResults);
        
        // 加载文档内容并截断到TopK
        return fusedResults.stream()
            .limit(config.getTopK())
            .map(fr -> {
                Document doc = fr.getOriginalDoc();
                // 设置融合后的分数
                return doc.withScore(fr.getRrfScore());
            })
            .collect(Collectors.toList());
    }
    
    private List<RankedResult> executeDenseSearch(String query, int size) {
        List<Document> docs = vectorStore.similaritySearch(
            SearchRequest.query(query).withTopK(size)
        );
        
        return IntStream.range(0, docs.size())
            .mapToObj(i -> RankedResult.builder()
                .docId(docs.get(i).getId())
                .rank(i)
                .score(docs.get(i).getScore())
                .document(docs.get(i))
                .source("dense")
                .build())
            .collect(Collectors.toList());
    }
    
    private List<RankedResult> executeSparseSearch(String query, int size) {
        List<ScoredDocId> bm25Results = bm25Service.search(query, size);
        
        return IntStream.range(0, bm25Results.size())
            .mapToObj(i -> {
                ScoredDocId scored = bm25Results.get(i);
                Document doc = documentRepo.findById(scored.getDocId());
                
                return RankedResult.builder()
                    .docId(String.valueOf(scored.getDocId()))
                    .rank(i)
                    .score(scored.getScore())
                    .document(doc)
                    .source("sparse")
                    .build();
            })
            .collect(Collectors.toList());
    }
}

六、Qdrant原生混合检索支持

如果你用的是Qdrant（我推荐的方案），它原生支持稀疏+稠密的混合检索，不需要自己实现RRF：

@Service
public class QdrantHybridSearchService {
    
    @Autowired
    private QdrantClient qdrantClient;
    
    @Autowired
    private EmbeddingModel embeddingModel;
    
    @Autowired
    private SPLADEEncoderService spladeEncoder;
    
    /**
     * 使用Qdrant内置的混合检索
     * Qdrant支持在一次请求中同时查询稀疏和稠密向量，然后用RRF融合
     */
    public List<ScoredPoint> hybridSearchNative(String query, int topK) {
        // 1. 生成稠密向量
        float[] denseVector = toFloatArray(
            embeddingModel.embed(query).getOutput()
        );
        
        // 2. 生成稀疏向量（SPLADE）
        Map<Integer, Float> sparseVector = spladeEncoder.encode(query);
        
        // 3. 构建混合查询请求
        // Qdrant的RRF参数：可以设置不同向量的权重
        QueryPoints queryPoints = QueryPoints.newBuilder()
            .setCollectionName("documents")
            .setQuery(Query.newBuilder()
                .setFusion(FusionQuery.newBuilder()
                    .setFusion(Fusion.RRF)
                    .addPrefetch(PrefetchQuery.newBuilder()
                        // 稠密向量检索
                        .setQuery(Query.newBuilder()
                            .setNearest(VectorInput.newBuilder()
                                .setDense(DenseVector.newBuilder()
                                    .addAllData(Floats.asList(denseVector))
                                    .build())
                                .build())
                            .build())
                        .setUsing("dense")
                        .setLimit(topK * 3)
                        .build())
                    .addPrefetch(PrefetchQuery.newBuilder()
                        // 稀疏向量检索
                        .setQuery(Query.newBuilder()
                            .setNearest(VectorInput.newBuilder()
                                .setSparse(SparseVector.newBuilder()
                                    .addAllIndices(sparseVector.keySet().stream()
                                        .mapToInt(Integer::intValue).boxed()
                                        .collect(Collectors.toList()))
                                    .addAllValues(new ArrayList<>(sparseVector.values()))
                                    .build())
                                .build())
                            .build())
                        .setUsing("sparse")
                        .setLimit(topK * 3)
                        .build())
                    .build())
                .build())
            .setLimit(topK)
            .setWithPayload(WithPayloadSelector.newBuilder().setEnable(true).build())
            .build();
        
        QueryResponse response = qdrantClient.queryAsync(queryPoints).get();
        return response.getResultList();
    }
    
    private float[] toFloatArray(List<Double> list) {
        float[] arr = new float[list.size()];
        for (int i = 0; i < list.size(); i++) arr[i] = list.get(i).floatValue();
        return arr;
    }
}

七、混合检索的权重调优

RRF的K值，以及多路检索时每路的权重，都需要调优。不同场景的最优配置不一样。

@Service
public class HybridSearchTuningService {
    
    @Autowired
    private BatchEvaluationFramework evaluationFramework;
    
    /**
     * 网格搜索：找最优的RRF参数和权重组合
     */
    public TuningResult gridSearch(List<TestCase> validationSet) {
        List<Integer> kValues = Arrays.asList(20, 40, 60, 80, 100);
        List<Double> alphaValues = Arrays.asList(0.3, 0.4, 0.5, 0.6, 0.7);
        
        TuningResult bestResult = null;
        double bestScore = 0;
        
        for (int k : kValues) {
            for (double alpha : alphaValues) {
                // alpha: 稠密向量权重，1-alpha: 稀疏向量权重
                HybridSearchConfig config = HybridSearchConfig.builder()
                    .rrfK(k)
                    .denseWeight(alpha)
                    .sparseWeight(1 - alpha)
                    .topK(10)
                    .oversampling(3)
                    .build();
                
                // 在验证集上评估
                double ndcg = evaluateOnValidationSet(validationSet, config);
                
                log.info("k={}, alpha={:.1f}: NDCG@10={:.4f}", k, alpha, ndcg);
                
                if (ndcg > bestScore) {
                    bestScore = ndcg;
                    bestResult = TuningResult.of(k, alpha, ndcg);
                }
            }
        }
        
        log.info("最优配置：k={}, alpha={:.1f}, NDCG@10={:.4f}",
            bestResult.getK(), bestResult.getAlpha(), bestResult.getScore());
        
        return bestResult;
    }
    
    private double evaluateOnValidationSet(List<TestCase> testCases, 
                                            HybridSearchConfig config) {
        double totalNDCG = 0;
        
        for (TestCase tc : testCases) {
            List<Document> results = hybridRetrievalService.hybridSearch(
                tc.getQuery(), config
            );
            
            totalNDCG += calculateNDCG(results, tc.getRelevantDocIds(), 10);
        }
        
        return totalNDCG / testCases.size();
    }
    
    /**
     * 计算NDCG@K
     */
    private double calculateNDCG(List<Document> results, 
                                   List<String> relevantDocIds, 
                                   int k) {
        double dcg = 0;
        double idcg = 0;
        
        // 计算DCG
        for (int i = 0; i < Math.min(results.size(), k); i++) {
            boolean relevant = relevantDocIds.contains(results.get(i).getId());
            if (relevant) {
                dcg += 1.0 / (Math.log(i + 2) / Math.log(2));
            }
        }
        
        // 计算理想DCG（所有相关文档都排在前面）
        for (int i = 0; i < Math.min(relevantDocIds.size(), k); i++) {
            idcg += 1.0 / (Math.log(i + 2) / Math.log(2));
        }
        
        return idcg == 0 ? 0 : dcg / idcg;
    }
    
    @Autowired
    private HybridRetrievalService hybridRetrievalService;
}

八、不同场景下的混合检索配置建议

基于我们在多个项目里的实验数据：

代码文档检索（函数名、类名是关键）：

稀疏权重高，alpha = 0.3（稠密30%，稀疏70%）
理由：代码中的标识符和关键词精确匹配很重要

通用知识问答：

均衡配置，alpha = 0.5
语义和关键词都重要

中文对话内容检索（口语化表达多）：

稠密权重高，alpha = 0.7
理由：口语表达语义相似但用词多变，语义检索更可靠

产品手册/规章制度：

稀疏权重略高，alpha = 0.4
理由：规章文档有大量专有术语和条款编号，精确匹配重要

九、实际效果对比

在我们的企业知识库（200万文档）上的A/B测试：

检索方式	Recall@5	Recall@10	MRR
纯稠密（BM25+Dense融合前的baseline）	0.68	0.78	0.61
纯稠密（Dense only）	0.71	0.81	0.64
纯稀疏（BM25）	0.59	0.72	0.54
混合（Dense+BM25+RRF）	0.79	0.88	0.72
混合（Dense+SPLADE+RRF）	0.81	0.90	0.74

混合检索（Dense+SPLADE）相比纯稠密检索，Recall@10提升了11个百分点，MRR提升了10个百分点。这个提升在实际用户体验上很明显：用户需要翻找第2页答案的情况显著减少。

SPLADE比BM25稍好，但好的不多，而SPLADE的部署成本（需要额外的ONNX模型和推理服务）比BM25高不少。如果资源有限，BM25+Dense已经能拿到大部分混合检索的收益。

下一篇讲RAG系统的缓存架构——语义缓存的设计与命中率优化。这是从性能和成本角度优化RAG系统的重要手段，特别是在高并发场景下，语义缓存可以把延迟降低90%以上。