RAG 混合检索生产实战指南:从召回原理到高并发架构落地

【AIGC】AI如何匹配RAG知识库:混合检索 混合检索技术通过结合关键词检索和语义检索的优势,实现了多路召回,从而提高了检索的准确性和全面性。掌握上面我们提到的混合检索,不仅你可以根据自己的实际情况去对多种检索方式的权重进行加权,还可以根据自己的实际情况去调整对应的召回策略,对我们自建RAG检索有着极大帮助,希望本文能对你有启示。 阅读详情

这不是一篇“向量库 + BM25”入门文,而是一份面向真实业务场景的生产级设计手册。我们会从检索原理、系统架构、并发治理、索引一致性、可观测性、代码实现和演进路线几条主线,系统讲清楚如何把 RAG 混合检索做成一套稳定、可扩展、可运营的在线服务。


一、为什么要重写 RAG 检索链路

很多团队做 RAG 时,第一版通常都很快:

    1. 文档切块
    1. 生成向量
    1. 写入向量库
    1. 查询时做一次相似度搜索
    1. 把 TopK 文本拼进 Prompt

Demo 阶段这条链路完全成立,但一旦进入真实生产环境,很快就会遇到四类问题:

  • • 检索质量不稳定:能回答“怎么配置单点登录”,却回答不好“错误码 AUTH_403_17 是什么”
  • • 时延不可控:低峰期 150ms,高峰期 P99 飙到 2 秒以上
  • • 数据一致性差:ES 中能搜到,Milvus 中搜不到;或者新版本 FAQ 已入库但旧答案还在命中
  • • 运营复杂度高:多租户隔离、灰度索引、热更新配置、链路追踪、容量评估都没有设计

这背后的核心原因并不是模型不够强,而是把“检索”当成了单点能力,而没有把它设计成一条完整的在线系统。

生产级 RAG 的本质不是“搜出来”,而是“在时延预算内,稳定、可解释、可隔离地搜对”。


二、典型业务场景与真实约束

先看一个足够真实的企业知识问答场景。

一个面向 SaaS 客户的智能知识助手,底层接入:

  • • 产品帮助中心
  • • 运维手册
  • • API 文档
  • • 售后 FAQ
  • • 工单经验库
  • • 版本发布说明

系统目标:

  • • 支持企业租户隔离
  • • 支持秒级新增文档可检索
  • • 支持 3000+ QPS 峰值查询
  • • 支持答案引用来源追踪
  • • 支持错误码、接口名、版本号、SKU 等精确术语召回

这类场景有三个非常鲜明的特点。

1. 问题类型混杂

用户提问既包含语义问题,也包含精确匹配问题。

例如:

  • • “如何配置跨域认证”
  • • “tenant_id 字段在哪个接口出现”
  • • “ERR_CODE_50421 的修复方式是什么”
  • • “2.3.7 版本登录失败和 Redis 有关系吗”

前两类问题需要语义理解,后两类问题高度依赖关键词、标识符和局部精确命中。

2. 查询流量有明显热点与长尾

  • • 热点问题重复率高,适合缓存
  • • 长尾问题表达多样,依赖召回覆盖率
  • • 发布日、故障日、活动日会出现突发流量

3. 文档更新不是离线行为

企业知识库经常会发生:

  • • FAQ 新增
  • • 产品文档改版
  • • 权限策略变化
  • • 工单经验沉淀
  • • 旧知识失效

这意味着索引系统必须支持增量更新、版本管理和不停服切换。


三、为什么纯向量检索一定不够

很多团队第一次遇到召回问题时,会直觉地认为“换更强 embedding 模型就好了”。这通常只能缓解,不能根治。

1. 纯 Dense Retrieval 的优势

稠密检索擅长:

  • • 同义表达匹配
  • • 自然语言 paraphrase
  • • 非字面相似问题的语义召回

例如:

  • • “怎么限制接口被别人乱调”
  • • “如何做 API 鉴权和访问控制”

这两句话虽然不共享太多关键词,但语义高度相关,向量检索很有优势。

2. 纯 Dense Retrieval 的天然盲区

稠密检索对以下内容通常不稳定:

  • • 错误码
  • • 订单号
  • • 接口名
  • • 字段名
  • • SKU
  • • 版本号
  • • 类名、方法名、配置项

原因很简单:这些 token 在语义空间中的分布并不稳定,且大量属于低频实体、专有名词、结构化片段,embedding 模型往往不会把它们编码成足够强的“精确锚点”。

例如:

  • • AUTH_403_17
  • • X-Trace-Id
  • • sku_id
  • • application-prod.yaml

如果只依赖向量召回,这类问题要么召回不到,要么被语义相近但实际无关的文档“挤掉”。

3. 纯 Sparse Retrieval 也不够

关键词检索的问题同样明显:

  • • 不能理解语义改写
  • • 无法处理用户口语化表达
  • • 对上下文理解弱
  • • 容易被噪音词干扰

比如用户问:

  • • “为什么我配置完回调地址还是验签失败”

如果文档标题写的是“Webhook 回调签名校验失败排查”,纯关键词检索未必能稳定排到前面。

4. 结论

Dense 与 Sparse 不是替代关系,而是正交互补关系。

  • • Dense 负责语义覆盖
  • • Sparse 负责精确命中
  • • Rerank 负责前排质量

因此,真正的生产级方案一定是:

双路召回 + 融合排序 + 精排兜底 + 权限过滤 + 超时降级。


四、混合检索的核心原理

4.1 稀疏检索:BM25 解决“字面命中”

稀疏检索通常采用 BM25 或其变种,本质上是在问:

“查询中的这些词,在这篇文档里出现了多少次,它们稀有吗,这篇文档是否过长导致词频被稀释?”

经典 BM25 公式:

Score(D, Q) = Σ IDF(qi) * ((f(qi, D) * (k1 + 1)) / (f(qi, D) + k1 * (1 - b + b * |D| / avgdl)))

其中:

  • • f(qi, D):词项在文档中的词频
  • • IDF(qi):逆文档频率,越稀有权重越大
  • • |D|:文档长度
  • • avgdl:平均文档长度
  • • k1:词频饱和控制
  • • b:长度归一化权重

工程上的经验值:

  • • FAQ、问答类文档:k1=0.8~1.2,b=0.6~0.75
  • • 代码片段、配置文档:b 可以更低,通常 0.2~0.5

如果文档中有大量结构化字段,比如错误码、接口路径、类名、方法名,建议为这些字段建立单独的 searchable field,而不是全部混在正文里。

4.2 稠密检索:向量召回解决“语义相似”

稠密检索通常流程如下:

Query -> Embedding Model -> Query Vector -> ANN Search -> TopK

关键点不在“能搜”,而在“搜得稳”。

主要关注四件事:

    1. 向量模型是否匹配领域语料
    1. ANN 索引是否适配数据规模
    1. 相似度度量是否一致
    1. 查询时向量生成是否成为瓶颈

常见索引选择:

索引特点适合场景
IVF_FLAT构建快,精度中等中小规模,快速起步
IVF_PQ压缩强,省内存成本敏感场景
HNSW高召回,低延迟百万级到千万级主流生产场景
DiskANN适合超大规模十亿级以上或内存受限场景

对于企业知识库,HNSW 是非常常见的默认生产选择,原因是它在召回率、延迟和工程成熟度之间平衡最好。

4.3 融合排序:让两路召回形成合力

双路召回之后,最大的问题不是“怎么合并”,而是“怎么公平地合并”。

因为 Dense 和 Sparse 的打分体系完全不同:

  • • BM25 分数通常没有固定上界
  • • 向量相似度可能是 cosine、IP、L2 转换值

直接线性相加通常不稳定。

RRF:最稳妥的工程默认值

RRF(Reciprocal Rank Fusion)公式:

RRF(d) = Σ 1 / (k + rank_i(d))

优点:

  • • 不依赖原始分数尺度
  • • 对不同检索器分值分布不敏感
  • • 实现简单
  • • 灰度调参成本低

缺点:

  • • 不利用原始分差
  • • 对 rank 之外的信息利用有限

Weighted Fusion:更灵活,但更难调

FusionScore(d) = α * norm(denseScore) + (1 - α) * norm(sparseScore)

适合:

  • • 已掌握两类打分分布
  • • 有离线评测体系
  • • 需要按租户、按场景动态权重

生产建议:

  • • 第一版默认上 RRF
  • • 有足够评测与反馈数据后,再引入 weighted fusion 或 learning-to-rank

4.4 Rerank:决定最终上下文质量

粗排阶段的目标是“不要漏掉”,精排阶段的目标是“前几条必须准”。

Reranker 一般使用 Cross-Encoder,其工作方式是:

[Query, CandidateDoc] -> Relevance Score

与 Bi-Encoder 相比,Cross-Encoder 会同时看到 query 和 document 的交互关系,因此精度更高,但代价也更高。

工程约束通常是:

  • • 召回 Top50 或 Top100
  • • Rerank 后截取 Top5 或 Top10
  • • 对时延设置硬预算

如果查询链路总预算是 500ms,Rerank 通常不能无限制吃掉时间。


五、从算法到系统:生产级 RAG 检索链路分层

一个成熟的在线检索系统,建议至少拆成以下几层。

1. Query Understanding 层

负责:

  • • 查询清洗
  • • 拼写纠错
  • • 同义词扩展
  • • 领域术语归一化
  • • 查询改写
  • • 意图分类

例如把:

  • • “登录一直 403”

标准化成:

  • • 原始 query:登录一直 403
  • • 扩展 query:登录 403 AUTH_403 认证失败 权限不足
  • • 检索字段 hint:error_code, title, content

2. Candidate Retrieval 层

并行发起:

  • • 稀疏召回
  • • 稠密召回

这里的核心不是“并发执行”四个字,而是:

  • • 每一路要有独立超时
  • • 每一路失败不能拖垮整条链路
  • • 每一路的召回结果要保留来源标签,方便后续分析

3. Merge & Dedup 层

负责:

  • • 去重
  • • 融合
  • • 阈值过滤
  • • 候选截断

4. Permission Filter 层

负责:

  • • 租户隔离
  • • 文档级权限
  • • 段落级安全标签
  • • 发布时间、生效状态、版本过滤

注意顺序:权限过滤必须在进入生成模型之前完成。

5. Rerank 层

负责:

  • • 相关性精排
  • • 候选数量裁剪
  • • 高风险结果降权

6. Context Builder 层

负责:

  • • 上下文去重
  • • Token 预算控制
  • • 引用片段截取
  • • 证据排序

7. Answer Generation 层

负责:

  • • Prompt 拼装
  • • 答案生成
  • • 引用绑定
  • • 兜底回复

六、面向高并发的整体架构设计

下面给出一套更贴近生产环境的服务架构。

┌──────────────────────────────┐                │       Client / Gateway       │                └──────────────┬───────────────┘                               │                        Auth / Rate Limit                               │                ┌──────────────▼───────────────┐                │      Query Orchestrator      │                │  rewrite / route / timeout   │                └───────┬───────────┬──────────┘                        │           │             ┌──────────▼───┐   ┌──▼────────────┐             │ Sparse Search │   │ Dense Search  │             │ ES / OpenSearch│  │ Milvus / pgv  │             └──────────┬────┘   └────┬──────────┘                        │             │                        └──────┬──────┘                               ▼                     Merge / Dedup / Filter                               │                               ▼                          Rerank Service                               │                               ▼                       Context Builder / LLM                               │                               ▼                           Final ResponseData Plane:Document Upload -> Normalize -> Chunk -> Embed -> ES + Vector DB                                 │                                 ▼                              Kafka / MQ                                 │                                 ▼                    Index Worker / Retry / DLQ / Metrics

架构上的关键原则有五个。

1. 检索服务无状态

在线检索服务不保存会话状态,不绑定本地缓存,不持有索引构建职责。这样才能:

  • • 横向扩容
  • • 灰度发布
  • • 快速回滚

2. 检索、Embedding、Rerank 三类算力分离

它们的资源特征完全不同:

  • • 检索服务偏 CPU、网络和序列化
  • • Embedding 偏 GPU/CPU 推理吞吐
  • • Rerank 偏 GPU 且对时延更敏感

混部署只会互相争抢资源。

3. 在线查询与离线建索引解耦

新增文档、重建索引、回填 embedding 不能阻塞在线查询。最常见做法是事件驱动:

  • • 上传文档
  • • 产生索引事件
  • • 异步消费
  • • 成功后更新索引版本

4. 所有外部依赖都必须可超时、可熔断、可降级

在真实高峰期,你最先遇到的问题不是“没有结果”,而是:

  • • ES 偶发抖动
  • • 向量库 segment compaction
  • • GPU 服务队列积压
  • • 配置中心抖动

所以链路设计必须接受“局部失败”,并把失败限定在单个阶段。

5. 用预算思维管理时延

比如整条查询链路预算 800ms:

  • • Query rewrite:80ms
  • • Sparse retrieval:120ms
  • • Dense retrieval:180ms
  • • Merge/filter:20ms
  • • Rerank:220ms
  • • Prompt assemble + LLM 前置:80ms
  • • Buffer:100ms

如果某一层无限占用,系统整体一定失控。


七、在线查询链路设计:不是并发执行,而是并发治理

很多文章会写“稀疏检索和稠密检索并行调用”,但生产环境真正重要的是下面这几个问题:

1. 部分成功优于全部失败

如果 Dense 超时,但 Sparse 正常,系统仍应返回可用结果,而不是整个请求 500。

2. 召回阶段要保留 trace 信息

每个候选文档最好记录:

  • • 来自哪一路检索
  • • 原始分数是多少
  • • 在该路中的 rank 是多少
  • • 是否通过权限过滤
  • • 是否进入 rerank

否则线上一旦回答失真,你根本不知道问题发生在召回、融合、重排还是上下文构建。

3. 要支持动态退化策略

例如:

  • • 高峰期关闭 query rewrite
  • • Dense 超时时只用 Sparse
  • • Rerank 服务繁忙时直接用融合结果返回
  • • 热点 query 直接命中缓存

4. 结果去重不能只按 doc_id

生产里一个文档往往被切成多个 chunk,去重策略通常要综合:

  • • doc_id
  • • chunk_id
  • • semantic_hash
  • • 归并窗口

否则可能把同一段证据重复喂给模型,浪费 token。


八、离线入库与索引构建:生产问题大多出在这里

RAG 检索质量的一半,实际上在“文档入库”阶段就已经决定了。

8.1 文档标准化

入库前建议统一抽取:

  • • tenant_id
  • • doc_id
  • • source_type
  • • title
  • • content
  • • tags
  • • publish_time
  • • version
  • • acl
  • • language

8.2 分块不是越小越好

切块过小:

  • • 语义不完整
  • • 上下文断裂
  • • rerank 噪声大

切块过大:

  • • 召回不够细粒度
  • • 稀疏检索命中不稳定
  • • token 浪费

通用经验:

  • • FAQ:一个问答对通常就是一个 chunk
  • • 产品文档:300~800 中文字较常见
  • • API 文档:按接口或字段组块
  • • 运维手册:按步骤段落切

8.3 双索引写入必须考虑一致性

混合检索天然意味着至少两套索引:

  • • 稀疏索引
  • • 向量索引

常见问题:

  • • ES 成功,向量库失败
  • • 向量成功,ES 失败
  • • 文档更新时新旧版本并存
  • • 重试导致重复写入

所以建议:

  • • 用事件 ID 保证幂等
  • • 用版本号控制读写可见性
  • • 用补偿任务修复不一致
  • • 用索引别名支持蓝绿切换

8.4 秒级生效与批量重建要同时支持

生产中至少要支持两条入库通道:

  • • 增量更新:新增 FAQ、修复说明、紧急公告,要求秒级生效
  • • 批量重建:模型升级、切块策略变化、字段结构调整,要求低风险迁移

这也是为什么索引 alias 和版本号设计非常关键。


九、生产级 Go 代码实现:混合检索编排器

下面给出一套更接近生产环境的核心实现。代码重点不在“能跑通 demo”,而在体现几个关键设计:

  • • 查询预算控制
  • • 并行召回
  • • 局部失败降级
  • • 候选去重与融合
  • • 可观测字段保留

9.1 核心模型定义

package searchimport (    "context"    "time")type SearchRequest struct {    RequestID   string    TenantID    string    UserID      string    Query       string    Filters     map[string]string    TopK        int    CandidateK  int    Timeout     time.Duration    UseRerank   bool}type Candidate struct {    DocID         string    ChunkID       string    Content       string    Title         string    Score         float64    Source        string    SparseRank    int    DenseRank     int    RerankScore   float64    Version       int64    Metadata      map[string]string}type SearchResponse struct {    RequestID  string    Candidates []Candidate    Degraded   bool    Debug      DebugInfo}type DebugInfo struct {    SparseUsed   bool    DenseUsed    bool    RerankUsed   bool    SparseCostMs int64    DenseCostMs  int64    RerankCostMs int64    Fallbacks    []string}type SparseSearcher interface {    Search(ctx context.Context, req SearchRequest) ([]Candidate, error)}type DenseSearcher interface {    Search(ctx context.Context, req SearchRequest) ([]Candidate, error)}type Reranker interface {    Rerank(ctx context.Context, query string, docs []Candidate, topK int) ([]Candidate, error)}type PermissionFilter interface {    Filter(ctx context.Context, req SearchRequest, docs []Candidate) ([]Candidate, error)}

9.2 时间预算分配器

package searchimport "time"type Budget struct {    total time.Duration    used  time.Duration}func NewBudget(total time.Duration) *Budget {    return &Budget{total: total}}func (b *Budget) Allocate(ratio float64, min time.Duration) time.Duration {    rest := b.total - b.used    if rest <= 0 {        return min    }    alloc := time.Duration(float64(b.total) * ratio)    if alloc < min {        alloc = min    }    if alloc > rest {        alloc = rest    }    b.used += alloc    return alloc}

9.3 检索编排服务

package searchimport (    "context"    "errors"    "sort"    "time"    "golang.org/x/sync/errgroup")var ErrNoCandidate = errors.New("no candidate found")type HybridSearchService struct {    sparse   SparseSearcher    dense    DenseSearcher    reranker Reranker    filter   PermissionFilter    fusion   FusionStrategy}func (s *HybridSearchService) Search(ctx context.Context, req SearchRequest) (SearchResponse, error) {    if req.TopK <= 0 {        req.TopK = 5    }    if req.CandidateK <= 0 {        req.CandidateK = 50    }    if req.Timeout <= 0 {        req.Timeout = 800 * time.Millisecond    }    ctx, cancel := context.WithTimeout(ctx, req.Timeout)    defer cancel()    budget := NewBudget(req.Timeout)    sparseTimeout := budget.Allocate(0.20, 80*time.Millisecond)    denseTimeout := budget.Allocate(0.30, 120*time.Millisecond)    rerankTimeout := budget.Allocate(0.30, 150*time.Millisecond)    resp := SearchResponse{RequestID: req.RequestID}    var sparseDocs []Candidate    var denseDocs []Candidate    var sparseErr error    var denseErr error    g, gctx := errgroup.WithContext(ctx)    g.Go(func() error {        start := time.Now()        subCtx, cancel := context.WithTimeout(gctx, sparseTimeout)        defer cancel()        docs, err := s.sparse.Search(subCtx, req)        resp.Debug.SparseCostMs = time.Since(start).Milliseconds()        if err != nil {            sparseErr = err            return nil        }        resp.Debug.SparseUsed = true        sparseDocs = docs        return nil    })    g.Go(func() error {        start := time.Now()        subCtx, cancel := context.WithTimeout(gctx, denseTimeout)        defer cancel()        docs, err := s.dense.Search(subCtx, req)        resp.Debug.DenseCostMs = time.Since(start).Milliseconds()        if err != nil {            denseErr = err            return nil        }        resp.Debug.DenseUsed = true        denseDocs = docs        return nil    })    _ = g.Wait()    if len(sparseDocs) == 0 && len(denseDocs) == 0 {        return resp, ErrNoCandidate    }    if sparseErr != nil {        resp.Degraded = true        resp.Debug.Fallbacks = append(resp.Debug.Fallbacks, "sparse_failed")    }    if denseErr != nil {        resp.Degraded = true        resp.Debug.Fallbacks = append(resp.Debug.Fallbacks, "dense_failed")    }    merged := s.fusion.Merge(sparseDocs, denseDocs, req.CandidateK)    filtered, err := s.filter.Filter(ctx, req, merged)    if err != nil {        return resp, err    }    if len(filtered) == 0 {        return resp, ErrNoCandidate    }    if !req.UseRerank || s.reranker == nil {        if len(filtered) > req.TopK {            filtered = filtered[:req.TopK]        }        resp.Candidates = filtered        return resp, nil    }    rerankCtx, rerankCancel := context.WithTimeout(ctx, rerankTimeout)    defer rerankCancel()    start := time.Now()    reranked, err := s.reranker.Rerank(rerankCtx, req.Query, filtered, req.TopK)    resp.Debug.RerankCostMs = time.Since(start).Milliseconds()    if err != nil {        resp.Degraded = true        resp.Debug.Fallbacks = append(resp.Debug.Fallbacks, "rerank_failed")        if len(filtered) > req.TopK {            filtered = filtered[:req.TopK]        }        resp.Candidates = filtered        return resp, nil    }    resp.Debug.RerankUsed = true    resp.Candidates = reranked    return resp, nil}type FusionStrategy interface {    Merge(sparse []Candidate, dense []Candidate, limit int) []Candidate}

9.4 RRF 融合实现

package searchimport "sort"type RRFFusion struct {    K int}func (f RRFFusion) Merge(sparse []Candidate, dense []Candidate, limit int) []Candidate {    if f.K <= 0 {        f.K = 60    }    type agg struct {        doc Candidate        score float64    }    table := make(map[string]*agg, len(sparse)+len(dense))    mergeOne := func(list []Candidate, source string) {        for idx, item := range list {            key := item.DocID + "#" + item.ChunkID            if _, ok := table[key]; !ok {                cp := item                table[key] = &agg{doc: cp}            }            table[key].score += 1.0 / float64(f.K+idx+1)            if source == "sparse" {                table[key].doc.SparseRank = idx + 1            }            if source == "dense" {                table[key].doc.DenseRank = idx + 1            }        }    }    mergeOne(sparse, "sparse")    mergeOne(dense, "dense")    out := make([]Candidate, 0, len(table))    for _, v := range table {        v.doc.Score = v.score        out = append(out, v.doc)    }    sort.Slice(out, func(i, j int) bool {        if out[i].Score == out[j].Score {            return out[i].Version > out[j].Version        }        return out[i].Score > out[j].Score    })    if limit > 0 && len(out) > limit {        out = out[:limit]    }    return out}

9.5 Dense 检索实现要点

生产级 Dense Search 不只是“调一次向量库”,还要包含:

  • • embedding 缓存
  • • 多租户过滤表达式
  • • 热点 query 限流
  • • ANN 参数控制
  • • 失败重试边界
package searchimport (    "context"    "fmt"    "time")type EmbeddingClient interface {    Embed(ctx context.Context, text string) ([]float32, error)}type VectorStore interface {    Search(ctx context.Context, vector []float32, tenantID string, filters map[string]string, topK int) ([]Candidate, error)}type Cache interface {    Get(key string) (any, bool)    Set(key string, value any, ttl time.Duration)}type DenseService struct {    embedder EmbeddingClient    store    VectorStore    cache    Cache}func (d *DenseService) Search(ctx context.Context, req SearchRequest) ([]Candidate, error) {    cacheKey := "embed:" + req.TenantID + ":" + req.Query    if cached, ok := d.cache.Get(cacheKey); ok {        return d.store.Search(ctx, cached.([]float32), req.TenantID, req.Filters, req.CandidateK)    }    vector, err := d.embedder.Embed(ctx, req.Query)    if err != nil {        return nil, fmt.Errorf("embed query failed: %w", err)    }    d.cache.Set(cacheKey, vector, 10*time.Minute)    return d.store.Search(ctx, vector, req.TenantID, req.Filters, req.CandidateK)}

9.6 Rerank 服务调用策略

Rerank 不是“候选有多少就打多少”,而是要受控:

  • • 设置最大候选数
  • • 支持 batch 推理
  • • 设置最小相关性阈值
  • • 对超时直接降级
package searchimport "sort"type ScoreClient interface {    ScorePairs(query string, docs []string) ([]float64, error)}type CrossEncoderReranker struct {    client            ScoreClient    maxCandidates     int    minScoreThreshold float64}func (r *CrossEncoderReranker) Rerank(ctx context.Context, query string, docs []Candidate, topK int) ([]Candidate, error) {    if r.maxCandidates > 0 && len(docs) > r.maxCandidates {        docs = docs[:r.maxCandidates]    }    texts := make([]string, 0, len(docs))    for _, doc := range docs {        texts = append(texts, doc.Content)    }    scores, err := r.client.ScorePairs(query, texts)    if err != nil {        return nil, err    }    out := make([]Candidate, 0, len(docs))    for i := range docs {        docs[i].RerankScore = scores[i]        docs[i].Score = scores[i]        if docs[i].Score >= r.minScoreThreshold {            out = append(out, docs[i])        }    }    sort.Slice(out, func(i, j int) bool {        return out[i].Score > out[j].Score    })    if topK > 0 && len(out) > topK {        out = out[:topK]    }    return out, nil}

十、索引写入链路:保证幂等、一致性和可恢复

混合检索最大的工程风险之一,是双写一致性。

推荐设计如下:

10.1 事件驱动写入模型

Document Saved -> Outbox Event -> MQ -> Index Worker                                   ├─ write sparse index                                   ├─ write dense index                                   ├─ update status                                   └─ retry / DLQ

这样做的好处是:

  • • 避免请求线程里同步做重活
  • • 支持削峰填谷
  • • 支持失败重放
  • • 支持批量回补

10.2 生产级写入代码示例

package indexerimport (    "context"    "fmt")type IndexEvent struct {    EventID   string    TenantID  string    DocID     string    Version   int64    Operation string}type EventStore interface {    MarkProcessing(ctx context.Context, eventID string) error    MarkSucceeded(ctx context.Context, eventID string) error    MarkFailed(ctx context.Context, eventID string, reason string) error    IsProcessed(ctx context.Context, eventID string) (bool, error)}type SparseWriter interface {    Upsert(ctx context.Context, event IndexEvent) error}type DenseWriter interface {    Upsert(ctx context.Context, event IndexEvent) error}type Worker struct {    events EventStore    sparse SparseWriter    dense  DenseWriter}func (w *Worker) Handle(ctx context.Context, event IndexEvent) error {    done, err := w.events.IsProcessed(ctx, event.EventID)    if err != nil {        return err    }    if done {        return nil    }    if err := w.events.MarkProcessing(ctx, event.EventID); err != nil {        return err    }    if err := w.sparse.Upsert(ctx, event); err != nil {        _ = w.events.MarkFailed(ctx, event.EventID, "sparse_upsert_failed")        return fmt.Errorf("sparse upsert failed: %w", err)    }    if err := w.dense.Upsert(ctx, event); err != nil {        _ = w.events.MarkFailed(ctx, event.EventID, "dense_upsert_failed")        return fmt.Errorf("dense upsert failed: %w", err)    }    if err := w.events.MarkSucceeded(ctx, event.EventID); err != nil {        return err    }    return nil}

10.3 为什么不建议做强事务双写

ES 和向量库通常不是同一个事务域,强行做分布式事务代价很高,恢复复杂度也高。实际工程里更常见、更稳妥的方案是:

  • • 幂等事件
  • • 状态机管理
  • • 重试队列
  • • 差异巡检任务
  • • 别名切换兜底

也就是说,我们追求的是最终一致性可控,而不是理论强一致但系统脆弱。


十一、多租户隔离与权限安全设计

RAG 系统最不能犯的错误不是“答得不准”,而是“串库”。

11.1 最低要求:租户级隔离

每条文档、每个 chunk、每个索引记录都必须带:

  • • tenant_id
  • • doc_acl
  • • status
  • • version

查询时这些条件必须前置到检索层,而不能只在生成后再过滤。

11.2 建议的过滤顺序

tenant filter -> document status -> ACL -> business filters -> rerank -> context build

11.3 不要把权限判断交给模型

错误做法:

  • • 检索出所有结果
  • • 把内容交给 LLM
  • • 再让 LLM“尽量不要回答越权信息”

这在生产里不可接受。正确做法是:

  • • 先过滤,再生成

11.4 多租户索引组织建议

视规模而定:

    1. 小规模租户:共享 collection / index,使用 tenant_id 过滤
    1. 中规模租户:共享大索引 + 热租户独立 partition
    1. 大客户或监管场景:独立索引、独立资源池,甚至独立集群

当你进入大客户场景后,多租户不是简单的查询条件问题,而是资源隔离、SLA 隔离和成本核算问题。


十二、高并发治理:缓存、限流、隔离、退化

如果系统要扛高并发,必须接受一个现实:

不是所有请求都值得走完整链路。

12.1 三层缓存设计

建议至少设计三层缓存。

第一层:Query Embedding 缓存

适合重复问题较多的场景,可显著降低 embedding 服务压力。

缓存 key 示例:

embed:{tenant_id}:{normalized_query}:{model_version}
第二层:检索结果缓存

适合热点 FAQ、活动公告、运维排障类问题。

缓存 value 建议包含:

  • • 候选文档 ID 列表
  • • 索引版本号
  • • 生成时间

一旦索引版本变化,需要失效。

第三层:答案缓存

只适合强事实、低变化问题,不适合高实时性知识。

12.2 限流策略

限流建议分三层:

    1. API Gateway 按租户限流
    1. 查询编排服务按用户限流
    1. GPU 服务按并发队列限流

不要只在入口限流,否则下游 GPU 服务仍可能被打爆。

12.3 隔离策略

把不同资源类型拆开:

  • • CPU 池:检索与编排
  • • GPU 池:Embedding、Rerank
  • • Worker 池:索引构建

避免索引重建抢占在线查询资源。

12.4 退化策略

生产里建议预先定义退化级别。

级别条件动作
L0正常全链路执行
L1Dense 超时只用 Sparse + 轻量排序
L2Rerank 超时返回融合结果
L3GPU 服务拥塞关闭 query rewrite 和 rerank
L4索引系统抖动命中缓存或返回兜底答案

一旦没有明确的退化策略,系统在高峰期就只能“随机坏”。


十三、可观测性:没有指标,就没有检索工程

RAG 检索链路必须至少覆盖三类观测数据。

13.1 Metrics

建议重点监控:

  • • 查询 QPS
  • • 请求成功率
  • • 各阶段 P50/P95/P99 时延
  • • 稀疏召回命中数
  • • 稠密召回命中数
  • • 融合后候选数
  • • Rerank 耗时
  • • 缓存命中率
  • • 降级比例
  • • 无结果比例

13.2 Structured Logging

每次查询建议记录:

  • • request_id
  • • tenant_id
  • • query
  • • normalized_query
  • • sparse_doc_ids
  • • dense_doc_ids
  • • fusion_doc_ids
  • • rerank_doc_ids
  • • degrade_flags

13.3 Tracing

链路追踪至少要覆盖:

  • • rewrite
  • • sparse
  • • dense
  • • filter
  • • rerank
  • • llm

这样才能快速判断问题到底卡在检索、推理还是生成。

13.4 质量评估指标

除了系统指标,还要持续看效果指标:

  • • Recall@K
  • • MRR
  • • NDCG@K
  • • Answer grounded rate
  • • Citation hit rate
  • • 用户追问率
  • • 人工纠错率

生产环境中最可怕的不是系统报错,而是系统“稳定地产生错误答案”。


十四、配置中心与动态调优

混合检索是一套需要持续调参的系统,因此配置必须动态化。

建议进入配置中心的项目包括:

  • • 每一路召回 TopK
  • • RRF 的 k
  • • weighted fusion 的 alpha
  • • rerank 是否开启
  • • rerank 最大候选数
  • • 各阶段 timeout
  • • 缓存 TTL
  • • 降级开关

示例配置:

search:  request_timeout_ms: 800  candidate_top_k: 60  final_top_k: 6  query_rewrite:    enabled: true    timeout_ms: 80  sparse:    enabled: true    timeout_ms: 120    top_k: 40  dense:    enabled: true    timeout_ms: 180    top_k: 40    ef_search: 128  fusion:    strategy: rrf    rrf_k: 60    weighted_alpha: 0.55  rerank:    enabled: true    timeout_ms: 220    max_candidates: 30    min_score_threshold: 0.1  degrade:    disable_rerank_when_gpu_queue_gt: 200    disable_dense_when_timeout_ratio_gt: 0.15

调参原则:

  • • 先保证稳定性,再追求最优召回
  • • 先做灰度,再全量生效
  • • 所有配置变更都要可回滚

十五、Kubernetes 与服务部署建议

生产部署建议至少拆成以下服务:

  • • query-orchestrator
  • • sparse-search-adapter
  • • dense-search-adapter
  • • embedding-service
  • • rerank-service
  • • index-worker
  • • index-audit-job

15.1 资源建议

查询编排服务
  • • 无状态
  • • CPU 优先
  • • 高副本
  • • 绑定 HPA
Embedding 服务
  • • 独立部署
  • • 支持批量推理
  • • 使用 GPU 或高性能 CPU
  • • 按队列长度和显存利用率伸缩
Rerank 服务
  • • 与 Embedding 分离
  • • 严格限制最大批次
  • • 优先保证时延稳定

15.2 灰度与别名切换

索引更新不要直接覆盖主索引,建议:

    1. 新建 index_v2
    1. 回填数据
    1. 完成校验
    1. 切 alias
    1. 观察稳定性
    1. 再下线旧索引

这比在线强改结构安全得多。

15.3 HPA 指标建议

不同服务用不同伸缩指标:

  • • Query Orchestrator:QPS、CPU、P99
  • • Embedding Service:GPU 利用率、队列长度、请求等待时间
  • • Rerank Service:P95 时延、队列长度
  • • Index Worker:消费 lag

十六、真实案例:企业知识助手的生产化改造

下面给一个更贴近实际的升级案例。

16.1 改造前

架构:

  • • Java 单体服务
  • • 本地向量索引
  • • 单路向量召回
  • • 没有 rerank
  • • 文档更新靠定时全量重建

线上问题:

  • • 错误码问题几乎答不好
  • • FAQ 更新后几个小时才能检索到
  • • 一次版本发布后,索引重建拖垮线上 CPU
  • • 用户问同一个问题,答案稳定性差

16.2 改造后

改造项:

  • • 增加 ES 稀疏召回
  • • 引入 Milvus HNSW 向量检索
  • • 用 RRF 做融合
  • • 接入 Cross-Encoder rerank
  • • 文档入库改为事件驱动
  • • Embedding 与 Rerank 服务独立 GPU 化
  • • 增加缓存、限流与退化策略

16.3 改造效果

典型收益:

  • • Recall@20 从 76% 提升到 92% 左右
  • • 精确术语问题命中率明显提升
  • • FAQ 增量更新可做到秒级到分钟级可检索
  • • 高峰期即使 Dense 或 Rerank 抖动,系统仍能返回可用结果
  • • 问题排查从“猜是哪层错了”变成“基于 trace 快速定位”

这类收益的本质并不是某一个模型指标提升,而是系统从“单点能力”升级成了“可治理的检索平台”。


十七、离线评测与线上优化闭环

没有评测,调参就是拍脑袋。

建议建立两类评测闭环。

17.1 离线评测集

按问题类型构建测试集:

  • • FAQ 型
  • • 错误码型
  • • API/字段型
  • • 运维排障型
  • • 版本差异型
  • • 多轮上下文型

每条样本至少包含:

  • • query
  • • 期望文档 ID
  • • 期望 chunk ID
  • • 问题类型标签

17.2 线上反馈闭环

可收集:

  • • 点击的引用文档
  • • 是否继续追问
  • • 是否人工转接
  • • 用户评分
  • • 人工修正答案

这能帮助你逐步做:

  • • 权重调优
  • • 热门 query 缓存优化
  • • 失败模式分析
  • • 特殊 query 路由

十八、演进路线:从 Demo 到平台化

阶段一:本地验证

适合:

  • • 小样本试点
  • • 验证语料质量
  • • 验证切块和 embedding 模型

技术特征:

  • • 单实例服务
  • • SQLite / 本地全文索引
  • • FAISS / 本地向量索引

阶段二:服务化拆分

适合:

  • • 团队开始承接真实业务
  • • 日请求量上升
  • • 文档更新频率提高

技术特征:

  • • 检索服务独立
  • • 引入 ES 与向量库
  • • Embedding 独立服务

阶段三:生产级混合检索

适合:

  • • 多租户
  • • 高并发
  • • 高可用要求
  • • 索引持续更新

技术特征:

  • • 双路召回
  • • 融合 + rerank
  • • MQ 异步建索引
  • • 配置中心
  • • 全链路可观测

阶段四:平台化与智能优化

适合:

  • • 多业务线共享能力
  • • 多知识域
  • • 多模型协同

技术特征:

  • • 自动路由检索策略
  • • 在线学习调权
  • • 索引质量巡检
  • • 自助化评测平台

十九、文章总结:生产级混合检索到底在解决什么

很多人以为混合检索只是“向量 + BM25”,但真正落地后会发现,它解决的是四个层面的问题:

1. 质量问题

让语义召回和精确召回互补,降低漏召回和错召回。

2. 时延问题

通过并行召回、预算控制、缓存和退化策略,把复杂链路稳定压在 SLA 内。

3. 一致性问题

通过异步入库、幂等事件、版本切换和补偿机制,让双索引系统可维护。

4. 平台化问题

通过无状态服务、配置中心、可观测性和多租户治理,把能力从 Demo 升级成基础设施。

如果只记住一句话,那就是:

生产级 RAG 混合检索 = 召回原理正确 + 工程治理到位 + 运行体系可控。

它不是某一个模型的胜利,而是检索工程、分布式系统和 AI 应用架构协同设计的结果。


二十、落地检查清单

最后给出一份可以直接用于项目评审的检查清单。

检索质量

  • • 是否同时支持 Dense 和 Sparse 召回
  • • 是否有融合策略与默认参数
  • • 是否有 rerank 或轻量排序兜底
  • • 是否有离线评测集

工程架构

  • • 检索服务是否无状态
  • • Embedding、Rerank、Index Worker 是否拆分
  • • 是否支持局部失败降级
  • • 是否有多级缓存

数据一致性

  • • 双索引写入是否幂等
  • • 是否支持增量更新
  • • 是否支持蓝绿索引切换
  • • 是否有补偿与巡检任务

安全与隔离

  • • 是否在检索前做租户和 ACL 过滤
  • • 是否有索引级或分区级隔离策略
  • • 是否防止越权内容进入 LLM

可观测性

  • • 是否有各阶段时延指标
  • • 是否记录召回来源和候选变化
  • • 是否有 trace 串联整条链路
  • • 是否监控降级比例与无结果率

运维治理

  • • 是否支持配置动态热更新
  • • 是否定义了退化等级
  • • 是否支持 HPA 和灰度发布
  • • 是否有容量评估与压测基线

如果以上大部分问题都还没有明确答案,那说明你的系统还处在“能跑 demo”阶段,而不是“可进生产”阶段。

学AI大模型的正确顺序,千万不要搞错了

🤔2026年AI风口已来!各行各业的AI渗透肉眼可见,超多公司要么转型做AI相关产品,要么高薪挖AI技术人才,机遇直接摆在眼前!

有往AI方向发展,或者本身有后端编程基础的朋友,直接冲AI大模型应用开发转岗超合适!

就算暂时不打算转岗,了解大模型、RAG、Prompt、Agent这些热门概念,能上手做简单项目,也绝对是求职加分王🔋

在这里插入图片描述

📝给大家整理了超全最新的AI大模型应用开发学习清单和资料,手把手帮你快速入门!👇👇

学习路线:

✅大模型基础认知—大模型核心原理、发展历程、主流模型(GPT、文心一言等)特点解析
✅核心技术模块—RAG检索增强生成、Prompt工程实战、Agent智能体开发逻辑
✅开发基础能力—Python进阶、API接口调用、大模型开发框架(LangChain等)实操
✅应用场景开发—智能问答系统、企业知识库、AIGC内容生成工具、行业定制化大模型应用
✅项目落地流程—需求拆解、技术选型、模型调优、测试上线、运维迭代
✅面试求职冲刺—岗位JD解析、简历AI项目包装、高频面试题汇总、模拟面经

以上6大模块,看似清晰好上手,实则每个部分都有扎实的核心内容需要吃透!

我把大模型的学习全流程已经整理📚好了!抓住AI时代风口,轻松解锁职业新可能,希望大家都能把握机遇,实现薪资/职业跃迁~

这份完整版的大模型 AI 学习资料已经上传优快云,朋友们如果需要可以微信扫描下方优快云官方认证二维码免费领取【保证100%免费】

在这里插入图片描述

RAG——RAG检索(混合检索) 本文探讨了RAG(检索增强生成)中的混合检索技术,结合向量检索和关键词检索的优势提升搜索效果。向量检索擅长语义匹配,但在精确匹配、短词搜索等场景表现欠佳;关键词检索则能有效处理产品编号、低频词等特定查询。混合检索通过多路召回策略(如BM25算法+向量检索)综合不同检索结果,并采用重排序技术(如RRF算法)优化结果排序。实验数据表明,混合检索结合重排序能显著提升召回率和准确性。文章还提供了Python实战代码,演示如何集成BM25和jieba分词实现中文混合检索。这种技术组合为RAG系统提供了更全面、精准的检 阅读详情

相关推荐

生产级RAG检索架构:混合搜索与业务规则驱动的精准召回

RAG(检索增强生成)的核心瓶颈往往不在大模型,而在检索层——传统向量搜索难以应对时效性、权限控制、结构化语义和查询意图漂移等真实业务挑战。Advanced Retrieval Techniques 本质是融合稀疏检索(BM25)、稠密检索(微调向量)、元数据路由与重排序的分层架构,其技术价值在于将模糊的‘相似匹配’转化为确定性的‘业务应召’。典型应用场景包括金融合规问答、医疗文档权限检索、制造业SOP精准定位等Production RAG Systems落地场景。本文聚焦可工程化部署的混合检索设计、参数调

weixin_33811539的博客 486

深入剖析 RAG 检索系统中的召回方式:BM25、向量召回、混合策略全解析

RAG(检索增强生成)系统通过结合信息检索与文本生成技术提升大模型回答的准确性。其中,召回作为第一步,直接影响系统性能。本文系统介绍了三种核心召回方式:基于关键词匹配的BM25稀疏召回、利用语义向量的BCE稠密召回,以及融合两者的混合召回。

weixin_48389642的博客 3968

混合检索系统实战指南:向量 × 关键词 × 多段召回协同提升 RAG 命中率

在构建国产大模型 RAG 系统的过程中,单纯依赖向量检索往往无法精准命中复杂用户查询,尤其在中文语义模糊、字段精确定位、上下文连续性等场景下效果不佳。本文系统拆解了“混合检索系统”的核心机制——通过向量召回 + 关键词召回 + 多段聚合的方式,大幅提升命中率与回答质量。实战落地采用 Qdrant × Elasticsearch 组合,支持 trace_id 追踪、GPT 自动评分、日志闭环分析与多模型调用拓展,适用于构建可解释、可优化、可复用的企业级 RAG 系统。适配国产模型(Qwen、DeepSeek、

努力分享一些人工智能、计算机视觉、影像等相关的知识干货! 1587

检索增强架构实践:召回率不是越高越好

RAG 架构实践中,召回率不是越高越好。混合召回、重排、引用、权限和失败样本评测一起做,才能让模型基于正确材料回答。

2401_87746054的博客 5637

【速通RAG实战:检索】7.RAG混合检索与重排序技术

在 RAG(检索增强生成)系统中,检索环节起着承上启下的关键作用,它需要精准地从知识库中找出与用户查询相关的信息,为后续的生成环节提供有力支撑。混合检索与重排序技术是提升检索效果的重要手段。

2025博客之星Top81。专注AI工程化与架构实战。从分布式思维到模型部署,用工程化视角为你厘清AI落地的真实路径。 1788

[Unity实战]热更新如何预防过度裁剪

假设你现在有一个游戏客户端,客户端只打包了入口场景,游戏场景都存放在了AB包。

u012587406的博客 1606

超越向量检索!混合检索 + 重排序改善 RAG 应用 | 新程序员

这样做的原因是大模型的输入窗口存在大小限制(一般为 4K、16K、32K、128K 的 Token 数量),我们需要根据选用的模型输入窗口的大小限制,选择合适的分段策略和 TopK 值。技术原理是通过将外部知识库的文档先拆分为语义完整的段落或句子,并将其转换(Embedding)为计算机能够理解的一串数字表达(多维向量),同时对用户问题进行同样的转换操作。要深刻理解用户的使用场景,将复杂的开放域问答问题概括为可收敛的一个个情景策略,只有在此基础之上,才能合理地选择索引、分段、检索、重排等一系列技术组合。

《程序员》官方BLOG 1万+

基于深度学习的时间序列预测

深度学习在时间序列数据中应用广泛,学术界已经有很多深度学习模型来适应不同领域的时间序列数据集的多样性。那么到底有哪些基于深度学习的时间序列预测模型?他们的优缺点是什么?让我们一起来看一下。

Sharon0408的博客 6582

大模型高级 RAG 检索策略之混合检索

混合检索也叫融合检索,也叫多路召回,是指在检索过程中,同时使用多种检索方式,然后将多种检索结果进行融合,得到最终的检索结果。混合检索的优势在于可以充分利用多种检索方式的优势,弥补各种检索方式的不足,从而提高检索的准确性和效率,下面是混合检索的流程图:首先是问题查询,这一过程的设计可以简单也可以复杂,简单的做法是直接将原始查询传递给检索器,而复杂一点的做法是通过 LLM(大语言模型)为原始查询生成子查询或相似查询,然后再将生成后的查询传递给检索器。

机器学习社区 8437

网络协议——Modbus-RTU

网络协议——Modbus-RTU,简介、消息格式、Modbus寄存器种类说明、功能码01H、功能码02H、功能码03H、功能码04H、功能码05H、功能码06H、功能码0FH、功能码10H。

计算机硕士的博客 9905

基于STM32 FOC下桥三电阻采样方式的电机相电流重构方法

如何提高三电阻采样的调制率

wanrenqi的博客 9200

【RAG检索】RAG技术揭秘:检索≠召回?

召回是RAG系统的核心环节,其本质是通过向量化、关键词匹配等技术,从海量知识库中筛选与用户问题相关的信息片段,为后续生成阶段提供精准上下文支持。与评估指标“召回率(Recall)”不同,Retrieval是动态的筛选过程,需平衡查全率与精确率。实现方法包括关键词匹配(快速但语义局限)和语义搜索(理解意图但需算力),优化策略建议采用混合搜索、动态分块及多模态处理。评估召回效果需关注命中率、排序质量及事实覆盖度,而实际应用面临长文本处理、实时更新、多跳推理等挑战。

Arbboter的专栏 4402

保姆级教程:用CameraX API快速搞定Android多摄像头切换与预览(附避坑指南)

本文提供了一份详细的CameraX API教程,帮助开发者快速实现Android多摄像头切换与预览功能。通过简化API设计和生命周期感知能力,CameraX大幅降低了开发复杂度,同时解决了多摄像头兼容性、预览优化等常见问题。文章包含完整代码示例和实战避坑指南,特别适合需要高效集成相机功能的Android开发者。

weixin_42699679的博客 167

混合检索 RAG:向量像雷达,关键词像门牌号

混合检索 RAG 把向量和关键词的优势结合起来。查询拆分、RRF 融合、专有名词保护、按查询类型评测,是落地关键。向量像雷达,关键词像门牌号。找资料时,两个都要带上。

2401_87746054的博客 5815

增量式PID的P和I怎么理解(一)

增量式PID的P、I理解之推翻片 据我所知的资料里关于PID三个参数的理解是这样的:(我这里只说P和I,先不说D) P的作用:比例P可以加快系统调节速度,P过小调节时间变长,响应性不够,P越大响应性越高超调也越严重,过大的P会使系统振荡。 I的作用:消除静差,提高控制精度,I越大越滞后,过大会使系统振荡。 ...

fangchenglia的博客 1万+

C#上位机实战:借助NetToPLCSim与西门子S7-1200仿真通信全攻略

本文详细介绍了如何使用C#开发上位机程序,通过NetToPLCSim与西门子S7-1200进行仿真通信的全过程。从环境准备、PLC仿真环境搭建、网络配置到C#代码实现,提供了完整的实战指南和常见问题解决方案,帮助开发者快速掌握工业自动化通信技术。

weixin_30596343的博客 442

检索增强从零落地:检索增强系统的索引、召回与评测

RAG 落地的关键是检索、引用和评测。向量库只是其中一环。文档切片要保留结构和元数据,召回要结合语义与关键词,答案要带引用,日志要记录索引版本。建议从小范围文档开始建设评测集。先让正确资料稳定进入 top-k,再优化生成效果。不要把所有问题都交给 Prompt。RAG 是检索系统和生成系统的组合,只有两端都可观测,答案才可控。

好代码自己会说话,烂代码才需要注释来圆谎 4983

Python Selenium全栈指南:从自动化入门到企业级实战

Selenium是一个用于自动化Web浏览器交互的框架,支持多种编程语言,包括Python。它提供了一组API,能够模拟用户在浏览器中的所有操作,如点击按钮、填写表单、获取页面内容等。Selenium通过WebDriver与不同的浏览器进行交互,使开发者能够模拟人工操作,从而进行自动化测试、数据抓取等任务。Selenium不仅仅是一个简单的自动化工具,它已经成为构建企业级应用的核心组件。通过Python Selenium的结合,开发者可以高效地完成自动化任务,从简单的网页抓取到复杂的企业级系统构建。

Sapphire521的博客 300

AI入门系列之RAG高效召回方法实践指南:从调参到部署的全流程实战手册

在大模型工程化落地中,RAG(检索增强生成)系统常因召回质量不佳而沦为“高级幻觉放大器”。许多开发者误以为只要接入向量数据库就能自动获得精准答案,却忽视了召回环节的精细化设计。本文面向一线程序员,提供一套可复现、可度量、可部署的RAG高效召回实践指南,涵盖数据预处理、多策略召回、重排序优化、异常降级四大核心模块,并附真实企业级配置参数与调试技巧,助你将召回准确率提升20%以上。

沛哥儿的专栏 2384

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

大模型高级 RAG 检索策略之混合检索_rag混合检索

混合检索也叫融合检索,也叫多路召回,是指在检索过程中,同时使用多种检索方式,然后将多种检索结果进行融合,得到最终的检索结果。混合检索的优势在于可以充分利用多种检索方式的优势,弥补各种检索方式的不足,从而提高检索的准确性和效率,下面是混合检索的流程图:首先是问题查询,这一过程的设计可以简单也可以复杂,简单的做法是直接将原始查询传递给检索器,而复杂一点的做法是通过 LLM(大语言模型)为原始查询生成子查询或相似查询,然后再将生成后的查询传递给检索器。

qingkahui24689的博客 3210

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

高性能RAG架构实战:全链路落地与工具选型指南

《高性能RAG架构实战:从召回率优化到企业级部署》摘要 本文系统介绍了高性能RAG(检索增强生成)系统的工程化实现方案。针对传统RAG系统召回率低(不足30%)、响应延迟高(超5秒)等问题,提出三层优化架构:1)数据预处理层采用智能切片技术提升语义连贯性;2)混合检索层融合向量检索与关键词检索(权重7:3),结合Cross-Encoder重排序使召回准确率提升至92%;3)推理加速层通过缓存机制和模型量化将延迟控制在800ms内。文章详细拆解了基于LangChain和Milvus的实现代码,包括文档智能分割

xiugou3365的博客 840

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

【收藏必备】RAG检索模块全解析:从向量检索到混合检索的实战指南

文章详解RAG系统中的检索模块,涵盖Query向量化、召回策略(向量、关键词、混合检索)、重排和结果过滤等关键步骤。强调检索优化需平衡召回率与精确率、降低延迟、处理专有词等挑战,提供实战案例和面试框架。核心观点是:检索优化是工程平衡的艺术,好的RAG系统依靠稳定的检索和准确的知识,而非玄学Prompt。

Android23333的博客 794

【2026必看】企业RAG技术全景图:从混合检索到Agentic RAG的实战指南

文章详解2024-2025年企业级RAG技术演进,混合检索已成生产标准,召回率提升5-10pp;GraphRAG通过知识图谱实现关系推理,LazyGraphRAG降低99.9%索引成本;Agentic RAG实现自主决策但90%项目生产失败,需谨慎应用。提供了框架选型指南和金融、法律、医疗等行业落地案例,强调企业应优先采用混合检索作为基础设施,根据场景决定技术引入,并建立评估体系贯穿始终。

2401_85325726的博客 1278

RAG检索系统优化实战:从向量检索到混合检索+重排序的进阶之路!

文章指出RAG应用中单一向量检索的局限性,包括专有名词匹配失败和语义漂移问题。解决方案是采用分层过滤机制:第一层通过混合检索(向量+BM25)利用RRF算法最大化召回率;第二层引入Cross-Encoder重排序模型对候选文档精准评分,提高精确度。这种架构特别适用于法律、医疗等术语密集领域,是构建高可用RAG系统的核心策略。

2401_85327249的博客 1199
上一篇: 万字图文,带你吃透Prompt工程 && Context工程 && Harness工程是如何演进的
下一篇: RAG 高级技术与调优实战手册
Python_金钱豹
博客等级 码龄5年 1万+粉丝 2841原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值