我的很多知识都记忆在 obsidian 上，长期积累下来后，文本变得越来越多，那天复习时，又得全部查看，比较不方便。我本意是利用类似 anki 的软件搭建一个知识回顾系统，但是存在两个问题：（1）制作卡片非常耗时；（2）知识和复习分别位于 obsidian 和 anki 两个软件，更新维护麻烦。所以想利用 ollama 调用大模型，帮自动生成卡片，解决问题 1，利用 obsidian 的间隔复习插件解决问题 2

认识 obsidian 的 2 个插件

这个系统主要是基于 obsidian 2 个插件的再开发，他们是 Quiz Generator 和 Spaced Repetition，第一个插件是基于文档生成 Q/A 问答的插件，第二个工具是 间隔复习插件

Quiz Generator

在 Quiz Generator 中，安装后，配置大模型路径，这里是个人电脑，所以选择 ollama 框架进行大模型推理，

然后选择需要生成问答的文档或者文件夹，即可生成以下效果的问答

这个工具还可以生成不同类型的问答，包括：单选、多选、填空、问答题等，其中填空和问答等类似的答案不唯一的问题，支持使用大模型评估问答效果

这个插件还有一个功能是保存生成的问题，包括 callout 和 Spaced Repetition 两种方式，这里选择第二种方式，配合下面插件 Spaced Repetition 去复习之前生成过的插件

Spaced Repetition

插件 Quiz Generator 已经生成可以被 Spaced Repetition 解析的卡片文件，直接打开 Spaced Repetition 会看到以下界面

修改 Quiz Generator

以上 2 个插件已经具备这个复习系统的功能，但是在实际使用中，发现 Quiz Generator 存在以下问题：

1. 显示答案时，没有显示是基于那些资料产生的提问，导致使用者无法确定自己的选择是否正确（有时候大模型给的答案也不准确）
2. 生成卡片过程，没有任何提示，不知道生成进度，只能一直等

针对以上两个问题，基于 Quiz Generator ，做以下修改：

1. 该插件无法给出问题的引用源，是因为基于整篇文章生成提问，所以改进是：获取文档后，先对文档进行分片，对每个分片生成提问，在两个插件复习时，显示答案的同时显示引用源
2. 根据文档分片数量，实时输出生成提问的进度，使用更加友好

修改源码时，我们以标题进行分片，也就是针对一个标题内容生成提问，比如下图是文档内容及生成的提问

通过修改源码，让在 Quiz Generator 和 Spaced Repetition 两个插件显示问题引用源，效果类似以下：

安装方式

本系统主要是在插件 Quiz Generator 的基础上修改得到，并没有直接上传到 obsidian 插件平台，所以需要下载源码安装，步骤为：

1. 在 GitHub - WuShaogui/obsidian-quiz-generator: 针对自己文档特点进行优化下载源码
2. 在 Obsidian 安装插件 Quiz Generator
3. 在源码位置，找到以下 4 个文件，拷贝到 obsidian 文件的 .obsidian\plugins\quiz-generator 路径下
4. 重新打开 obsidian

四个文件分别是：main.js、data.json、styles.css、manifest.json

如何再次基础上进行开发，请先在目录执行 npm install 安装依赖，然后使用 npm run dev 调试代码，使用 npm run build 编译代码

总结：

1. 通过修改 Quiz Generator 实现按标题内容生成问答对，生成的提问更准确
2. 通过引入源，解决复习时需要翻找资料的问题
3. 实时打印大模型生成问答对进度，更友好

环境设置

设置推理模型及 embedding 模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

from llama_index.core import Settings
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding
base_url='http://192.168.3.165:11434'
Settings.llm = Ollama(model="qwen2.5:latest", request_timeout=360.0,base_url=base_url)
Settings.embed_model = OllamaEmbedding(model_name="quentinz/bge-large-zh-v1.5:latest",base_url=base_url)
Settings.chunk_size = 512

# 可视化知识库函数
def show_knowledge_graph(index,name='example.html'):
    from pyvis.network import Network

    g = index.get_networkx_graph()
    net = Network(notebook=True, cdn_resources="in_line", directed=True)
    net.from_nx(g)
    net.show(name)

构建知识图谱

首先，使用 SimpleDirectoryReaderd 读取非结构化文档

1
2
3
4
5
6
7

# 1.自定义documents
from llama_index.core.schema import TextNode,Document
documents=[
    Document(id='123',text='阴雨绵绵的清晨，李华见徐天行老师在校门口焦急张望，立刻推出自己的新自行车：“老师，我送您去教室！”放学后，伍娟摸着儿子湿透的校服眼眶发红，李山拍拍儿子肩膀：“懂得承担责任，是男子汉了。'),
    Document(id='456',text='徐天行举着李华的作业本：“横平竖直，一夜进步神速！”原来李华熬夜练习书法，只因徐老师曾说“字如心正”。'),
    Document(id='789',tex='张志抱着一摞昆虫图鉴冲进教室：“生物课展示靠你了！”李华苦笑——他最怕甲虫，但想起徐老师“直面恐惧”的鼓励，咬牙点头。两人熬夜制作模型，李山帮忙3D打印鞘翅，伍娟端来牛奶。次日展示时，徐老师按下录音键：“这份协作，值得全班倾听。” 。')
]

其次利用 KnowledgeGraphIndex 在全局知识层面构建知识图谱 (也就是索引)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

from llama_index.core import SimpleDirectoryReader,StorageContext, KnowledgeGraphIndex
from llama_index.core.graph_stores import SimpleGraphStore

import os
save_kg_path=r'db\example\graph.db'
if os.path.exists(save_kg_path):
    graph_store = SimpleGraphStore().from_persist_dir(save_kg_path)

    index = KnowledgeGraphIndex.from_documents(
        documents,
        max_triplets_per_chunk=50,
        graph_store=graph_store,
        show_progress=True
    )
else:
    graph_store = SimpleGraphStore()
    storage_context = StorageContext.from_defaults(graph_store=graph_store)
    
    index = KnowledgeGraphIndex.from_documents(
        documents,
        max_triplets_per_chunk=50,
        storage_context=storage_context,
        show_progress=True
    )
    index.storage_context.persist(persist_dir=r'db\example',graph_store_fname='graph.db')

Parsing nodes:   0%|          | 0/3 [00:00<?, ?it/s]Processing nodes:   0%|          | 0/3 [00:00<?, ?it/s]

最后，使用 pyvis 工具查看知识图谱的内容

1

show_knowledge_graph(index,name='example.html')

由可视化结果看出，使用 llm 构建的知识图谱，将中文名改为了英文，而且感觉图谱质量不高。

实际上，知识图谱的构建本质是 N 个三元组 (实体 1，实体 2，关系) 组成，所以也可以直接向索引对象添加三元组，实现 “手动” 知识图谱的构建

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 2.文档chunk化
from llama_index.core.node_parser import SentenceSplitter
node_parser=SentenceSplitter(chunk_size=512,chunk_overlap=32)
nodes=node_parser.get_nodes_from_documents(documents)

# 3.构建索引
from llama_index.core import KnowledgeGraphIndex
index = KnowledgeGraphIndex(
    [],
)

# 针对第1个文档的关系
node_tups=[('李华','母亲是','伍娟'),('李华','父亲是','李山')]
for node_tup in node_tups:
    index.upsert_triplet_and_node(node_tup,nodes[0],include_embeddings=False)

# 针对第1个文档的关系
node_tups=[('李华','同学是','张志')]
for node_tup in node_tups:
    index.upsert_triplet_and_node(node_tup,nodes[1],include_embeddings=False)

# 针对第3个文档的关系
node_tups=[('张志','老师是','徐天行')]
for node_tup in node_tups:
    index.upsert_triplet_and_node(node_tup,nodes[2],include_embeddings=False)
    
show_knowledge_graph(index,name='custom_example.html')

使用知识图谱

1
2

# 直接使用索引，分析文本中的三元组
index._extract_triplets("李华和王五去徐天行老师家补课")

[('李华', '去', '徐天行老师家'), ('王五', '去', '徐天行老师家'), ('补课', '发生在', '徐天行老师家')]

1
2
3
4
5
6
7

# 索引->检索器
from llama_index.core.indices.knowledge_graph.retrievers import KGRetrieverMode
retriever=index.as_retriever(retriever_mode=KGRetrieverMode.KEYWORD)

from llama_index.core.schema import QueryBundle
query=QueryBundle(query_str="李华和同学张志一起完成了什么任务？")
retriever._retrieve(query)

1
2
3
4

[NodeWithScore(node=TextNode(id_='d38689d8-a7c2-41f8-a8de-d79c84bc4034', embedding=None, metadata={}, excluded_embed_metadata_keys=[], excluded_llm_metadata_keys=[], relationships={<NodeRelationship.SOURCE: '1'>: RelatedNodeInfo(node_id='97ee7e69-7ebf-4343-a587-8ee10e281cae', node_type='4', metadata={}, hash='96f4e9c8f81325976a25213572d9255024347d55bce55e980bc6d1ec03bd33f7')}, metadata_template='{key}: {value}', metadata_separator='\n', text='徐天行举着李华的作业本：“横平竖直，一夜进步神速！”原来李华熬夜练习书法，只因徐老师曾说“字如心正”。', mimetype='text/plain', start_char_idx=0, end_char_idx=51, metadata_seperator='\n', text_template='{metadata_str}\n\n{content}'), score=1000.0),
 NodeWithScore(node=TextNode(id_='3a354c0b-3051-41ae-80f0-089627928e8c', embedding=None, metadata={}, excluded_embed_metadata_keys=[], excluded_llm_metadata_keys=[], relationships={<NodeRelationship.SOURCE: '1'>: RelatedNodeInfo(node_id='a3aa4ae9-40e0-4303-b800-4a88d4f90b54', node_type='4', metadata={}, hash='44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a')}, metadata_template='{key}: {value}', metadata_separator='\n', text='', mimetype='text/plain', start_char_idx=0, end_char_idx=0, metadata_seperator='\n', text_template='{metadata_str}\n\n{content}'), score=1000.0),
 NodeWithScore(node=TextNode(id_='132f96dc-4d68-4313-ad64-d3a19f33581b', embedding=None, metadata={}, excluded_embed_metadata_keys=[], excluded_llm_metadata_keys=[], relationships={<NodeRelationship.SOURCE: '1'>: RelatedNodeInfo(node_id='822127f3-1511-4a31-921b-c527fd0f3a15', node_type='4', metadata={}, hash='904fbb3a3e01cf71a67cd33a5dafe1966fade6f3c538516a59823b2e78041b62')}, metadata_template='{key}: {value}', metadata_separator='\n', text='阴雨绵绵的清晨，李华见徐天行老师在校门口焦急张望，立刻推出自己的新自行车：“老师，我送您去教室！”放学后，伍娟摸着儿子湿透的校服眼眶发红，李山拍拍儿子肩膀：“懂得承担责任，是男子汉了。', mimetype='text/plain', start_char_idx=0, end_char_idx=92, metadata_seperator='\n', text_template='{metadata_str}\n\n{content}'), score=1000.0),
 NodeWithScore(node=TextNode(id_='64566ef0-e951-4512-86d3-b3c5dcf17f8a', embedding=None, metadata={'kg_rel_texts': ["['张志', '老师是', '徐天行']", "['李华', '母亲是', '伍娟']", "['李华', '父亲是', '李山']", "['李华', '同学是', '张志']", "['张志', '老师是', '徐天行']"], 'kg_rel_map': {'任务': [], '完成': [], '同学': [], '张志': [['张志', '老师是', '徐天行']], '李华': [['李华', '母亲是', '伍娟'], ['李华', '父亲是', '李山'], ['李华', '同学是', '张志'], ['张志', '老师是', '徐天行']]}}, excluded_embed_metadata_keys=['kg_rel_map', 'kg_rel_texts'], excluded_llm_metadata_keys=['kg_rel_map', 'kg_rel_texts'], relationships={}, metadata_template='{key}: {value}', metadata_separator='\n', text="The following are knowledge sequence in max depth 2 in the form of directed graph like:\n`subject -[predicate]->, object, <-[predicate_next_hop]-, object_next_hop ...`\n['张志', '老师是', '徐天行']\n['李华', '母亲是', '伍娟']\n['李华', '父亲是', '李山']\n['李华', '同学是', '张志']\n['张志', '老师是', '徐天行']", mimetype='text/plain', start_char_idx=None, end_char_idx=None, metadata_seperator='\n', text_template='{metadata_str}\n\n{content}'), score=1000.0)]

1
2
3
4
5
6
7
8
9
10

# 索引->RAG引擎
query_engine = index.as_query_engine(
    include_text=True, response_mode="tree_summarize",similarity_top_k=3
)
response = query_engine.query(
    "老师如何评价李华和张志的课程作业",
)

from IPython.display import Markdown
display(Markdown(f"<b>{response}</b>"))

徐天行对李华的书法进步给予了积极评价，说他的字 “横平竖直，一夜进步神速”。至于张志的情况，文中并未提及具体课程作业的评价信息。

后面两个应用中，可以发现知识图谱并没有准确检索到文档，或者准确回答问题，这是因为只使用了 “实体（关键字）” 去知识图谱检索文档，下面我们在知识图谱的基础上添加文档的整体语义信息，检索时，同时考虑实体及语义，看看其检索与回答效果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

index = KnowledgeGraphIndex(
    [],
)

# 针对第1个文档的关系
node_tups=[('李华','母亲是','伍娟'),('李华','父亲是','李山')]
for node_tup in node_tups:
    index.upsert_triplet_and_node(node_tup,nodes[0],include_embeddings=True)

# 针对第1个文档的关系
node_tups=[('李华','同学是','张志')]
for node_tup in node_tups:
    index.upsert_triplet_and_node(node_tup,nodes[1],include_embeddings=True)

# 针对第3个文档的关系
node_tups=[('张志','老师是','徐天行')]
for node_tup in node_tups:
    index.upsert_triplet_and_node(node_tup,nodes[2],include_embeddings=True)

# 索引->检索器
from llama_index.core.indices.knowledge_graph.retrievers import KGRetrieverMode

retriever=index.as_retriever(retriever_mode=KGRetrieverMode.HYBRID)

from llama_index.core.schema import QueryBundle
query=QueryBundle(query_str="老师如何评价李华和张志的课程作业")
retriever._retrieve(query)

1
2
3
4

[NodeWithScore(node=TextNode(id_='d38689d8-a7c2-41f8-a8de-d79c84bc4034', embedding=None, metadata={}, excluded_embed_metadata_keys=[], excluded_llm_metadata_keys=[], relationships={<NodeRelationship.SOURCE: '1'>: RelatedNodeInfo(node_id='97ee7e69-7ebf-4343-a587-8ee10e281cae', node_type='4', metadata={}, hash='96f4e9c8f81325976a25213572d9255024347d55bce55e980bc6d1ec03bd33f7')}, metadata_template='{key}: {value}', metadata_separator='\n', text='徐天行举着李华的作业本：“横平竖直，一夜进步神速！”原来李华熬夜练习书法，只因徐老师曾说“字如心正”。', mimetype='text/plain', start_char_idx=0, end_char_idx=51, metadata_seperator='\n', text_template='{metadata_str}\n\n{content}'), score=1000.0),
 NodeWithScore(node=TextNode(id_='3a354c0b-3051-41ae-80f0-089627928e8c', embedding=None, metadata={}, excluded_embed_metadata_keys=[], excluded_llm_metadata_keys=[], relationships={<NodeRelationship.SOURCE: '1'>: RelatedNodeInfo(node_id='a3aa4ae9-40e0-4303-b800-4a88d4f90b54', node_type='4', metadata={}, hash='44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a')}, metadata_template='{key}: {value}', metadata_separator='\n', text='', mimetype='text/plain', start_char_idx=0, end_char_idx=0, metadata_seperator='\n', text_template='{metadata_str}\n\n{content}'), score=1000.0),
 NodeWithScore(node=TextNode(id_='132f96dc-4d68-4313-ad64-d3a19f33581b', embedding=None, metadata={}, excluded_embed_metadata_keys=[], excluded_llm_metadata_keys=[], relationships={<NodeRelationship.SOURCE: '1'>: RelatedNodeInfo(node_id='822127f3-1511-4a31-921b-c527fd0f3a15', node_type='4', metadata={}, hash='904fbb3a3e01cf71a67cd33a5dafe1966fade6f3c538516a59823b2e78041b62')}, metadata_template='{key}: {value}', metadata_separator='\n', text='阴雨绵绵的清晨，李华见徐天行老师在校门口焦急张望，立刻推出自己的新自行车：“老师，我送您去教室！”放学后，伍娟摸着儿子湿透的校服眼眶发红，李山拍拍儿子肩膀：“懂得承担责任，是男子汉了。', mimetype='text/plain', start_char_idx=0, end_char_idx=92, metadata_seperator='\n', text_template='{metadata_str}\n\n{content}'), score=1000.0),
 NodeWithScore(node=TextNode(id_='f730db7b-3fe4-4133-b749-2872dee27412', embedding=None, metadata={'kg_rel_texts': ["('张志', '老师是', '徐天行')", "['张志', '老师是', '徐天行']", "('李华', '同学是', '张志')", "['李华', '母亲是', '伍娟']", "['李华', '同学是', '张志']", "['李华', '父亲是', '李山']"], 'kg_rel_map': {'课程作业': [], '老师': [], '李华': [['李华', '母亲是', '伍娟'], ['李华', '父亲是', '李山'], ['李华', '同学是', '张志'], ['张志', '老师是', '徐天行']], '张志': [['张志', '老师是', '徐天行']], '评价': []}}, excluded_embed_metadata_keys=['kg_rel_map', 'kg_rel_texts'], excluded_llm_metadata_keys=['kg_rel_map', 'kg_rel_texts'], relationships={}, metadata_template='{key}: {value}', metadata_separator='\n', text="The following are knowledge sequence in max depth 2 in the form of directed graph like:\n`subject -[predicate]->, object, <-[predicate_next_hop]-, object_next_hop ...`\n('张志', '老师是', '徐天行')\n['张志', '老师是', '徐天行']\n('李华', '同学是', '张志')\n['李华', '母亲是', '伍娟']\n['李华', '同学是', '张志']\n['李华', '父亲是', '李山']", mimetype='text/plain', start_char_idx=None, end_char_idx=None, metadata_seperator='\n', text_template='{metadata_str}\n\n{content}'), score=1000.0)]

1
2
3
4
5
6
7
8
9
10

# 索引->RAG引擎
query_engine = index.as_query_engine(
    include_text=True, response_mode="refine"
)
response = query_engine.query(
    "老师如何评价李华和张志的生物课程作业",
)

from IPython.display import Markdown
display(Markdown(f"<b>{response}</b>"))

根据新提供的信息，我们仍然没有关于老师对李华和张志生物课程作业的具体评价。文中仅描述了徐天行是张志的老师以及与李华相关的一些家庭成员关系，并未提及任何有关生物课程作业的内容。因此，无法回答关于他们的生物课程作业情况。

可以发现，检测、回答效果并没有改善，看来 GraphRAG 并不是在所有场景有效，或者是其效果依赖于知识图谱的质量，在本脚本中，知识图谱太小，使用受限

构建知识图谱的原理

知识图谱的目的是使用 llm 提取文本的三元组，我们首先来看看 llm 的相关 prompt

1
2
3
4
5

from llama_index.core import KnowledgeGraphIndex

index=KnowledgeGraphIndex([])
index.kg_triplet_extract_template

PromptTemplate(metadata={‘prompt_type’: <PromptType.KNOWLEDGE_TRIPLET_EXTRACT: ‘knowledge_triplet_extract’>}, template_vars=[‘max_knowledge_triplets’, ‘text’], kwargs={‘max_knowledge_triplets’: 10}, output_parser=None, template_var_mappings=None, function_mappings=None, template=“Some text is provided below. Given the text, extract up to {max_knowledge_triplets} knowledge triplets in the form of (subject, predicate, object). Avoid stopwords.\n---------------------\nExample:Text: Alice is Bob’s mother.Triplets:\n(Alice, is mother of, Bob)\nText: Philz is a coffee shop founded in Berkeley in 1982.\nTriplets:\n(Philz, is, coffee shop)\n(Philz, founded in, Berkeley)\n(Philz, founded in, 1982)\n---------------------\nText: {text}\nTriplets:\n”)

其中 prompt 内容如下:

1
2
3
4
5
6
7
8
9
10

Some text is provided below. Given the text, extract up to {max_knowledge_triplets} knowledge triplets in the form of (subject, predicate, object). Avoid stopwords.\n
---------------------\n
Example:Text: Alice is Bob's mother.Triplets:\n(Alice, is mother of, Bob)\n
Text: Philz is a coffee shop founded in Berkeley in 1982.\n
Triplets:\n(Philz, is, coffee shop)\n
(Philz, founded in, Berkeley)\n
(Philz, founded in, 1982)\n
---------------------\n
Text: {text}\n
Triplets:\n

内容显示，要求 llm 提供数量为 max_knowledge_triplets 个的 (subject, predicate, object) s 三元组，并且给出提示例子

应用小例子

1
2

from llama_index.core import SimpleDirectoryReader
documents = SimpleDirectoryReader("./三国演义白话文/",recursive=True).load_data(show_progress=True)

Loading files: 100%|██████████| 8/8 [00:00<00:00, 74.28file/s]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

from llama_index.core import StorageContext, KnowledgeGraphIndex
from llama_index.core.graph_stores import SimpleGraphStore

import os
save_kg_path=r'db\sanguo\graph.db'
if os.path.exists(save_kg_path):
    graph_store = SimpleGraphStore().from_persist_dir(save_kg_path)

    index = KnowledgeGraphIndex.from_documents(
        documents,
        max_triplets_per_chunk=50,
        graph_store=graph_store,
        show_progress=True
    )
else:
    graph_store = SimpleGraphStore()
    storage_context = StorageContext.from_defaults(graph_store=graph_store)
    
    index = KnowledgeGraphIndex.from_documents(
        documents,
        max_triplets_per_chunk=50,
        storage_context=storage_context,
        show_progress=True
    )
    index.storage_context.persist(persist_dir=r'db\sanguo',graph_store_fname='graph.db')

Parsing nodes:   0%|          | 0/8 [00:00<?, ?it/s]Processing nodes:   0%|          | 0/80 [00:00<?, ?it/s]

1
2
3
4
5
6
7
8
9

query_engine = index.as_query_engine(
    include_text=False, response_mode="tree_summarize"
)
response = query_engine.query(
    "董卓如何将吕布收为义子的？",
)

from IPython.display import Markdown
display(Markdown(f"<b>{response}</b>"))

董卓通过给予礼物的方式收买了吕布，将他收为了义子。根据信息，董卓用一匹名为 “赤兔马” 的千里马和数不尽的黄金珠宝作为礼物送给了吕布，成功地让他拜自己为义父。

1
2
3
4
5
6
7
8

query_engine = index.as_query_engine(
    include_text=True, response_mode="tree_summarize"
)
response = query_engine.query(
    "刘备如何为朝廷效力？",
)

display(Markdown(f"<b>{response}</b>"))

根据提供的信息，刘备最初是通过军事才能为朝廷效力的。在故事中提到，关羽和张飞在战场上英勇无敌，而刘备则既有勇又有谋，三人接连取胜，战功赫赫。但是，随着时间推移，朝廷变得更加腐败，实行卖官鬻爵的行为。尽管如此，刘备并未放弃为国家贡献力量的机会，在担任安喜县县尉期间，他与百姓秋毫无犯，深得民心，展现了其忠于职守的一面。

总结：本文使用 llamaindex 学习了知识图谱的构建，并基于知识图谱创建 RAG 应用，发现 GraphRAG 的回答质量不是在所有场景适用，而是依赖于高质量的知识图谱

RAG 的标准过程是 “索引 - 检索 - 生成”，他们的影响关系如下：

• 索引的目的是为了更好的检索
• 检索的目的是为了提供更好的上下文
• 基于更好的上下文，产生更高质量的回答

在 RAG 发展的不同阶段，对以上 3 个过程进行改进或扩展，到 Agentic RAG 为止，其技术演进思路如下：

RAG 演进历史

Naive RAG

Naive RAG 是 RAG 的基础实现，侧重于关键词检索技术，如 TFIDF,BM25 等传统检索技术，从静态数据集中获取上下文，然后生成输出

缺点

• 缺乏上下文感知 ：由于依赖关键词匹配，导致无法捕捉查询的语义细微差别
• 输出碎片化 ：缺乏高级预处理或上下文集成，导致生成的响应可能不连贯或过于通用。
• 可扩展性问题 ：基于关键词的检索技术，无法处理大规模数据集

Advanced RAG

针对 Naive RAG 的缺点，Advanced RAG 着重提升检索阶段的质量，包括以下改进：

• 密集向量搜索：查询和文档在高维空间表示，实现了用户查询和检索文档之间的更好 语义对齐
• 上下文重排：神经模型重新排序检索到的文档，优先考虑最上下文相关的信
• 迭代检索：Advanced RAG 引入了多跳检索机制，能够对复杂查询进行跨多个文档的推理

Modular RAG

Modular RAG 在灵活性和定制化方向，扩展 RAG 的应用，将 RAG 的关键过程（如：检索、生成、路由) 整合成独立的组件，方便复用，它有以下优势：

• 混合检索策略 ：结合稀疏和密集检索方法，以最大化不同查询类型的准确性。
• 工具集成 ：整合外部 API、数据库或计算工具来处理专业任务，例如实时数据分析或特定领域的计算。
• 可组合管道 ：允许独立替换、增强或重新配置检索器、生成器和其他组件。

Graph RAG

通过对 “全局文档” 构建知识图谱，实现对多跳、复杂推理的进一步提升，本质上是重构数据的索引方式，有原来片段式的索引，变为全局实体及关系的索引

GraphRAG 的特点：

• 节点连接：捕获和响应不同推理实体之间的关系
• 分层知识管理：通过图形化的结构处理结构化和非结构化数据
• 上下文扩充：基于图形化的路径增加关系的理解

GraphRAG 存在以下局限性：

• 扩展限制：图结构化数据限制其扩展性，尤其是使用大量数据源的情况下，知识图谱更新将变得困难
• 数据依赖：需要构建高质量的知识图谱，在非结构化数据或者缺少注释的数据上难以做到
• 集成的复杂性：检索图形化数据、非结构化数据，其集成将使得系统变得复杂

Agentic RAG

Agentic RAG 通过引入动态决策和流程化的自主代理，实现 “静态系统” 到 “动态系统” 的转换，可以进行迭代优化和自适应检索策略处理复杂问题

Agentic RAG 的主要特征包括：

• 自主决策：根据查询的复杂性，自主评估和管理检索策略
• 迭代优化：整合反馈循环，提高检索的准确性和响应相关性
• 工作流优化：动态编排任务，提高实时应用程序的效率

Agentic RAG 存在以下调挑战：

• 协调复杂性：管理代理之间的交互需要复杂的编排机制
• 计算开销：使用多个代理会增加复杂工作所需的资源
• 可扩展性限制：虽然可扩展，但系统的动态特性可能会使高查询量的计算资源紧张

Agentic RAG 详解

Agent 的组成及能力

Agent 的组成

• LLM (定义角色和任务)：作为 Agent 的主要推理引擎，它解释用户查询、生成响应
• Memory (短期和长期)：捕获上下文相关的数据，短期记忆追踪对话状态，长期记忆积累知识和代理体验
• Planning (反思和自我批评)：通过反思和自我评判，指导代理迭代过程，确保复杂任务被分解
• Tool (工具)：将代理功能扩展到文本生成之外，支持访问外部资源，使用外部工具

支撑 Agent 动态地构建工作流的模式有四种：

1. 反思 (Reflection)

代理工作流中的基本模式，通过评估去迭代优化输出，评估指标包括输出的正确性、风格等

在多智能体系统中，反射可能涉及不同的角色，例如一个智能体生成输出，而另一个智能体批评输出，从而促进协作改进。

2. 规划 (Planning)

规划是另一种代理设计模式，它使代理能够自主将复杂任务分解为更小、可管理的子任务，但是与 Reflection 相比， Planning 产生的结果更难预测，因为子任务相互依赖，后续子任务的质量依赖前序子任务的完成质量

3. 工具使用 (Tool use)

工具使用是代理的另一种工作流，它允许代理调用外部工具、API，提供更准确的上下文

4. 多代理 (Multi-Agent)

多代理是代理工作流的一种关键模式，它支持任务专业化和并行处理。代理之间可以共享数据、相互指派任务，每个代理内部有自己的记忆、工具、反思和规划，从而实现动态和协作地解决问题

Agentic RAG 分类

Single-Agent Agentic RAG: Router

有单一的 Agent 管理检索、路由和整合的过程，简化了系统设计，但是工具或者数据源的数量有限，因为单一的 Agent 无法使用大量的工具

工作流程：

1. 查询提交与评估：代理分析查询，分析确定合适的数据源
2. 数据源选择：
   1. 结构化数据：对于需要表格访问的查询，需要将查询转为 SQL 处理
   2. 语义搜索：处理非结构化数据时，基于向量检索即可
   3. 网络搜索：对于实时或者广泛上下文，系统利用互联网工具访问最新在线数据
   4. 推荐系统：对于个性化或上下文查询，利用推荐引擎提供定制化建议
3. 数据集成及生成：将检索到的数据集成到 prompt 中，然后交给 llm 生成

Multi-Agent Agentic RAG Systems

由于一个代理绑定的工具有限，那么在 Single-Agent Agentic RAG 的基础上增加多个代理，用于负责不同工具的调用，降低每个 agent 的 prompt 复杂程度

工作流程：

1. 查询提交与评估：代理分析查询，分析确定合适的代理
2. 代理源：
   1. 代理 X：负责向量化检索
   2. 代理 Y：负责网络搜索
   3. 代理 Z：负责检索邮件或者聊天
3. 将检测的数据整合进 prompt，

Hierarchical Agentic RAG Systems

相比较 Multi-Agent Agentic RAG，Hierarchical Agentic RAG 采取多层次的方法构建 Agent，高级代理监督指导低级代理

工作流程：

1. 接受查询，委派代理：用户输入查询，通过主代理分析，并将任务委派到子代理，可以委派多个代理
2. 子代理执行：子代理执行，并将结果返回给主代理，可以有多个子代理同时执行
3. 生成：主代理接收汇总所有子代理的结果，然后生成回答

Agentic Corrective RAG

通过引入自我纠正机制，迭代细化上下文文档和回答，最小化错误并最大化相关性。这个方法是通过以下 3 个代理完成：

1. 上下文检索代理：负责从向量库中检索上下文
2. 相关性评估代理：评估检索到文档的相关性，过滤或纠正对于标记不相关的文档
3. 查询细化代理：利用语义理解来优化检索，以获得更好上下文
4. 外部知识代理：当上下文不足时，通过网络搜索补充知识
5. 回答合成代理：将经过验证的代理整合生成连贯且准确的回答

Adaptive Agentic RAG

根据查询的复杂性调整处理策略，然后选择合适的方法回答问题，范围从单步推理到多步推理，甚至对于简单回答直接回答，而不需检索

Adaptive Agentic RAG 的核心在于根据查询复杂性动态调整检索策略，比如以下检索：

• 直接查询：对于不需要额外检索的基于事实的问题（例如，“水的沸点是多少？”），系统使用预先存在的知识直接生成答案。
• 简单查询：对于需要最少上下文的中等复杂任务（例如，“我的最新电费单的状态如何？”），系统会执行单步检索以获取相关详细信息。
• 复杂查询：对于需要迭代推理的多层查询（例如，“过去十年 X 市的人口变化如何，影响因素是什么？”），系统采用多步骤检索，逐步提炼中间结果以提供全面的答案

Adaptive Agentic RAG 有以下 3 个核心组件组成

1. 分类角色：一个小的 llm 模型，用于分析用户输入复杂性，分类器使用从过去模型结果和查询模式派生的自动标注数据训练
2. 动态策略选择：直接查询，使用 llm 回答即可；简单查询，单步检索即可；复杂查询，使用多步检索，迭代细化结果
3. LLM 整合：整合检索到的信息，生成回答

Graph-Based Agentic RAG

Agent-G: Agentic Framework for Graph RAG

![[Pasted image 20250214135237.png]]

Agent-G 将图知识库和非结构化的检索相结合，通过结构化的知识图谱和非结构化化数据增强 RAG 的上下文能力，在设计上还使用评估模块，确保可以不断迭代细化，产生高质量输出

工作流程：

1. 知识图谱：使用结构化的数据在全文层次提取实体、关系
2. 非结构化数据：使用向量检索检索相关文档
3. 评估模块：评估检索到信息的相关性和质量，确保与查询一致
4. 反馈循环：通过迭代验证和重新查询细化检索和合成

GeAR:Graph-EnhancedAgentforRetrieval-AugmentedGeneration

通过整合基于图的检索机制来增强传统的 RAG 系统。通过利用图扩展技术和基于代理的架构，GeAR 解决了多跳检索场景中的挑战，提高了系统处理复杂查询的能力

• 增强的多跳检索：GeAR 的图形扩展允许系统处理需要对多个互连信息进行推理的复杂查询。
• 代理决策：代理框架支持动态和自主选择检索策略，从而提高效率和相关性。
• 提高准确性：通过整合结构化图形数据，GeAR 提高了检索信息的精度，从而产生更准确和上下文合适的响应。
• 可扩展性：代理框架的模块化特性允许根据需要集成其他检索策略和数据源。

Agentic Document Workflows in Agentic RAG

智能体文档工作流（Agentic Document Workflows, ADW）整合文档解析、检索、推理和结构化输出与智能代理。通过维护状态、协调多步工作流，并将领域特定逻辑应用于文档，解决了智能文档处理（IDP）和 RAG 的限制

工作流程：

1. 文档解析和信息结构化：使用企业级工具（例如 LlamaParse）解析文档，提取相关数据字段，如发票号码、日期、供应商信息、明细项和付款条款
2. 跨流程的状态维护： 系统维护文档上下文的状态，确保多步工作流之间的一致性和相关性
3. 知识检索：从外部知识库或向量索引中检索相关参考文献
4. 代理协调：智能代理应用业务规则，执行多跳推理，并生成可操作的建议
5. 可操作输出生成：以结构化格式呈现输出，针对特定用例进行定制

Agentic RAG 框架比较

Agentic RAG 的出现，意味着 RAG 和 Agent 结合迈向下一步，扩展了 RAG 解决复杂查询的能力，如果 llm 没有进一步发展，可以试想这个架构将统治 RAG 很长一段时间。

什么是 GraphRAG？

GraphRAG（Graph-based Retrieval-Augmented Generation）是微软提出的一种结合知识图谱的增强检索生成框架，旨在改进传统 RAG 的局限性。其核心思想是通过构建结构化知识图谱，对文档内容进行全局语义建模，从而提升大语言模型（LLM）在复杂问题中的推理能力和回答准确性。

与传统 RAG 依赖非结构化文本的向量检索不同，GraphRAG 通过图谱的拓扑结构（如节点、边、子图）挖掘深层语义关联，解决传统 RAG 在长尾问题、多跳推理和全局一致性上的不足，总的来说，他们之间有以下区别：

RAG 每次检索出的 chunk，只是某个文档的内容，而通过知识图谱，GraphRAG 在全局预料层面检索知识，弥补了传统 RAG 在复杂关联推理中的不足，同时提升了回答的可解释性。

GraphRAG 的实现过程

flowchart LRA[文档]B[实体/关系抽取]C[构建知识图谱]D[社区划分]E[检索子图]F[llm生成答案]A-->B-->C-->D-->E-->F

GraphRAG 的实现分为以下关键步骤：

1. 索引（数据预处理与知识图谱构建）

   • 实体与关系抽取：使用 LLM 解析文档，提取实体（如人物、地点、事件）及其关系（如 “属于”“导致”）。
   • 图谱生成：将实体和关系存储为图结构（节点 = 实体，边 = 关系），支持属性扩展（如时间、上下文描述）。
   • 社区检测：通过图聚类算法（如 Louvain）将图谱划分为主题社区（如 “技术”“市场”），每个社区代表一个语义子图。
   • 生成社区摘要：使用自下而上的方法为每个 community 及其中的重要部分生成摘要。这些摘要包括 Community 内的主要 Entity、Entity 的关系和关键 Claim。这一步为整个数据集提供了概览，并为后续查询提供了有用的上下文信息

2. 查询生成 (检索)
   利用用户提问到知识图谱检索上下文，根据检索的范围，可以分为 2 种检索方式：

• 全局查询：在整个知识图谱检索上下文，可以跨多文档检索
• 本地查询：在特定子图（如社区、领域节点），聚焦在某个实体上

举个例子说明两者之间的关系：

所以全局查询强调整体关联，适合复杂推理，但计算成本高，本地查询注重效率，适合简单问答，但依赖图谱构建质量，实际使用建议混合使用，当用户提出关于特定 Entity（如人名、地点、组织等）的问题时，建议使用本地搜索工作流程，若结果不足再触发全局检索

3. 生成
   • 子图检索：根据用户问题定位相关社区或子图，提取结构化信息（如实体链、关系路径）。
   • 上下文增强：将子图信息转化为文本提示（Prompt），输入 LLM 生成最终回答。

GraphRAG 的例子

背景：微软基于 GraphRAG 构建新闻事件分析系统，用于回答涉及多实体关联的复杂问题，例如：“2023 年某科技公司并购案对行业竞争格局的影响？”

实施流程：

1. 数据源：爬取 100 万篇科技新闻，清洗后提取实体（公司、人物、产品）及关系（并购、合作、竞争）。
2. 图谱构建：在 Neo4j 中存储节点（公司 A、公司 B）、边（“并购”）、属性（时间、金额）。
3. 混合检索：
   • 向量检索：通过 Milvus 检索与 “并购” 相关的文本片段。
   • 图谱检索：查询 “公司 A→并购→公司 B→影响→行业竞争” 的多跳路径。
4. 答案生成：将检索结果（文本片段 + 子图结构）输入 GPT-4，生成包含因果链的答案。

效果对比：

• 传统 RAG：仅能返回单篇新闻中的并购金额等片段化信息。
• GraphRAG：可生成跨时间、跨实体的综合分析，例如：“并购导致市场份额向头部集中，触发反垄断调查”。

总结

GraphRAG 通过知识图谱的引入，解决了传统 RAG 在复杂推理任务中的局限性，但其实现成本较高，需权衡业务需求与资源投入。未来方向包括：

1. 轻量化图谱构建：利用 LLM 自动生成三元组。
2. 动态图谱更新：结合流数据处理技术实现实时更新。
3. 多模态扩展：融合文本、图像、表格等多模态数据构建异构图谱。

适用场景建议：

• 推荐采用 GraphRAG：金融风控（关联交易分析）、医疗诊断（病因推理）、法律合规（案件关联性审查）。
• 仍适用传统 RAG：客服问答（单轮对话）、文档摘要（无复杂逻辑）。

通过灵活选择 RAG 与 GraphRAG 的组合，可最大化大模型在垂直领域落地的价值。

文章《15 Advanced RAG Techniques from Pre-Retrieval to Generation》 总结了提升 RAG 系统性能的 4 类 15 种技术，以优化 RAG 的输出质量、成本及鲁棒性

这些技术分别是：

• 预检索与数据索引技术
  • 技术 1：使用 LLM 提高信息密度（如 GPT-4 提取网页关键信息，减少冗余和噪声）
  • 技术 2：分层索引检索（通过摘要实现多层检索，提升效率）
  • 技术 3：假设性问题索引（生成 QA 对嵌入，解决查询 - 文档不对称问题）
  • 技术 4：LLM 去重（聚类嵌入空间，合并重复信息）
  • 技术 5：分块策略优化（A/B 测试分块大小、重叠率等参数）
• 检索技术
  • 技术 6：LLM 优化搜索查询（适配 Google 语法或对话上下文）
  • 技术 7：HyDE（生成假设性文档嵌入，提升语义相似性）
  • 技术 8：RAG 决策器模式（判断是否需要检索，降低成本）
• 后检索技术
  • 技术 9：重排序（优先展示最相关文档）
  • 技术 10：上下文提示压缩（如 LLMLingua 框架，压缩无关信息）
  • 技术 11：纠正性 RAG（T5 模型过滤不相关结果）
• 生成技术
  • 技术 12：链式思考（CoT）提示（通过推理减少噪声影响）
  • 技术 13：Self-RAG（自省标记，动态调用检索并批判输出）
  • 技术 14：微调模型（提升忽略无关上下文的能力）
  • 技术 15：自然语言推理（NLI 模型过滤无关内容）

预检索与数据索引技术

预检索优化主要目的是提高检索的质量，减少在检索阶段的冗余、错误信息，有助于降低 RAG 系统的成本及幻觉。

技术 1：使用 LLM 提高信息密度

RAG 外挂的数据源有不同的信息密度，如 markdown 等文本文件的信息密度一般比 Web 数据信息密度高，因为 Web 数据除了文本数据，还包含一些 html 标记数据，总的来说，数据源可能出现以下问题：

• 信息密度低 / 信息冗余：低信息内容要求输入更多 token 到 llm，这会导致使用 llm 成本上升
• 不相关信息或噪声：噪声可能误导 llm，甚至在一些常识问题上犯错，也就是外挂数据源引入了新幻觉

所以我们在存储数据前，可以使用 llm 提高数据源的信息密度，减少冗余数据，比如使用 llm 剥离 Web 数据中的 html 标记等信息，然后再存储到知识库中，

利用这个方法可以明显降低 token 数据

• 原始 html：~55000 token
• 精简 html：1500 token
• llm 处理后的 html：330 token

但是使用这个方法，可能会去除一些有用信息，需要提防

技术 2：分层索引检索

直接用用户提问去检索原始文本，可能因为原始文本的信息密度问题导致检索失败，假设知识库存在以下两个片段，当用户提问是：“llm 的定义？”，可能检索到片段 2，因为 llm 出现更加频繁，但是我们实际需要的是片段 1

1. llm 是 xxxxxxx
2. 我要使用 llm、llm 真好用

此时我们除了检索原始文本，还去检索由原始文本总结的摘要，形成摘要、原始文本双层的索引检索，提高检索的质量

技术 3：假设性问题索引

直接用用户提问去检索原始文本，除了信息密度问题，还有一个问题是：通过问题无法检索到答案相关片段，可能是因为答案片段完成没有出现问题的任何关键词或相近词

这是使用 llm 针对所有片段生成片段可能的提问，然后将问题与片段一起存储，这样检索类似场景的难度就会下降，比如有以下片段：

LLM 是大型语言模型（Large Language Model）的缩写，是一种基于深度学习的人工智能技术，通过大量文本数据训练，能够理解和生成自然语言。LLM 可用于文本生成、问答、翻译、摘要、情感分析等任务，还能进行代码生成和多模态内容创作。LLM 采用 Transformer 架构，通过自注意力机制捕捉上下文信息，利用无监督学习方法，如下一个单词预测和掩码语言模型，学习语言的模式和规律。

可以将其拆分为 3 个 QA 组合：

问题：llm 的定义？ 回答：[以上原始文本]
问题：llm 能做什么？ 回答：[以上原始文本]
问题：llm 的原理？ 回答：[以上原始文本]

可以看出，使用这个方法会扩充知识库，提高检索成本，这时候可能使用 HyDE 技术，使用 llm 先回答用户提问，然后使用 [提问，llm 回答] 去检索文档，相当于没有扩充知识库，而是丰富了提问

技术 4：LLM 去重

不同数据源可能包含重复信息，并且会排挤到真正有用的上下文，比如以下 3 个片段

1. 苹果清新甜美，苹果口感爽脆多汁，果香浓郁
2. 苹果，一种常见的水果，富含维生素和膳食纤维，口感清脆多汁，营养丰富，可鲜食或加工成果汁、果酱等
3. 苹果清新甜美，苹果口感爽脆多汁，果香浓郁

假设用户提问是 “苹果是什么？”，当检索系统（有可能）认为片段 1 比片段 2 评分高，由于片段 1、3 是重复的，所以 3 个片段的检索评分是 1=3>2，在检索系统要求返回评分 topk2 的片段时，只会返回片段 1、3，但是实际需要的是片段 2

所以说数据源的去重，有助于提高上下文的准确性，提高模型回答质量

技术 5：分块策略优化

不同数据源，信息密度不同，在分块构建索引时，不同的分块策略，可能影响检索准确性，所以在通过调整：分块大小、重叠率、选择不同嵌入模型，测试检索的效果很有必要

在 llamaindex 中，已经提供流程化的工具去评估检索器，可能通过效果以上参数，测试检索器性能，选择最佳的参数

检索技术

技术 6：LLM 优化搜索查询

在检索内容时，当用户的提问以特定的形式出现时，检索的质量更加精确，比如用户提问：张三 2025 年 2 月 7 日做了什么？直接检索可能检索到其他日期的事情，因为单个数字在检索系统起到的作用很小，此时我们将用户检索转换为
[“张三”,“2025-02-07”]，然后使用这两个字段，类似数据库的方式去查找记录，得到的结果就是 100% 准确的

在多轮的对话系统中，直接使用某次对话去检索上下文可能失败，因为有些信息包含在对话历史中，比如以下对话

用户：xxx 的价格是多少
机器: xxx
用户：它能解决 xxxx

如果直接使用 "它能解决 xxxx" 去检索知识库，得到的肯定是错误答案，此时基于对话历史先用 llm 优化查询很重要

技术 7：HyDE

在查询 vs 文档不对称的 RAG 系统中，直接使用查询去检索文档的准确性不高，此时先使用 llm 生成回答，然后使用 [查询、llm 回答] 去检索文档，准确性得到提高

所谓不对称是指目标文档未直接包含查询内容，或者目标文档在语义层面回答了问题，但是没在字面上回答问题

技术 8：RAG 决策器模式

在准备检索文档前，先使用 llm 判断是否需要检索，对于一些常识问题或者在对话历史出现的问题，直接使用 llm 回答即可，而不需要再次去检索文档，已降低 RAG 系统的成本

比如提问:

请统计 "xxx" 这段话中的人物？
请将 "" 翻译为英文？

后检索技术

技术 9：重排序

在检索系统找到的文档中，根据查询可以分为以下 4 类

• 相关文档 (可以直接回答查询的)
• 有联系但是不相关
• 无联系并且不相关
• 反事实文档（与相关文档相反的）

理想的检索系统是只检索到 “相关文档”，但是实际情况往往会出现其他类型的文档，此时使用 llm 对检索到的文档进行重排序，可以有效提高 llm 的回答质量

技术 10：上下文提示压缩

和重排序不同的是，这里使用 llm 压缩检索到的文档，目的是提高相关文档的重要性，过滤掉其他文档的干扰

这里 llm 相当于一个过滤器，智能选择能回答提问的上下文

技术 11：纠正性 RAG

使用 llm 评估 RAG 系统的输出，将其分类为 [正确、不正确] 的，对于不正确的提问，直接丢起

比如提问 “苹果是什么？”，然后检索到的文档如下，使用每个检索到的文档去生成回答，一共得到 3 个回答，然后使用 llm 选择最佳答案

1. 苹果清新甜美，苹果口感爽脆多汁，果香浓郁
2. 苹果，一种常见的水果，富含维生素和膳食纤维，口感清脆多汁，营养丰富，可鲜食或加工成果汁、果酱等
3. 苹果清新甜美，苹果口感爽脆多汁，果香浓郁

生成技术

技术 12：链式思考（CoT）提示

利用链式思考（CoT）提升模型在噪声或者不相关文档上回答准确性

技术 13：Self-RAG

给定一个输入提示和先前的生成，Self‑RAG  首先确定使用检索到的段落来扩充后续生成 是否有帮助。如果是，它会输出一个检索标记，该标记会根据需要调用检索器模型。

随后，Self‑RAG  会同时处理多个检索到的段落，评估它们的相关性，然后生成相应的任务输 出。然后，它会生成批评标记来批评自己的输出，并从事实性和整体质量方面选择最佳的输出

技术 14：微调模型

鉴于  LLM  通常不会针对  RAG  进行明确训练或调整，因此可以推断，针对此用例对模型进行微调可以提高 模型忽略不相关上下文的能力

技术 15：自然语言推理

使用自然语言推理  (NLI)  模型来识别不相关的上下文，并过滤

1. 模型优化与性能提升

在深度学习模型应用中，模型的大小和复杂度往往与其推理速度和内存占用密切相关。为了在资源有限的环境中部署大型网络，通常需要对模型进行优化。这一优化过程主要包括以下几方面：

• 量化（Quantization）：通过将浮点数向量的精度降低，将模型权重和激活值从 32 位转换为更高效的表示形式（如 8 位或 4 位），从而减少内存占用并加快推理速度。
• 模型压缩（Model Compression）：通过去除冗余的网络结构、迁移学习等技术，削弱不必要的计算步骤，进一步降低模型复杂度。
• 优化后端（Post-Tuning）：针对特定硬件架构（如 CPU）的性能特点，对模型进行微调，使其在资源利用上达到最佳状态。

OpenVINO 框架通过集成了这些技术，为模型优化提供了通用的解决方案，支持多种深度学习模型的部署和推理任务。

2. 基于 ncff 量化模型

NCFF（NNAfter Calibration and Folding）是一种用于对 ONNX 模型进行量化的工具。其核心原理是通过对模型中的神经网络层参数和激活值进行量化，减少数据类型的精度，从而降低计算复杂度和内存占用

NCFF 量化模型的原理主要包括以下几个步骤：首先，选择适合的量化位数；然后，使用训练数据对量化后的模型进行校准，以找到最佳的量化参数；最后，将原始模型中的神经网络层、权重和激活值转换为量化形式，具体代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

def quantiz_by_onnx(onnx_path,save_dir=''):
    # 1. 准备量化需要的校准数据集
    train_dataset = DatasetBuilder()  # 针对自己数据编写加载逻辑，和训练时加载逻辑一样
    train_loader = DataLoader(train_dataset, batch_size=1, shuffle=True)
    
    # 校准时只需要图片数据，不需要标签
    def transform_fn(data_item):
        img, label, weight, is_ng = data_item
        return {'input': img.numpy()} 

    # 构建校准数据集
    calibration_dataset = nncf.Dataset(train_loader, transform_fn)

    # 2. 使用nncf量化onnx
    print('calibration....')
    onnx_model = onnx.load(onnx_path)
    quantized_model = nncf.quantize(
        model=onnx_model, 
        calibration_dataset=calibration_dataset
        )

    # 3. 保存量化模型
    quantized_onnx_path=os.path.join(save_dir,os.path.basename(onnx_path))
    onnx.save(quantized_model, quantized_onnx_path)
    print('quantized_onnx_path:',quantized_onnx_path)

    return quantized_onnx_path

3. 基于 openvino 部署量化模型

按照以下步骤基于 openvino 部署量化模型

1. 模型转换：把 ONNX 文件转换成 OpenVINO 的 XML 格式。这一步应该涉及到 OpenVINO 的 API，比如 ov.convert_model 和 ov.save_model
2. 编译模型：导入了一些性能优化的设置，比如启用 Hyper-threading 和 CPU 固定，这可能是在准备模型进行推理时的设置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 1. onnx->openvino
quantized_openvino_path=quantized_onnx_path.replace('.onnx','.xml')
ov_quantized_model = ov.convert_model(quantized_onnx_path)
ov.save_model(ov_quantized_model, quantized_openvino_path)

# 2. 编译模型
config = {
   hints.performance_mode: hints.PerformanceMode.LATENCY,
   hints.enable_hyper_threading(): False,
   hints.enable_cpu_pinning(): True}
core = ov.Core()
core.set_property({props.cache_dir: r"E:\MyCode\python-openvino\cache"})
ov_model = core.read_model(model=quantized_openvino_path)

compiled_model = core.compile_model(model=ov_quantized_model, device_name="CPU",config=config)

基于编译好的模型，我们使用代码去测试其推理效果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

# 模型推理
img_path=r'1.png'
img = cv2.imdecode(np.fromfile(img_path, dtype=np.uint8), 1)
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# 前处理
img = cv2.resize(img, (512,512), interpolation=cv2.INTER_NEAREST)
img_data=img.astype(np.float32)
img_data/=255.0
print(img_data.shape)
img_data-=0.5
img_data/=0.5
h,w=img_data.shape[:2]
img_data=img_data.reshape(1,1,h,w)

# 推理
print('infer....')
output_layer = compiled_model.output(0)

iters=100
start_time = time.time()  # 获取当前时间
for i in range(iters):
   output=compiled_model([img_data])[output_layer]
end_time = time.time()  # 获取当前时间
print(f"运行时间：{(end_time - start_time)*1.0/iters}秒")

# 后处理
pred = np.zeros_like(output)
pred[output>0.5]=255
pred=pred[0,0].astype(np.uint8)
result=cv2.addWeighted(img,1.0,pred,0.3,0)
cv2.imwrite('ai.png',result)

4. 在 C++ 部署 openvino 推理过程

基于 openvino 的 cpp 版，在 CPU 上部署模型，关键代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

int OpenvinoRuntime::sync_infer(std::vector<cv::Mat>& frames)
{
    for (int si = 0; si < frames.size(); si++)
    {
        int imgWidth = frames[si].size().width;
        int imgHeight = frames[si].size().height;

        // 1.前处理
        int retn = preprocess(frames[si]);
        if (retn < 0)
        {
            return -1;
        }

        // 2.推理
        try {
            const ov::Tensor input_tensor = ov::Tensor(compiled_model.input().get_element_type(), ov::Shape(modelInputShape), (float*)(frames[si].data));
            curr_request.set_input_tensor(input_tensor);
            curr_request.infer();
        }
        catch (ov::Exception& e)
        {
            std::cout << e.what() << endl;
            return -2;
        }

        // 3.后处理
        float* detections = curr_request.get_output_tensor().data<float>();
        cv::Mat predMat(cv::Size(modelInputWidth, modelInputHeight), CV_32F, detections);
        retn = postprocess(frames[si],predMat, imgWidth, imgHeight,si);
        if (retn < 0)
        {
            return -3;
        }
    }

    return 0;
}

针对 openvino 提供的批处理及异步推理，相应还编写以下推理方法

1
2
3
4
5

int sync_infer(std::vector<cv::Mat>& frames);
int sync_infer_batch(std::vector<cv::Mat>& frames);
int async_infer(std::vector<cv::Mat>& frames);
int sync_infer_preprocess(std::vector<cv::Mat>& frames);
int async_infer_preprocess(std::vector<cv::Mat>& frames); 

除此之外，将以上的 C 代码编译为 dll，并使用 CLR 封装其接口，以便供 C 或者 C# 使用

5. 效果分析

以下统计在不同软硬件平台部署模型的耗时，可以看出在 CPU 部署模型时，openvino 部署方式更快，已经接近在 GPU 部署

总结

本文基于 openvino 构建了一个 onnx 模型的部署流程，其耗时和 GPU 部署接近，并最终编译为 dll，提供到不同的软件开发平台使用。

使用 openvino 丰富了模型的应用场景，从传统的要求使用 GPU，推广到 CPU，降低了模型应用的成本。

所谓变化，就是场景中新增那些目标、那些目标去除了，由于图片不是对齐的，所以无法直接通过图片加减法去找到图片变化位置，并且如果涉及变化的目标类别，该方法也无法做到。

本文使用语义分割模型实现图片变化分析，常规的语义分割模型输入一张图片，然后分割图片目标，这里将范式改为：输入前后时刻的图片，输出变化的二值图，最终实现下图效果

上图分别是前后不同时刻同一位置的卫星图片、人工认定的变化区域、语义分割模型分析的变化区域。可以看出语义分割模型基本找到变化区域

模型定义

本文使用 deeplabv3 + 模型，输入通道由原来的 3 通道变为 6 通道（两张 3 通道的图片合并），输出为 1 个类别的概率图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class DeepLabV3Plus(nn.Module):
    def __init__(self, aspp_dilations=None, aspp_dropout=True, dropout_prob=0.2, num_classes=1, pretrained=True):
        super(DeepLabV3Plus, self).__init__()

        # 改动输入为6通道转为3通道
        self.get_input=nn.Conv2d(6, 3, kernel_size=7, stride=2, padding=3, bias=False)
        self.backbone = resnet18(pretrained=pretrained)

        self.aspp = ASPP(aspp_dilations=aspp_dilations, aspp_dropout=aspp_dropout)
        self.decoder = Decoder(num_classes=num_classes, dropout_prob=dropout_prob)
        self.freeze_modules = self.backbone

    def forward(self, input):
        input=self.get_input(input)
        x, feat_2x, feat_4x = self.backbone(input)
        x = self.aspp(x)
        x = self.decoder(x, feat_2x, feat_4x)
        x = F.interpolate(x, size=input.size()[2:], mode="bilinear", align_corners=True)

        return x

数据加载

由于此处分析的图片是卫星图片，分辨率很大，这里首先使用 sahi 将图片重叠切分为小图，然后再进行训练，切割后图片如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

from sahi.slicing import slice_image

img1_path='/home/wushaogui/MyCodes/Pytorch_Change_detection/CD_Data_GZ/labels_change/P_GZ_test4_2010_2019.png'
data_name='test'

SliceImageResult=slice_image(
    image=img1_path,
    output_file_name=data_name,
    output_dir=None,
    slice_height=1024,
    slice_width=1024,
    overlap_height_ratio=0.5,
    overlap_width_ratio=0.5
)

show_images(SliceImageResult.images)

训练过程

使用 tensorboard 查看训练过程，可以将看出 fscore 逐渐提升，最终训练集 fscore>0.98，验证集 fscore~0.87

本方法是利用 paddle 的两个工具，一个是 ocr，用于从 pdf 抽取文本，另一个是 nlp 模型，用于从文本中抽取关键信息，开始介绍前先安装环境

1
2

conda install paddlepaddle-gpu cudatoolkit
python -m pip install opencv-contrib-python==4.4.0.46 paddleocr paddlenlp==2.4

提取图片上的文字

本方法处理的文件是 pdf，这里利用 PaddleOCR 抽取其中的文本数据，该工具输入是图片，所以需要其他工具将 pdf 转为图片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

from paddleocr import PaddleOCR, draw_ocr  # type: ignore
from PIL import Image
import cv2
import numpy as np
import matplotlib.pyplot as plt

# paddleocr目前支持中英文、英文、法语、德语、韩语、日语等80个语种，可以通过修改lang参数进行切换
ocr = PaddleOCR(use_angle_cls=False, lang="ch", det_db_box_thresh=0.3, use_dilation=True)
# 印章部分造成的文本遮盖，影响了文本识别结果，因此可以考虑通道提取，去除图片中的红色印章
#读入图像,三通道
image=cv2.imread("./test_img/hetong3.jpg",cv2.IMREAD_COLOR) #timg.jpeg

import time
from my_read_code_tools import *
start=time.time()
# 合同文本信息提取
# 合同照片的红色通道被分离，获得了一张相对更干净的图片，此时可以再次使用ppocr模型提取文本内容
img_path = './red_channel.jpg' # 使用红色通道图片排除印章影响
result = ocr.ocr(img_path, cls=False)
# 可视化结果，不想可视化可以注释下面几行代码
image = Image.open(img_path).convert('RGB')
boxes = [line[0] for line in result[0]]
txts = [line[1][0] for line in result[0]]
scores = [line[1][1] for line in result[0]]
im_show = draw_ocr(image, boxes, txts, scores, font_path='./simfang.ttf')
im_show = Image.fromarray(im_show)
vis = np.array(im_show)
# im_show.show()
show_images([vis])
#忽略检测框内容，提取完整的合同文本：
txts = [line[1][0] for line in result[0]]
all_context = "\n".join(txts)
print(all_context)

end=time.time()
print('cost time:{}s'.format(end-start))

[2024/04/10 16:06:16] ppocr DEBUG: dt_boxes num : 24, elapsed : 1.3868777751922607[2024/04/10 16:06:16] ppocr DEBUG: rec_res num  : 24, elapsed : 0.5372314453125

甲方：佛山市禅城区住房城乡建设和水利局
乙方：交通银行股份有限公司佛山分行
丙方：佛山市禅城区盈恒置业有限公司
为加强商品房预售管理，规范商品房预售款使用行为，根据《广
东省商品房预售管理条例》（以下简称《条例》）和《佛山市商品房预
售款监督管理实施办法》（以下简称《办法》），经甲方、乙方和丙方三
方协商，就坐落于_佛山市禅城区佛罗路南侧、化纤路北侧，项目名
称为保利芳华苑 12 座，监控账号 446899991010003029262
的商品房屋预售款收存和划拨使用订立如下协议，共同遵守。
一、 权利
1、甲方负责贯彻实施《条例》和《办法》有关规定，行使商品房
预售款收存和使用的日常监督管理的权利。
2、乙方在为丙方办理预售款拨付时，应要求丙方出具经甲方审核
同意的《佛山市商品房预售款使用申请表》。
公有限
3、预售项目完成初始登记并达到购房人可单方办理转移登记条件
V
的，丙方可持有关证明文件向甲方申请办理专用账户解除监管手续。
经甲方核准同意的，在《佛山市商品房预售款监管专用账户取消监管
申请表》上加具同意的意见后，视同本协议取消。丙方凭《佛山市商
cost time:2.178391218185425s

关键信息抽取

使用 paddlenlp 从提取的文本中抽取关键信息，比如下面抽取 [“甲方”,“乙方”,“总价”,“大写”,“小写”,“项目”] 等信息

1
2
3
4
5
6
7
8
9
10
11
12
13

from paddlenlp import Taskflow # type: ignore

schema = ["甲方","乙方","总价","大写","小写","项目"]
ie = Taskflow('information_extraction', schema=schema)
ie.set_schema(schema)

start=time.time()

result = ie(all_context)
print(result)

end=time.time()
print('cost time:{}s'.format(end-start))

[{'甲方': [{'text': '佛山市禅城区住房城乡建设和水利局', 'start': 3, 'end': 19, 'probability': 0.8409922679564374}], '乙方': [{'text': '交通银行股份有限公司佛山分行', 'start': 23, 'end': 37, 'probability': 0.8475471161905048}], '项目': [{'text': '保利芳华苑12座', 'start': 183, 'end': 191, 'probability': 0.5095629052180897}]}]cost time:0.20002102851867676s

使用 nuitka 将以上过程打包为 exe，可以自定义处理的文档及关键信息

运行时，后台日志如下：

结果展示

Torch-TensorRT 是 PyTorch/TorchScript/FX 的编译器。与 PyTorch 的即时 （JIT） 编译器不同，Torch-TensorRT 是一个提前 （AOT） 编译器，这意味着在部署 TorchScript 代码之前，您需要执行一个明确的编译步骤，将标准 TorchScript 或 FX 程序转换为面向 TensorRT 引擎的模块

使用 Torch-TensorRT 编译 ResNet50

1. 加载并测试模型

1
2
3
4
5
6
7
8
9
10
11

import torch
import torchvision

torch.hub._validate_not_a_forked_repo=lambda a,b,c: True

resnet50_model = torch.hub.load('pytorch/vision:v0.10.0', 'resnet50', pretrained=True)
resnet50_model.eval()

# Model benchmark without Torch-TensorRT
model = resnet50_model.eval().to("cuda")
benchmark(model, input_shape=(128, 3, 224, 224), nruns=100)

2. 编译模型 - fp32

1
2
3
4
5
6
7
8
9
10
11

import torch_tensorrt

# The compiled module will have precision as specified by "op_precision".
# Here, it will have FP32 precision.
trt_model_fp32 = torch_tensorrt.compile(model, inputs = [torch_tensorrt.Input((128, 3, 224, 224), dtype=torch.float32)],
    enabled_precisions = torch.float32, # Run with FP32
    workspace_size = 1 << 22
)

# Obtain the average time taken by a batch of input
benchmark(trt_model_fp32, input_shape=(128, 3, 224, 224), nruns=100)

3. 编译模型 - fp16

1
2
3
4
5
6
7
8
9
10
11

import torch_tensorrt

# The compiled module will have precision as specified by "op_precision".
# Here, it will have FP32 precision.
trt_model_fp32 = torch_tensorrt.compile(model, inputs = [torch_tensorrt.Input((128, 3, 224, 224), dtype=torch.float32)],
    enabled_precisions = , dtype=torch.half, # Run with FP32
    workspace_size = 1 << 22
)

# Obtain the average time taken by a batch of input
benchmark(trt_model_fp32, input_shape=(128, 3, 224, 224), dtype='fp16', nruns=100)

使用 Torch-TensorRT 编译 TorchScript 模型

1. 加载并测试模型

1
2
3

model = LeNet()
model.to("cuda").eval()
benchmark(model)

2. 生成 trace 模型，并测试速度

1
2

traced_model = torch.jit.trace(model, torch.empty([1,1,32,32]).to("cuda"))
benchmark(traced_model)

3. 生成 script 模型，并测试速度

1
2
3

model = LeNet().to("cuda").eval()
script_model = torch.jit.script(model)
benchmark(script_model)

4. 使用 Troch-TensoRT 编译 trace 模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import torch_tensorrt

# We use a batch-size of 1024, and half precision
trt_ts_module = torch_tensorrt.compile(traced_model, inputs=[torch_tensorrt.Input(
            min_shape=[1024, 1, 32, 32],
            opt_shape=[1024, 1, 33, 33],
            max_shape=[1024, 1, 34, 34],
            dtype=torch.half
            )], 
            enabled_precisions = {torch.half})

input_data = torch.randn((1024, 1, 32, 32))
input_data = input_data.half().to("cuda")

input_data = input_data.half()
result = trt_ts_module(input_data)
torch.jit.save(trt_ts_module, "trt_ts_module.ts")

benchmark(trt_ts_module, input_shape=(1024, 1, 32, 32), dtype="fp16")

5. 使用 Troch-TensoRT 编译 script 模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

import torch_tensorrt

trt_script_module = torch_tensorrt.compile(script_model, inputs = [torch_tensorrt.Input(
            min_shape=[1024, 1, 32, 32],
            opt_shape=[1024, 1, 33, 33],
            max_shape=[1024, 1, 34, 34],
            dtype=torch.half
            )],
            enabled_precisions={torch.half})

input_data = torch.randn((1024, 1, 32, 32))
input_data = input_data.half().to("cuda")

input_data = input_data.half()
result = trt_script_module(input_data)
torch.jit.save(trt_script_module, "trt_script_module.ts")

benchmark(trt_script_module, input_shape=(1024, 1, 32, 32), dtype="fp16")

使用 Torch-TensorRT 进行 PTQ 量化

1. 构建模型，并使用 Torch-TensorRT 转换，但是未进行量化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# Exporting to TorchScript
with torch.no_grad():
    data = iter(val_dataloader)
    images, _ = data.next()
    jit_model = torch.jit.trace(model, images.to("cuda"))
    torch.jit.save(jit_model, "mobilenetv2_base.jit.pt")

#Loading the Torchscript model and compiling it into a TensorRT model
baseline_model = torch.jit.load("mobilenetv2_base.jit.pt").eval()
compile_spec = {"inputs": [torch_tensorrt.Input([64, 3, 224, 224])]
               , "enabled_precisions": torch.float
               }
trt_base = torch_tensorrt.compile(baseline_model, **compile_spec)

# Evaluate and benchmark the performance of the baseline TRT model (TRT FP32 Model)
test_loss, test_acc = evaluate(trt_base, val_dataloader, criterion, 0)
print("Mobilenetv2 TRT Baseline accuracy: {:.2f}%".format(100 * test_acc))

benchmark(trt_base, input_shape=(64, 3, 224, 224))

2. 使用 torch-tensorRT 进行 PTQ 量化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

calibrator = torch_tensorrt.ptq.DataLoaderCalibrator(calib_dataloader,
                                              use_cache=False,
                                              algo_type=torch_tensorrt.ptq.CalibrationAlgo.MINMAX_CALIBRATION,
                                              device=torch.device('cuda:0'))

compile_spec = {
         "inputs": [torch_tensorrt.Input([64, 3, 224, 224])],
         "enabled_precisions": torch.int8,
         "calibrator": calibrator,
        "truncate_long_and_double": True
         
     }
trt_ptq = torch_tensorrt.compile(baseline_model, **compile_spec)

# Evaluate the PTQ model
test_loss, test_acc = evaluate(trt_ptq, val_dataloader, criterion, 0)
print("Mobilenetv2 PTQ accuracy: {:.2f}%".format(100 * test_acc))

benchmark(trt_ptq, input_shape=(64, 3, 224, 224))

使用 Torch-TensorRT 进行 QAT 量化

1. 定义并加载模型权重

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

quant_modules.initialize()

# 定义并加载模型权重
# All the regular conv, FC layers will be converted to their quantized counterparts due to quant_modules.initialize()
feature_extract = False
q_model = models.mobilenet_v2(pretrained=True)
set_parameter_requires_grad(q_model, feature_extract)
q_model.classifier[1] = nn.Linear(1280, 10)
q_model = q_model.cuda()

# mobilenetv2_base_ckpt is the checkpoint generated from Step 2 : Training a baseline Mobilenetv2 model.
ckpt = torch.load("./mobilenetv2_base_ckpt")
modified_state_dict={}
for key, val in ckpt["model_state_dict"].items():
    # Remove 'module.' from the key names
    if key.startswith('module'):
        modified_state_dict[key[7:]] = val
    else:
        modified_state_dict[key] = val

# Load the pre-trained checkpoint
q_model.load_state_dict(modified_state_dict)
optimizer.load_state_dict(ckpt["opt_state_dict"])

2. 定义校准规则并校准，这里使用 max 校准

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

# 定义校准规则并校准，这里使用max校准
def compute_amax(model, **kwargs):
    # Load calib result
    for name, module in model.named_modules():
        if isinstance(module, quant_nn.TensorQuantizer):
            if module._calibrator is not None:
                if isinstance(module._calibrator, calib.MaxCalibrator):
                    module.load_calib_amax()
                else:
                    module.load_calib_amax(**kwargs)
    model.cuda()

def collect_stats(model, data_loader, num_batches):
    """Feed data to the network and collect statistics"""
    # Enable calibrators
    for name, module in model.named_modules():
        if isinstance(module, quant_nn.TensorQuantizer):
            if module._calibrator is not None:
                module.disable_quant()
                module.enable_calib()
            else:
                module.disable()

    # Feed data to the network for collecting stats
    for i, (image, _) in tqdm(enumerate(data_loader), total=num_batches):
        model(image.cuda())
        if i >= num_batches:
            break

    # Disable calibrators
    for name, module in model.named_modules():
        if isinstance(module, quant_nn.TensorQuantizer):
            if module._calibrator is not None:
                module.enable_quant()
                module.disable_calib()
            else:
                module.enable()


#Calibrate the model using percentile calibration technique.
with torch.no_grad():
    collect_stats(q_model, train_dataloader, num_batches=32)
    compute_amax(q_model, method="max")

3. 微调 QAT 模型 2 个 epoch

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 微调QAT模型2个epoch
num_epochs=2
lr = 0.001
for epoch in range(num_epochs):
    print('Epoch: [%5d / %5d] LR: %f' % (epoch + 1, num_epochs, lr))

    train(q_model, train_dataloader, criterion, optimizer, epoch)
    test_loss, test_acc = evaluate(q_model, val_dataloader, criterion, epoch)

    print("Test Loss: {:.5f} Test Acc: {:.2f}%".format(test_loss, 100 * test_acc))
    
save_checkpoint({'epoch': epoch + 1,
                 'model_state_dict': q_model.state_dict(),
                 'acc': test_acc,
                 'opt_state_dict': optimizer.state_dict()
                },
                ckpt_path="mobilenetv2_qat_ckpt")

4. 导出 QAT 模型，得到 Torchscript 模型

1
2
3
4
5
6
7

# 导出QAT模型，得到Torchscript模型
quant_nn.TensorQuantizer.use_fb_fake_quant = True
with torch.no_grad():
    data = iter(val_dataloader)
    images, _ = data.next()
    jit_model = torch.jit.trace(q_model, images.to("cuda"))
    torch.jit.save(jit_model, "mobilenetv2_qat.jit.pt")

5. 加载 Torchscript 模型并编译为 TensorRT 模型

1
2
3
4
5
6
7
8
9
10
11

#加载Torchscript模型并编译为TensorRT模型
qat_model = torch.jit.load("mobilenetv2_qat.jit.pt").eval()
compile_spec = {"inputs": [torch_tensorrt.Input([64, 3, 224, 224])],
                "enabled_precisions": torch.int8
               }
trt_mod = torch_tensorrt.compile(qat_model, **compile_spec)

#Evaluate and benchmark the performance of the QAT-TRT model (TRT INT8)
test_loss, test_acc = evaluate(trt_mod, val_dataloader, criterion, 0)
print("Mobilenetv2 QAT accuracy using TensorRT: {:.2f}%".format(100 * test_acc))
benchmark(trt_mod, input_shape=(64, 3, 224, 224))

提升网站的 SEO

SEO（Search Engine Optimization，搜索引擎优化）是一种通过优化网站内容和结构，提高网站在搜索引擎自然搜索结果中排名的技术和策略。SEO 的目的是增加网站的流量、提升用户体验

在 next 主题中，支持在文件_config.next.yml.yml 配置搜索引擎验证

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# Google Webmaster tools verification.
# See: https://developers.google.com/search
google_site_verification: 

# Bing Webmaster tools verification.
# See: https://www.bing.com/webmasters
bing_site_verification: 

# Yandex Webmaster tools verification.
# See: https://webmaster.yandex.ru
yandex_site_verification:

# Baidu Webmaster tools verification.
# See: https://ziyuan.baidu.com/site
baidu_site_verification: 

分别访问以上连接，然后注册帐号，获取 site_verification，填入以上位置，重写提交后，到对应网站测试是否成功，以下是 bing 的提交界面

提交完成后，到对应的搜索引擎下检索自己的网站，检索成功即设置成功

三、安全设置 ^[1]

以前将 hexo 发布到 github page，相当于服务器在 github，带宽和流量都不用自己担心，现在这些都在自己掌控下，服务器和域名这种一次性付费的项目还不用担心，但是带宽和流量是动态，这就需要设置预警门槛，别把自己钱包弄空了

目前动态计费项目有：

• COS 部分：因为 COS 上主要存储着图片，主要计费点是访问下行流量及上传图片存储，主要风险是盗刷
• CDN 部分：通过加速网站内容的分发，提高用户访问速度，

跨域访问 CORS 设置

防盗链设置

自定义 CDN 加速域名 (付费项目)

cdn 配置部分

设置防盗链和访问频率

用量封顶配置

购买 CDN 流浪包

参考：

备案包含两个部门的备案，即 ICP 备案、公安备案，两者区别如下

由于本人的域名、服务器都在腾讯云，所以全程参考腾讯云提供的文档完成备案，两个备案的操作手册：

• ICP 备案 首次备案 - ICP 备案操作指引（PC 端）- 文档中心 - 腾讯云
• ICP 备案 公安备案流程 - 公安备案与经营性备案 - 文档中心 - 腾讯云

ICP 备案

ICP 备案分为两个阶段，第一阶段在腾讯云提交审核资料，腾讯云完成资料初步审核后，与本人确认后再帮提交到工信部，第二阶段是在工信部网站完成的

公安备案

ICP 审核完成后，可以申请公安备案，这个过程是直接在全国互联网安全管理平台完成，

首先注册个人帐号，然后申请主体，完成网站备案

hexo 配置备案信息

完成以上两个备案后，在 hexo 下找到_config.next.yml.yml，设置以下字段：

1
2
3
4
5
6
7
8
9
10

# Beian ICP and gongan information for Chinese users. See: https://beian.miit.gov.cn, https://beian.mps.gov.cn
beian:
  enable: true
  icp: 粤ICP备 2025368593号-1
  # The digit in the num of gongan beian.
  gongan_id: 44011302004761
  # The full num of gongan beian.
  gongan_num: 粤公网安备 44011302004761号
  # The icon for gongan beian. Login and See: https://beian.mps.gov.cn/web/business/businessHome/website
  gongan_icon_url: /images/beian.png

重写提交网站到服务器，即可看到网站备案信息，此时可通过域名访问网站

TensorRT 的量化原理？

• TensorRT 支持量化浮点，可以显着提高了算术吞吐量，同时降低了存储要求和内存带宽。在量化浮点张量时，TensorRT 需要知道它的动态范围 —— 即表示什么范围的值。动态范围信息可由构建器根据代表性输入数据计算（这称为校准 calibration）。或者，您可以在框架中执行量化感知训练，并将模型与必要的动态范围信息一起导入到 TensorRT，分别对应以下的 PQT 量化、QAT 量化
• TensorRT 支持 2 种量化，一种是 INT8 推理，也就是 PQT 量化，另一种是带有 Q/QD 算子以指定量化参数的量化（QAT 量化）
• INT8 量化需要进行校准，以便确定激活值的量化范围；而带有 Q/DQ 操作的模型则将量化参数自带在 Q/DQ 算子中，可以直接量化

TensoRT 如何进行 PTQ 量化？

• PTQ 量化时，量化激活值阶段需要进行校准，可以使用有代表的数据集进行校准，也可以外部输入校准表进行校准
• 所需的输入数据量取决于应用，但实验表明，约 500 幅图像足以校准 ImageNet 分类网络。
• 官方提供配套工具 pytorch-quantization 进行 PTQ 量化

TensoRT 如何使用经过 QAT 的 ONNX 模型？

• TensoRT8 可以直接加载通过 QAT 量化后且导出为 ONNX 的模型，官方提供配套工具 pytorch-quantization 进行 QAT 量化

TensoRT 如何使用使用 Pytorch 模型进行量化推理

• 已经训练好的模型，经过 Quantization Toolkit 进行模型量化
• 使用 torch.onnx.export 导出模型为 onnx
• tensorRT 对 onnx 根据 Q/DQ 的设置量化模型 + 通用优化操作，生成推理引擎，并执行推理

逐张量 (Per-tensor) 量化与逐通道 (Per-channel) 量化？

• 逐张量 (Per-tensor) 量化：其中使用单个尺度值（标量）来缩放整个张量
• 逐通道 (Per-channel) 量化：对于卷积神经网络，其中尺度张量沿给定轴广播

TensorRT 的显式量化？

• 在显式量化的网络中，量化值和非量化值之间转换的缩放操作由图中的 IQuantizeLayer 和 IDequentizeLayer 节点显式表示，这些节点此后将被称为 Q/DQ 节点。与隐式量化相比，显式形式精确地指定了向 INT8 和从 INT8 进行转换的位置，优化器将仅执行由模型语义决定的精度转换
• 当 PyTorch 或 TensorFlow 中的模型导出到 ONNX 时，ONNX 使用显式量化表示法 -，框架图中的每个伪量化操作都导出为 Q，后跟 DQ
• 当 TensorRT 检测到模型中有 QDQ 算子的时候，就会触发显式量化

TensorRT 的隐式量化？

• 在处理隐式量化网络时，TensorRT 在应用图形优化时将模型视为浮点模型，并利用 INT8 机会优化层执行时间。如果一个层在 INT8 中运行得更快，那么它在 INT8 执行。否则，使用 FP32 或 FP16。 在此模式下，TensorRT 仅针对性能进行优化，您几乎无法控制 INT8 的使用位置 - 即使您在 API 级别明确设置了一个层的精度，TensorRT 也可能在图形优化期间将该层与另一层融合，并丢失它必须在 INT8 中执行的信息
• TensorRT 的 PTQ 能力生成隐式量化网络

TensorRT 的 Network-Level 精度设置？

• FP32 是大多数框架的默认训练精度，因此我们将首先使用 FP32 进行推断。推理通常需要比训练更少的数值精度。较低的精度可以在不牺牲精度的情况下实现更快的计算和更低的内存消耗
• 降低的精度支持取决于您的硬件，参考：Hardware and Precision
• 注意： TensorRT 为层选择精度，但是如果设置精度导致速度变慢或者该层没有低精度实现时，这些层将使用高精度
• C++ 检测硬件支持精度并设置精度

  1 2 3

  if (builder->platformHasFastFp16()) { … }; config-> setFlag(BuilderFlag: :kFP16);

TensorRT 的 Layer-Level 的精度设置？

• config-> setFlag(BuilderFlag: :kFP16); 提供了精度粗粒度控制。然而有时网络的一部分需要更高的动态范围或对数值精度敏感，可以约束每层的输入和输出类型
• C++ 上为某一层设置输入输出类型

  1 2	layer->setPrecision(DataType::kFP16) layer->setOutputType(out_tensor_index, DataType::kFLOAT)

• 计算使用精度： 计算将使用与输入首选的浮点类型相同的浮点类型。大多数 TensorRT 实现具有相同的输入和输出浮点类型；然而，卷积、反卷积和 FullyConnected 可以支持量化 INT8 输入和非量化 FP16 或 FP32 输出，因为有时需要使用来自量化输入的更高精度输出来保持精度。
• 上下层精度设置冲突： 设置精度约束提示 TensorRT 应该选择输入和输出与首选类型匹配的层实现，如果上一层的输出和下一层的输入与请求的类型不匹配，则插入重新格式化操作。

什么是 PyTorch-Quantization？

• TensorRT 开发的量化工具包，可以便捷将 Pytorch 的模型量化为 TensorRT 支持的量化模型，它支持将 Pytorch 模型按 PQT 或 QAT 量化。

使用 PyTorch-Quantization 导出 PQT 模型

使用以下代码将量化每个模块，如果不希望所有模块都量化，则应手动替换量化模块

1
2

from pytorch_quantization import quant_modules
quant_modules.initialize()

为了有效推断，我们希望为每个量化器选择一个固定范围。从预先训练的模型开始，最简单的方法是校准

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

quant_desc_input = QuantDescriptor(calib_method='histogram')
quant_nn.QuantConv2d.set_default_quant_desc_input(quant_desc_input)
quant_nn.QuantLinear.set_default_quant_desc_input(quant_desc_input)

model = models.resnet50(pretrained=True)
model.cuda()

# 定义校准数据集
data_path = "PATH to imagenet"
batch_size = 512

traindir = os.path.join(data_path, 'train')
valdir = os.path.join(data_path, 'val')
dataset, dataset_test, train_sampler, test_sampler = load_data(traindir, valdir, False, False)

data_loader = torch.utils.data.DataLoader(
    dataset, batch_size=batch_size,
    sampler=train_sampler, num_workers=4, pin_memory=True)

data_loader_test = torch.utils.data.DataLoader(
    dataset_test, batch_size=batch_size,
    sampler=test_sampler, num_workers=4, pin_memory=True)

# 定义校准规则并校准
def collect_stats(model, data_loader, num_batches):
     """Feed data to the network and collect statistic"""

     # Enable calibrators
     for name, module in model.named_modules():
         if isinstance(module, quant_nn.TensorQuantizer):
             if module._calibrator is not None:
                 module.disable_quant()
                 module.enable_calib()
             else:
                 module.disable()

     for i, (image, _) in tqdm(enumerate(data_loader), total=num_batches):
         model(image.cuda())
         if i >= num_batches:
             break

     # Disable calibrators
     for name, module in model.named_modules():
         if isinstance(module, quant_nn.TensorQuantizer):
             if module._calibrator is not None:
                 module.enable_quant()
                 module.disable_calib()
             else:
                 module.enable()

 def compute_amax(model, **kwargs):
     # Load calib result
     for name, module in model.named_modules():
         if isinstance(module, quant_nn.TensorQuantizer):
             if module._calibrator is not None:
                 if isinstance(module._calibrator, calib.MaxCalibrator):
                     module.load_calib_amax()
                 else:
                     module.load_calib_amax(**kwargs)
             print(F"{name:40}: {module}")
     model.cuda()

# It is a bit slow since we collect histograms on CPU
 with torch.no_grad():
     collect_stats(model, data_loader, num_batches=2)
     compute_amax(model, method="percentile", percentile=99.99)

评估量化 + 校准后的模型，并保存

1
2
3
4
5
6

criterion = nn.CrossEntropyLoss()
with torch.no_grad():
    evaluate(model, criterion, data_loader_test, device="cuda", print_freq=20)

# Save the model
torch.save(model.state_dict(), "/tmp/quant_resnet50-calibrated.pth")

使用 PyTorch-Quantization 导出 QAT 模型

对于 PQT 模型，对其进行微调，得到 QAT 模型

1
2
3
4
5
6
7
8
9

criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.0001)
lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.1)

# Training takes about one and half hour per epoch on a single V100
train_one_epoch(model, criterion, optimizer, data_loader, "cuda", 0, 100)

# Save the model
torch.save(model.state_dict(), "/tmp/quant_resnet50-finetuned.pth")

将经过 PyTorch-Quantization 量化的模型导出为 ONNX

导出到 ONNX 的目标是通过 TensorRT 部署推理，而不是 ONNX 运行时。因此，我们只将假量化模型导出为 TensorRT 将采用的形式。假量化将被分解成一对 QuantizeLinear/DequantizeLinear ONNX ops

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

from pytorch_quantization import nn as quant_nn
quant_nn.TensorQuantizer.use_fb_fake_quant = True

from pytorch_quantization import nn as quant_nn
from pytorch_quantization import quant_modules
quant_nn.TensorQuantizer.use_fb_fake_quant = True

quant_modules.initialize()
model = torchvision.models.resnet50()
# load the calibrated model
state_dict = torch.load("quant_resnet50-entropy-1024.pth", map_location="cpu")
model.load_state_dict(state_dict)
model.cuda()

dummy_input = torch.randn(128, 3, 224, 224, device='cuda')

input_names = [ "actual_input_1" ]
output_names = [ "output1" ]

# enable_onnx_checker needs to be disabled. See notes below.
torch.onnx.export(
    model, dummy_input, "quant_resnet50.onnx", verbose=True, opset_version=10, enable_onnx_checker=False)

参考：

1. Developer Guide :: NVIDIA Deep Learning TensorRT Documentation
2. 使用 NVIDIA QAT 工具包为 TensorFlow 和 NVIDIA TensorRT 加速量化网络 - NVIDIA 技术博客
3. 利用 NVIDIA TensorRT 量化感知训练实现 INT8 推理的 FP32 精度 - NVIDIA 技术博客
4. 一起实践量化番外篇 ——TensorRT-8 的量化细节 - Oldpan 的个人博客

Pytorch 原生量化之 FX Graph Mode Quantization?

• FX Graph Mode Quantization 是 PyTorch 中一个新的自动量化框架，目前它是一个原型功能。它通过添加对函数的支持和自动化量化过程来改进 Eager Mode Quantization

1
2
3
4
5
6
7
8
9
10
11
12
13
14

import torch
from torch.quantization import get_default_qconfig
from torch.quantization.quantize_fx import prepare_fx, convert_fx
float_model.eval()  # 因为是PTQ，所以就推理模式就够了
qconfig = get_default_qconfig("fbgemm")  # 指定量化细节配置
qconfig_dict = {"": qconfig}             # 指定量化选项
def calibrate(model, data_loader):       # 校准功能函数
model.eval()
with torch.no_grad():
for image, target in data_loader:
model(image)
prepared_model = prepare_fx(float_model, qconfig_dict)  # 准备量化模型，比如融合CONV+BN+RELU，然后插入量化观察节点
calibrate(prepared_model, data_loader_test)  # 校准数据集进行标准
quantized_model = convert_fx(prepared_model)  # 把校准后的模型转化为量化版本模型

Pytorch 原生量化之 Eager Mode Quantization?

• Eager Mode Quantization 是一项测试功能。用户需要进行融合并指定手动进行量化和去量化的位置，而且它只支持模块而不支持功能

• 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

  import torch # define a floating point model where some layers could be statically quantized class M(torch.nn.Module): def __init__(self): super(M, self).__init__() # QuantStub converts tensors from floating point to quantized self.quant = torch.quantization.QuantStub() self.conv = torch.nn.Conv2d(1, 1, 1) self.relu = torch.nn.ReLU() # DeQuantStub converts tensors from quantized to floating point self.dequant = torch.quantization.DeQuantStub() def forward(self, x): # 自己指定开始量化的层 x = self.quant(x) x = self.conv(x) x = self.relu(x) # 指定结束量化的层 x = self.dequant(x) return x # create a model instance model_fp32 = M() # model must be set to eval mode for static quantization logic to work model_fp32.eval() model_fp32.qconfig = torch.quantization.get_default_qconfig('fbgemm') # 指定融合的层 model_fp32_fused = torch.quantization.fuse_modules(model_fp32, [['conv', 'relu']]) model_fp32_prepared = torch.quantization.prepare(model_fp32_fused) input_fp32 = torch.randn(4, 1, 4, 4) model_fp32_prepared(input_fp32) model_int8 = torch.quantization.convert(model_fp32_prepared) res = model_int8(input_fp32)

参考：

1. TORCH.FX 第二篇 ——PTQ 量化实操 - Oldpan 的个人博客
2. Site Unreachable

量化原理

量化是模型压缩的一种方式，通过将模型参数从宽范围调整宰范围，使得计算量降低

未量化前权重和激活的表示范围是 FP32，量化可以是 FP16、TF8，甚至是 4bit、2bit

• FP32 表示的范围：浮点数范围在 [-3.4e38,3.4e38] 之间，这个区间被称为动态范围 (dynamic-range)
• int8 量化：使用 scale-factor 将浮点张量的动态范围映射到 [-128,127]，又称对称量子化，因为范围关于原点对称，TensoRT 使用对称量化来表示激活值与权重
• 量化计算公式：对任意浮点张量分布，拿到绝对值最大的元素 max，量化的目的是将浮点数从 [-max,max] 缩小到 [-128,127]，则先计算 [-max,max] 被 256 等分，然后判断浮点数处于第几等分上

$$\begin{array}{c}a_{max} =\max \left(a b s\left(x_{f}\right)\right) \\\text { scale }=(2 * a_{max} ) / 256 \\x_{q}=\operatorname{Clip}\left(\operatorname{Round}\left(x_{f} / \text { scale }\right)\right)\end{array}$$

为什么量化后模型推理变快了呢？可以从以下角度分析：

• 吞吐量变大：使用更加快速的 INT8 内核进行计算，其速度更快
• 数据交换时间更少：尤其是数据交换从原来的 32 位，变为 8 位，交换的数据量减少到 1/8
• 减少带宽占用：有些层有带宽限制（内存有限）。这意味着它们的实现将大部分时间用于读写数据，因此减少它们的计算时间并不会减少它们的总体运行时间。带宽限制层从减少的带宽需求中获益最大
• 减少内存占用：模型需要更少的存储空间，参数更新更小，缓存利用率更高

量化按技术路线

训练后量化 (PTQ)：

• 在训练得到的高精度模型后，统计权重和激活值的动态范围和量化参数（q-parms）后，再进行量化操作
• 分为 2 个量化阶段：1) 量化权重，这个很简单，因为权重可以直接被访问，所以可以很轻松计算得到其分布；2) 量化激活，这个比较麻烦，因为必须使用实际输入数据才能测出其分布
• 校准 (Calibration)： 在量化激活时，输入代表性数据集，获得层间激活分布的过程
• 训练得到模型后再进行量化，按照是否提前确定激活值量化参数，又分为静态量化：提前通过校准确定量化参数；动态量化：前向推理过程中动态计算量化参数

量化感知 (QAT)：

• 训练后量化 (PTQ) 有时候出现无法接受的精度损失，这时候就需要使用量化感知训练 Quantization Aware Training (QAT)，它的主要思想是：在训练阶段包含加入量化算子，训练时学习量化参数，使得网络可以适应量化后的权值与激活
• 通过在训练图中插入量化操作 (Q) 和反量化操作 (DQ)，实现将量化误差包含在网络中，以使得 量化参数 更加符合网络，减少精度损失

训练后量化核心过程的是校准，比较简单，量化感知训练涉及训练过程，比较复杂，我们来看看是怎么回事

• QAT 量化中最重要的就是 fake 量化算子，fake 算子负责将输入该算子的参数和输入先量化后反量化，然后记录这个 scale
• 上图原始网络精度是 FP32，输入和权重因此也是 FP32
• FQ (fake-quan) 算子会将 FP32 精度的输入和权重转化为 INT8 再转回 FP32，记住转换过程中的尺度信息
• FQ (fake-quan) 算子在 ONNX 中可以表示为 QDQ 算子

在带量化算子的 pytorch 模型转为 onnx 后，模型中会带有 Q/DQ 的算子，那么在 tensorrt 部署框架如何使用这个模型呢？

• 输入 X 是 FP32 类型的 op，输出是 FP32，在输入 A 这个 op 时会经过 Q（即量化）操作，这个时候操作 A 我们会默认是 INT8 类型的操作，A 操作之后会经过 DQ（即反量化）操作将 A 输出的 INT8 类型的结果转化为 FP32 类型的结果并传给下一个 FP32 类型的 op
• 有了 QDQ 信息，TensorRT 在解析模型的时候会根据 QDQ 的位置找到可量化的 op，然后与 QDQ 融合（吸收尺度信息到 OP 中）
  

在 tensorrt 优化这个 Q/DQ 操作的方式很多，比如 QDQ-ONNX 网络在输入到 TensorRT 中的时候，TensorRT 的算法会 propagate 整个网络，根据一些规则适当移动 Q/DQ 算子的位置，（需要尽可以拼凑出 QDQ 结构，使整个网络尽可能多的 op 变为量化算子）然后再执行 QDQ 融合策略

然后尽可能将 DQ 算子推迟，推迟反量化操作 ± 尽可能将 Q 算子提前，提前量化操作

参考：

1. Site Unreachable

本文该方法首先对大分辨率图片进行重叠切割，这一步骤允许我们更细致地处理图像的每个部分，避免了因缩放而丢失小目标的问题。随后，利用多线程技术并行处理各个分块，显著提升了处理速度。在此基础上，应用 AI 技术对每个分块进行快速而准确的识别，确保了识别的精度。最终，通过智能的结果融合策略，将各个分块的识别结果综合起来，不仅提高了识别的准确性，也增强了系统的鲁棒性。

思路

本发明提供一种大分辨率图片下的多类别多目标识别方法，包括以下步骤：

1. 重叠切割： 在处理大分辨率图片时，我们首先采用重叠切割的方法。这种策略的引入是为了解决目标在图像边缘被切割导致 AI 无法学习的问题。以 14400x10800 像素的图片为例，我们将图片划分为 1024x1024 像素的块，同时保证每个块在上下左右方向上具有 20% 的重叠区域。这样的设计确保了即使目标对象位于图像的边缘，也能在至少一个分块中完整呈现。通过这种方法，我们最终能够从原始图像中切出 235 张具有重叠区域的图片，为后续的 AI 识别提供了更加精确的输入数据。
2. 训练 AI 识别器：在完成图片的重叠切割之后，接下来的任务是对这些小图进行 AI 识别器的训练。我们选择 YOLOv10 模型作为识别器，该模型以其在目标检测任务中的速度和精度而著称。通过在切割后的小图上进行训练，YOLOv10 能够学习到多类别多目标的特征，从而在小图上实现高效的目标识别。这一步骤是实现快速且准确识别的关键，为后续的多线程并行处理打下了坚实的基础。
3. 多线程识别大图：利用多线程技术，我们可以显著提高大图的识别效率。在这一步骤中，我们将利用多线程快速处理切割后的图片块，同时并行地应用训练好的 AI 识别器对每个分块进行分析。这种方法不仅能够充分利用现代多核处理器的计算能力，还能够大幅度缩短整体的处理时间，实现对大分辨率图片的快速响应。
4. 多目标识别结果融合：最后，为了解决由于重叠切割带来的重复识别问题，我们采用了非极大值抑制（Non-Maximum Suppression, NMS）算法。在这一步骤中，我们根据目标识别的置信度对结果进行筛选和融合。通过比较不同分块中识别到的同一目标，我们保留置信度最高的结果，并抑制其他低置信度的识别，从而有效减少重复识别，提高识别的准确性。这一融合过程是确保最终结果既精确又一致的关键环节。

创新点
原始的 nms 直接按照预测打分排序预测框，然后使用 iou 过滤重叠框，这就要求对 “预测打分” 有足够自信，所谓足够自信，就是相信模型输出 “好预测框的分数” 比 “次一些的预测框分数” 高，这在单图优化确实可以做到。比如下图，假设图片有目标 A、B、C，其中红色框是标注的真实框，目标 A 的预测框有 2 个，分别标为 1、2，可以看出预测框 2 比 1 号预测框好。神经网络学习的目的是计算预测框和真实框的距离，然后再更新网络，所以预测框 2 比预测框 1 的距离更小，网络学习使得预测框 2 与预测框 1 的预测分数有竞争排斥关系，即预测框 2 越来越接近真实框，所以其分数越来越高，预测框 1 越来越远离真实框，其分数越来越低，这样最后才能通过高分数选择高质量的预测结果，因此可以得出结论：网络学习目的是输出越来越准确的预测框，并给出越来越高的预测分数。

有了这个结论，可以认为当模型对同一目标进行预测时，预测分数越高其预测框越准确，那么就可以使用 nms 对选择高预测分数的预测框，过滤掉预测分数低的，但是这个传统的目标检测处理后处理方式在大分辨率重叠预测上不适用。

假设图片进行重叠切图时，切图边缘刚好经过目标，图片 R1 只包含部分目标 A，R2 包含整体目标，网络训练时 R1、R2 图片分别进行，神经网络并不知道这两个目标是来自大图同一目标的不同部分，所以他们分数没有竞争排斥关系，所以网络学习的目的是各自推高框 1、框 2 的预测分数。这样会带来一个问题，预测框 1 只有一小部分，更容易学习，其预测分数比预测框 2 的预测分数更高，直接使用 nms 会过滤掉预测框 2，但是明显我们需要的是预测框 2。

关于使用框融合的问题，还是以上图为例，实际上预测框 2 已经接近真实框，如果预测框 1 和预测框 2 进行加权平均，其预测框效果更差，如果有多个类似预测框 1 时，效果就是靠近预测框 1，这还是无法实现 “保留预测框 2、过滤预测框 1” 的目的。

再回头思考一下，造成 nms 无法使用的原因是重叠切图带来的目标在不同图像块上多次预测，由于不同图像块的预测分数没有竞争排斥关系，所以分数最高的预测框不一定是框得最准的。既然是重叠切图造成的，那修改 nms，确保预测框面积较大的结果被保留，过滤面积较小，实践效果如下：

图片 1、2、3 分别是未进行 nms、根据预测分数进行 nms、根据面积进行 nms，从 1 可知着色区域的目标有两个预测结果，根据预测分数 nms 得到的框，预测分数更高，但是并没有框住目标，而根据面积进行 nms 的预测框虽然预测分数低一点，但是更贴合目标。

更进一步，使用面积替代预测分数选择预测框，能解决问题的原因是：假定任何目标在重叠切图下，必定有一个切块存在完整目标（预测面积最大的），如果存在一个大目标，横跨多个切图时，比如下图，切图 R1、R2 都无法预测到完整目标，只使用面积 nms 会从预测框 1 或预测框 2 选择其中一个或者认为有两个预测框，这都是不准确的。实际上，这里应该使用框融合，融合 2 个小框为 1 个大框。那么什么情况下只使用面积 nms，什么情况下使用框融合呢？

本文通过计算 “重叠面积对待分析预测框面积占比 “的后处理方式，下面分小目标和大目标情况进行讨论，小目标的预测框 1、2 的重叠区域占各自面积百分比为 100%，40%，预测框 1 占比为 100%，这时按照面积 nms 过滤即可；大目标的预测框 1、2 的重叠区域占各自面积百分比为 30%，40%，说明两个框很大部分没重叠，此时使用 WBF 对这两个框进行融合。

实践证明，加入 “重叠面积对待分析预测框面积占比” 的阈值后，可以解决单纯面积阈值过滤方式的两个问题，一是重叠时 nms 的 IOU 阈值大于实际 IOU 导致无法过滤的情况，如下图，标号 1、2、3 分别是无 nms、面积 nms、面积 nms+“重叠面积对待分析预测框面积占比” 阈值，从标号 1 看出，AI 输出 3 个检测框，从标号 2 可以看出，由于计算的 IOU 小于 nms 的过滤 IOU 阈值，所以有一个重叠框没被过滤，在使用 “重叠面积对待分析预测框面积占比” 阈值后，内部的预测框被过滤。

还有一个优势是，重新组合预测框提升框的准确度，如下图标号 1、2、3 分别是无 nms、面积 nms、面积 nms+“重叠面积对待分析预测框面积占比” 阈值，从标号 1 可以看出，AI 输出 2 个预测框，仅使用面积过滤，只能过滤一个框，使用 “重叠面积对待分析预测框面积占比” 阈值后，对这两个框进行重新组合，得到一个新的框，新的框更加准确框住目标。

所以，总结基于大分辨率下的 nms 思路如下：待分析框被保留认为 AI 预测了 2 个目标的检测框，而不是 1 个目标的重叠框，框融合使用取确认保留框与待分析框的横纵座标最小最大值即可，假设确认保留框的左上角和右下角座标为$x_1^{LT},y_1^{LT},x_1^{BR},y_1^{BR}$，待分析框的左上角及右下角座标为$x_2^{LT},y_2^{LT},x_2^{BR},y_2^{BR}$，那么框融合后座标变为

$$min(x_1^{LT},x_2^{LT}),{\min(y}_1^{LT},y_2^{LT}),{max(x}_1^{BR},x_2^{BR}),{max(y}_1^{BR},y_2^{BR})$$

效果

本文提出的大分辨率图片下的多类别多目标识别方法大大提高识别效率及识别精度，在对某一张包含 100 以上目标的 14400x10800 分辨率的图片分析实践中，使用模板匹配的技术耗时 5 分钟，识别准确率只有 60%，而直接在大图上使用 AI 的技术耗时 1 分钟，识别准确率达到 85%，而采用本文的技术，可以在 5 秒内实现 98% 以上的识别效果，在速度和精度上超越现有方法。

Torch-TensorRT 是 PyTorch 的推理编译器，通过 NVIDIA 的 TensorRT 深度学习优化器，运行时以 NVIDIA GPU 为目标。 它通过界面支持即时 （JIT） 编译工作流以及预先 （AOT） 工作流。 Torch-TensorRT 无缝集成到 PyTorch 生态系统中，支持将优化的 TensorRT 代码与标准 PyTorch 代码混合执行。

由于 Torch-TensorRT 接受 torchScript 输入，优化后输出 ts 模型，所以下文将从 pytorch\ptq\qat 三个方向测试 Torch-TensorRT

为了评估量化水平，我们定义一个评估函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# Helper function to benchmark the model
def benchmark(model, input_shape=(1024, 1, 32, 32), dtype='fp32', nwarmup=50, nruns=800):
    input_data = torch.randn(input_shape)
    input_data = input_data.to("cuda")
    if dtype=='fp16':
        input_data = input_data.half()
        
    with torch.no_grad():
        for _ in range(nwarmup):
            features = model(input_data)
    torch.cuda.synchronize()
    timings = []
    with torch.no_grad():
        for i in range(1, nruns+1):
            start_time = time.time()
            output = model(input_data)
            torch.cuda.synchronize()
            end_time = time.time()
            timings.append(end_time - start_time)
    print('Average batch time: %.2f ms,median:%2f-%2f:'%(np.mean(timings)*1000,

base->TorchScript->Torch_tensorRT

基于原始的 pth，编译为 torchscript，然后再使用 Torch_tensorRT 优化

首先导入 pth 模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

import torch
from modelingv2.deeplab import DeepLab
model=DeepLab(in_channels=3,num_classes=2,pretrained=False)
model = model.cuda()
# mobilenetv2_base_ckpt is the checkpoint generated from Step 2 : Training a baseline Mobilenetv2 model.
ckpt = torch.load("./models/deeplabv3plus_base.pth")
modified_state_dict={}
for key, val in ckpt.items():
    # Remove 'module.' from the key names
    if key.startswith('module'):
        modified_state_dict[key[7:]] = val
    else:
        modified_state_dict[key] = val
# Load the pre-trained checkpoint
model.load_state_dict(modified_state_dict)
model = model.cuda()

其次，导出为 torchscript

1
2
3
4
5
6
7

# Exporting to TorchScript
with torch.no_grad():
    data = iter(train_dataloader)
    images, _ = data.next()
    jit_model = torch.jit.trace(model, images.to("cuda"))
    torch.jit.save(jit_model, "models/deeplabv3plus_base.jit.pt")
benchmark(jit_model, input_shape=(16, 3, 512, 512), nruns=100)

最后使用 Torch_tensorRT 优化

1
2
3
4
5
6
7
8
9
10

#Loading the Torchscript model and compiling it into a TensorRT model
baseline_model = torch.jit.load("models/deeplabv3plus_base.jit.pt").eval()

compile_spec = {"inputs": [torch_tensorrt.Input([4, 3, 512, 512])],
                "enabled_precisions": torch.float,
                "truncate_long_and_double": True
               }
trt_base = torch_tensorrt.compile(baseline_model, **compile_spec)
torch.jit.save(trt_base, "models/deeplabv3plus_base_trt.ts")
benchmark(trt_base, input_shape=(16, 3, 512, 512), nruns=100)

base->ptq->TorchScript->Torch_tensorRT

首先导入 pth 模型，并使用 pytorch_quantization 进行量化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

quant_modules.initialize()
q_model=DeepLab(in_channels=3,num_classes=2,pretrained=False)
q_model = q_model.cuda()
ckpt = torch.load("./models/deeplabv3plus_base.pth")
modified_state_dict={}
for key, val in ckpt.items():
    # Remove 'module.' from the key names
    if key.startswith('module'):
        modified_state_dict[key[7:]] = val
    else:
        modified_state_dict[key] = val
# Load the pre-trained checkpoint
q_model.load_state_dict(modified_state_dict)

def compute_amax(model, **kwargs):
    # Load calib result
    for name, module in model.named_modules():
        if isinstance(module, quant_nn.TensorQuantizer):
            if module._calibrator is not None:
                if isinstance(module._calibrator, calib.MaxCalibrator):
                    module.load_calib_amax()
                else:
                    module.load_calib_amax(**kwargs)
    model.cuda()

def collect_stats(model, data_loader, num_batches):
    """Feed data to the network and collect statistics"""
    # Enable calibrators
    for name, module in model.named_modules():
        if isinstance(module, quant_nn.TensorQuantizer):
            if module._calibrator is not None:
                module.disable_quant()
                module.enable_calib()
            else:
                module.disable()
    # Feed data to the network for collecting stats
    for i, (image, _) in tqdm(enumerate(data_loader), total=num_batches):
        model(image.cuda())
        if i >= num_batches:
            break
    # Disable calibrators
    for name, module in model.named_modules():
        if isinstance(module, quant_nn.TensorQuantizer):
            if module._calibrator is not None:
                module.enable_quant()
                module.disable_calib()
            else:
                module.enable()
# Calibrate the model using max calibration technique.
with torch.no_grad():
    collect_stats(q_model, train_dataloader, num_batches=20)
    compute_amax(q_model, method="max")
    # compute_amax(q_model, method="entropy")
    # compute_amax(q_model, method="percentile")
    # compute_amax(q_model, method="mse")

with torch.no_grad():
    collect_stats(q_model, val_dataloader, num_batches=20)
    compute_amax(q_model, method="max")

其次，导出为 torchscript

1
2
3
4
5
6
7
8
9

quant_nn.TensorQuantizer.use_fb_fake_quant = True

# Exporting to TorchScript
with torch.no_grad():
    data = iter(train_dataloader)
    images, _ = data.next()
    jit_model = torch.jit.trace(q_model, images.to("cuda"))
    torch.jit.save(jit_model, "models/deeplabv3plus_ptq.jit.pt")
benchmark(jit_model, input_shape=(16, 3, 512, 512), nruns=100)

最后使用 Torch_tensorRT 优化

1
2
3
4
5
6
7
8
9

#Loading the Torchscript model and compiling it into a TensorRT model
ptq_model = torch.jit.load("models/deeplabv3plus_ptq.jit.pt").eval()

compile_spec = {"inputs": [torch_tensorrt.Input([4, 3, 512, 512])],
                "enabled_precisions": torch.int8,
               }
trt_ptq = torch_tensorrt.compile(ptq_model, **compile_spec)
torch.jit.save(trt_base, "models/deeplabv3plus_ptq_trt.ts")
benchmark(trt_ptq, input_shape=(16, 3, 512, 512), nruns=100)

ptq->qat->TorchScript->Torch_tensorRT

首先使用 qat 优化模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

def train(model, dataloader, crit, opt):
    model.train()
    for batch, (data, labels) in enumerate(dataloader):
        data, labels = data.cuda(), labels.cuda()
        opt.zero_grad()
        outputs = model(data)
        loss = Focal_Loss(outputs, labels)+Dice_loss(outputs, labels)
        loss.backward()
        opt.step()

crit=torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(),lr=1e-4,weight_decay=0.9)
q_model=q_model.train()
# Finetune the QAT model for 2 epochs
num_epochs=10
for epoch in range(num_epochs):
    print('Epoch: [%5d / %5d]' % (epoch + 1, num_epochs))
    train(q_model, train_dataloader, crit, optimizer)
    test_loss,acc = evaluate(q_model, val_dataloader, crit)
    print("Test Loss: {:.5f} Test acc {:.2f}%".format(test_loss,acc*100))

其次，导出为 torchscript

1
2
3
4
5
6
7
8
9
10

quant_nn.TensorQuantizer.use_fb_fake_quant = True
q_model=q_model.eval()

# Exporting to TorchScript
with torch.no_grad():
    data = iter(train_dataloader)
    images, _ = data.next()
    jit_model = torch.jit.trace(q_model, images.to("cuda"))
    torch.jit.save(jit_model, "models/deeplabv3plus_qat.jit.pt")
benchmark(jit_model, input_shape=(16, 3, 512, 512), nruns=100)

最后使用 Torch_tensorRT 优化

1
2
3
4
5
6
7
8
9

#Loading the Torchscript model and compiling it into a TensorRT model
qat_model = torch.jit.load("models/deeplabv3plus_qat.jit.pt").eval()

compile_spec = {"inputs": [torch_tensorrt.Input([4, 3, 512, 512])],
                "enabled_precisions": torch.int8
               }
trt_qat = torch_tensorrt.compile(qat_model, **compile_spec)
torch.jit.save(trt_base, "models/deeplabv3plus_qat_trt.ts")
benchmark(trt_base, input_shape=(16, 3, 512, 512), nruns=100)

耗时汇总

总结以上 3 个流程的耗时如下

Modular RAG 是具有⾼度扩展的范式，它将 RAG 系统拆分为 Molule Type (Indexing) - Module (Chunk/Structrural)-Operator (…) 的三层结构

![[认识 ModularRAG-20250123114804.png]]

有了以上这些 Operator，既可以组合出不同的 RAG 应用，常用的有以下：

1. Sequential

线性的结构的 RAG Flow，模块线性的组织成流⽔线，如果拥有 Pre-Retrieval 和 Post-Retrieval 两个 Module Type，则是典型的 Advanced RAG 范式，如果去掉则是典型的 Naive RAG 范式。

![[NextRAG-20250115222238.png]]

Sequential 是⽬前使⽤最多的 RAG Pipeline，其中在最常使⽤的搭配如下，在检索前增加 Query Rewrite，在检索后增加 Rerank 的算⼦。例如 QAnything。

![[NextRAG-20250115222238-1.png]]

Rewrite-Retrieve-Read (RRR) 也是典型的序列结构。其中 jQuery Rewrite 模块是⼀个⼩型的可训练的语⾔模型，并通过最终 LLM 的输出结果作为奖励。在强化学习的背景下，重写器优化被形式化为⼀个⻢尔科夫决策过程。检索器选⽤了稀疏编码器 BM25。

![[NextRAG-20250115222239.png]]

2. Conditional

条件结构的 RAG Flow，根据不同的条件选择不同的 RAG 路线。通常由⼀个 Routing 模块进⾏路由，判断依据包括通常包括 Query 的关键词或语义。路由到不同的路线，通常根据问题的类型，适⽤的场景路由到不同的 Flow 中。例如当⽤户提问到严肃的问题，政治问题或是娱乐问题，对⼤模型幻觉的容忍度是不同的。不同路由分⽀通常在检索源、检索流程、配置信息、模型选择和 Prompt 上进⾏差异化。

![[NextRAG-20250115222240.png]]

⼀个 Conditional RAG 的经典 Implementation 是 semantic Router。

3. Branching

分⽀结构的 RAG Flow。不同于 Conditional 中是要在多条分⽀中选择⼀条，Branching 则是有多个分⽀并⾏。从结构上可以分成两类：

• 检索前分⽀ (Multi-Query, Parallel Retrieval)。对原始 Query 进⾏扩展，得到多个⼦ Query，然后对每⼀个⼦ Query 分别进⾏检索，检索后就可以选择⽴即根据⼦问题和对应检索来的内容⽣成答案，也可以只使⽤拓展检索出来的内容最后合并到统⼀上下⽂中进⾏⽣成。
• 检索后分⽀ (Single Query, Parallel Generation)。保持原来的 Query，检索到多个⽂档块后，并⾏使⽤原始 Query 和每⼀个⽂档块进⾏⽣成，最后将⽣成的结果合并到⼀起。

![[NextRAG-20250115222240-1.png]]

REPLUG 就是⼀个典型的检索后分⽀的分结构，根据每⼀个分⽀预测 token 的概率，通过 Weighted possibilityEnsemble 将不同的分⽀聚合，并通过最后⽣成结果作作为反馈微调检索器 Contriever。

![[NextRAG-20250115222241.png]]

4. Loop

具有环状结构的 RAG Flow，这也是的 Modular RAG 的⼀个重要特点，检索和推理步骤相互影响的。通常包括⼀个 Judge 模块，⽤于控制流程。具体⼜可以分成迭代、递归和主动检索三种。

![[NextRAG-20250115222242.png]]

5.  Iterative Retrieval

有时候单次检索和⽣成的并不能很好的解决⼀些需要⼤量知识的复杂的问题。因此可以使⽤迭代的⽅式进⾏ RAG, 通常来说迭代检索都有⼀个固定的迭代次数。迭代检索⼀个典型的案例是是 ITER-RETGEN。

在每次迭代中，ITER-RETGEN 利⽤前⼀次迭代的模型输出作为特 定上下⽂，帮助检索更相关的知识，这可能有助于改进模型⽣成。循序的终⽌通过预设的迭代次数来判断。

![[NextRAG-20250115222243.png]]

6. Recursive Retrieval

不同于迭代检索，递归检索的特点是有明显依赖上⼀步并不断深⼊的检索。通常有判断机制作为递归检索的出口。在 RAG 系统中，递归检索的通常要搭配 Query Transformation，每次检索时依赖于新改写后的 Query。

⼀个典型的递归检索实现例如 ToC。从初始问题 (Ambiguous Question,AQ) , 通过递归执⾏ RAC（递归澄清⽅法，Retrieval-Augmented Clarification）逐步插⼊⼦节点到澄清树中，在每个扩展步骤中，根据当前查询重新对段落进⾏重新排名并⽣成⼀个 (Disambiguous Question,DQ)。树的探索在达到了最⼤数量的有效节点或最⼤深度时结束。构建了澄清树后，TOC 收集所有有效节点并⽣成⼀个全⾯的⻓⽂本答案来回答 AQ。

![[NextRAG-20250115222244.png]]

7. Adaptive (Active) Retrieval

随着 RAG 的发展，逐步超越被动的检索的⽅式，出现了⾃适应的检索（也被称作主动检索），这⼀⽅⾯也是受益于 LLM 的强⼤能⼒。在核⼼思想上与 LLM Agent 相似。

RAG 系统可以主动判断的检索时机，以及判断时候结束整个流程，输出最终的结果。根据判断的依据，⼜可以分成和 Prompt-base 和 Tuning-base。

• **Prompt-base.** 通过 Prompt Engineering 的⽅式让 LLM 对流程进⾏控制。⼀个典型的实现案例是 FLARE。它的核⼼思想是 LM 应该仅在缺乏所需知识时进⾏检索，以避免被动检索增强的 LM 中出现不必要或不适当的检索。FLARE 迭代地⽣成下⼀个临时句⼦，并检查是否包含低概率标记。如果是这样，系统将检索相关⽂档并重新⽣成句⼦。

![[NextRAG-20250115222244-1.png]]

• Tuning-base. 对 LLM 进⾏微调使其⽣成特殊的 token，以此来触发检索或⽣成。这种思想可以追溯到 Toolformer 中，通过⽣成特俗的内容，来辅助调⽤⼯具。在 RAG 系统中则是⽤于控制检索和⽣成两个步骤。⼀个典型的案例是 Self-RAG。具体⽽⾔，

（1）给定⼀个输⼊提示，和前⾯的⽣成结果，⾸先预测特殊 token “Retrieve" 判断是否通过检索段落对继续的⽣成进⾏增强是有帮助。
（2）如果有帮助，调⽤检索模型。模型会⽣成⼀个 critique token 来评估检索段的相关 性，下⼀个响应⽚段，和⼀个批判令牌来评估响应⽚段中的信息是否得到了检索段的⽀持。
（3）最后，⼀个新的批判令牌评估响应的整体效⽤。模型会并⾏处理这些内容，并选择最佳结果作为最终的输出。

![[NextRAG-20250115222245.png]]

最佳行业案例

OpenAI

从 OpenAI Demo day 的演讲整理所得，并不能完全代表 OpenAI 的实际操作。在提升 RAG 的成功案例中，OpenAI 团队从 45% 的准确率开始，尝试了多种⽅法并标记哪些⽅法最终被采⽤到⽣产中。他们尝试了假设性⽂档嵌⼊（HyDE）和精调嵌⼊等⽅法，但效果并不理想。通过尝试不同⼤⼩块的信息和嵌⼊不同的内容部分，他们将准确率提升到 65%。通过 Reranking 和对不同类别问题特别处理的⽅法，他们进⼀步提升到 85% 的准确率。最终，通过提示⼯程、查询扩展和其他⽅法的结合，他们达到了 98% 的准确率。团队强调了模型精调和 RAG 结合使⽤时的强⼤潜⼒，尤其是在没有使⽤复杂技术的情况下，仅通过简单的模型精调和提示⼯程就接近了⾏业领先⽔平。

![[NextRAG-20250115222248.png]]

Baichuan

基于百川的宣传资料整理（查看原⽂)。针对⽤户⽇益复杂的问题，百川借鉴了 Meta 的 CoVe 技术，将复杂 Prompt 拆分为多个独⽴且可并⾏检索的搜索友好型查询。利⽤⾃研的 TS（Think-Step Further) 技术来推断和挖掘⽤户输⼊背后更深层的问题，以更精准、全⾯地理解⽤户意图。在检索步骤中，百川智能⾃研了 Baichuan-TextEmbedding 向量模型。同时引⼊稀疏检索和 rerank 模型（未披露），形成向量检索与稀疏检索并⾏的混合检索⽅式，⼤幅提升了⽬标⽂档的召回率。此外还引⼊了 self-Critique 让⼤模型基于 Prompt、从相关性和可⽤性等⻆度对检索回来的内容⾃省，进⾏⼆次查看，从中筛选出与 Prompt 最匹配、最优质的候选内容。

![[NextRAG-20250115222249.png]]

DatDatabricks

作为⼤数据领域中领先的服务商，在 RAG 设计上依然保持了⾃⼰特点和优势（查看原⽂）。⽤户输⼊问题，通过从事先处理好的⽂本向量索引⾥⾯获取问题相关信息，加上提示词⼯程，⽣成回答。上半部分 Unstructured Data pipeline 就输主流的 RAG ⽅法，并没有特殊之处。

![[NextRAG-20250115222249-1.png]]

下半部分为 Structured Data Pipeline，是 Databricks 特征⼯程处理流程，也是 Databricks RAG 最⼤的特点。Databricks 从⾃身专业的⼤数据⻆度出发，从原来的准确度较⾼的数据存储中进⾏额外的检索，充分发挥⾃身在 Real Time Data Serving 上的优势。可以看到 Databricks 在 GenAI 时代的策略是助具有⼴泛市场需求的 RAG 应⽤，将⾃身强⼤的 Lakehouse 数据处理能与⽣成式 AI 技术深度融合，构建出⼀体化解决⽅案。abricks

参考：

1. Advanced RAG Techniques: What They Are & How to Use Them
2. 技术动态 | 模块化（Modular）RAG 和 RAG Flow-CSDN 博客
3. Site Unreachable

回答方式

RAG 针对多个检索文本，有不同的利用方式，可归纳为以下 3 种：

self-RAG

因为使用 llm，这个过程设计 prompt，所以很多 prompt 的技巧可以使用到这里，包括思维链等技术

甚至将 Agent 引入 llm，自动判断答案与问题的相关性，然后调整自己后续的行动，Self-RAG 就是这种技术，该模型不仅依赖于初始检索，而且通过生成后续查询和响应来主动重新评估和调整其方法。此迭代过程允许模型纠正自己的错误、填补空白并提高最终输出的质量

评估

针对 llm 生成的答案，评估答案的准确性，一般分为两种：

• 人工评估：评估答案是否响应了问题，以及和利用上下文的水平
• 模型评估：使用 llm 模型来评估答案，甚至可以使用 llm 生成 (问题、上下文、回答) 的三元组，然后通过比较问题与答案，自动评估模型性能

Rerank

根据文档与查询的相关性对文档进行排序，使用 reranker 模型重新排序检索结果

rerank 有两种规则实现文档排序

• ReRank-Rulebase：计算指标以重新排列块根据某些规则。常见的指标包括：多样性，相关性和 MRR（最大边际相关性）
• ReRank-Modelbase：专门的 AI 模型 (Rerank 模型)，用于评估这些检索到的文档与用户查询相关的相关性并确定其优先级

Compression

RAG 中的一个常见误解该过程是指尽可能多地检索相关文档并将其连接起来，形成一个冗长的文档检索提示是有益的。然而，过度的上下文可能会引入更多噪音，降低 LLM 对关键信息。解决这一问题的一种常见方法是压缩并选择检索到的内容

Selection

对于 self-Query retrieval 来说，在利用文档时，还可以根据用户查询与文档元数据过滤检索结果

CRAG 则引入了一个轻量级检索评估器，用于评估检索到的文档的整体质量，提供触发不同知识检索操作（如 “正确”、“不正确” 或 “模糊”）的置信度

CRAG 还可以通过合并 Web 搜索来确定检索到的结果是否相关，从而解决静态语料库中的限制

BM25（Best Matching 25）是一种用于信息检索的算法，广泛应用于搜索引擎和文本挖掘领域。它是对 TF-IDF（词频 - 逆文档频率）模型的改进，主要通过引入文档长度归一化和词频饱和机制，更准确地评估文档与查询之间的相关性

原理

1. 逆文档频率（IDF）
   用于衡量一个词的 “稀有性”。如果一个词在较少的文档中出现，其 IDF 值越高，表明这个词具有更好的区分能力。

$$IDF(q_i) = \log \left( \frac{N - n(q_i) + 0.5}{n(q_i) + 0.5} \right)$$

其中，N 是文档总数，n (qi​) 是包含词 qi​ 的文档数

2. 词频（TF）调整
   BM25 引入了词频饱和机制，避免长文档因词频过高而获得不合理的高分

$$BM25(q_i,d) = \text{IDF}(q_i) \cdot \frac{(k_1 + 1) \cdot \text{TF}(q_i,d)}{\text{TF}(q_i,d) + k_1 \cdot (1 - b + b \cdot \frac{d}{\text{avgdi}})}$$

其中 $TF(q_i,d)$ 表示词汇 qi 在文档 d 中出现的次数，k1 和 b 是可调参数，|d | 是文档长度，avgdl 是文档平均长度

3. 文档长度归一化
   BM25 通过文档长度归一化处理，使得文档长度对权重的影响是非线性的。这避免了长文档仅因词数多而得分更高的问题，即以上公式的 $\frac{d}{\text{avgdi}}$

4. 查询与文档的相关性
   对于一个查询 Q 和文档 d，BM25 的最终得分是查询中每个词与文档相关性的累加

$$BM25(Q,d) = \sum_{i=1}^{n} BM25(q_i,d)$$

n 表示 Q 中的词汇数量

例子

假设我们有以下文档集合（3 篇文档）和一个查询：

文档集合：

1. 文档 D1："苹果 苹果 苹果"（3 个词，文档长度为 3）
2. 文档 D2："苹果"（1 个词，文档长度为 1）
3. 文档 D3："苹果 香蕉"（2 个词，文档长度为 2）

查询 Q："苹果"

1. 计算 IDF
   首先，我们需要计算查询词 “苹果” 的逆文档频率（IDF）

$$IDF ("苹果") 的 \log \left ( \frac {3 - 3 + 0.5}{3 + 0.5} \right) = \log \left ( \frac {0.5}{3.5} \right) = \log (0.1429) \approx -1.90$$

注意：这里的 IDF 值是负数，因为 “苹果” 在所有文档中都出现了。在实际应用中，IDF 通常取正值，可以通过调整公式或对结果取绝对值来处理。

2. 计算文档长度相关参数

接下来，计算文档长度相关的参数

$$avgdl = \frac{D1 + D2 + D3} {3} = \frac{3 + 1 + 2}{3} = 2$$

3. 计算 BM25 分数
   假设参数 k1​=1.2 和 b=0.75，我们分别计算每个文档的 BM25 分数

注：实际情况，查询 Q 可能包含多个词汇