链载Ai

标题: 引入GraphRAG的场景条件分析 [打印本页]

作者: 链载Ai    时间: 12 小时前
标题: 引入GraphRAG的场景条件分析

在讨论GraphRAG并审阅本文之前,我们想了解一下GraphRAG的概念

什么时候使用GraphRAG

G-Retriever是如何工作的?

1.索引

本段描述了在GraphRAG中,将数据进行精炼和存储,以便事先方便使用的过程。要在提前使用时使用的信息,指的是图中节点和边的属性中所包含的文本信息。为了将此信息转换为可量化的数值,使用了语言模型。

2.检索

本段讨论了根据数据与用户查询相关性的过程来测量和检索数据。为了评估相关性,语言模型评估了“查询”与图中“节点”和“边”值之间的相似度,利用K最近邻算法进行此目的。

3.子图构建

与其他用于检索文件的RAG(检索增强生成)模型不同,GraphRAG 需要获取与用户查询相关的图形。在初始检索过程中,仅仅将用户文本与图形文本进行比较以获取信息,不能严格利用图形连接的语义。

为了加以利用,有必要评估每个节点和边与用户查询的语义相似度。在这种评估中,使用了PCST(奖励收集斯坦纳树)方法。

简单解释一下 PCST 方法:节点和边都被分配奖励。这些奖励的价值是通过使用节点和边与用户查询之间的排名相似性来确定的,在较早的检索过程中确定。与查询相似的节点将获得更高的奖励,而不相似的节点可能获得较低或甚至为零的值。

总结在相连的节点和边中的奖励,提取出总值较高的节点和边。这个总值代表具有最高总和的节点和边。为了管理子图的大小,使用一个称为“成本”的参数来预先确定要分配给每条边的惩罚,有效控制子图大小。

最终,这个过程提取包含与用户查询类似信息的子图,同时通过成本参数管理子图大小。

4.答案生成

本段描述了通过将文本嵌入值与图表嵌入值相结合来生成查询的答案的过程。在这里,文本嵌入值指的是来自预训练语言学习模型(LLM)的自注意层的值,这些值保持冻结,意味着它们的权重在训练过程中不会更新。

通过利用用于训练的图表嵌入值,它利用了先前提到的软提示技术,该技术涉及提取和更新优化的权重值,以将语义纳入答案产生中。

推导图嵌入值并将其与文本嵌入值结合的方法非常简单:

G-Retrieval 洞见

1.Efficiency Retrieval 效率检索

2. 架构

3. 性能

最后,在GraphRAG中我们必须牢记的是

具有解释的核心概念代码

def retrieval_via_pcst(graph, q_emb, textual_nodes, textual_edges, topk=3, topk_e=3, cost_e=0.5):
c = 0.01
if len(textual_nodes) == 0 or len(textual_edges) == 0:
desc = textual_nodes.to_csv(index=False) + '\n' + textual_edges.to_csv(index=False, columns=['src', 'edge_attr', 'dst'])
graph = Data(x=graph.x, edge_index=graph.edge_index, edge_attr=graph.edge_attr, num_nodes=graph.num_nodes)
return graph, desc

root = -1# unrooted
num_clusters = 1
pruning = 'gw'
verbosity_level = 0
if topk > 0:
n_prizes = torch.nn.CosineSimilarity(dim=-1)(q_emb, graph.x)
topk = min(topk, graph.num_nodes)
_, topk_n_indices = torch.topk(n_prizes, topk, largest=True)

n_prizes = torch.zeros_like(n_prizes)
n_prizes[topk_n_indices] = torch.arange(topk, 0, -1).float()
else:
n_prizes = torch.zeros(graph.num_nodes)

if topk_e > 0:
e_prizes = torch.nn.CosineSimilarity(dim=-1)(q_emb, graph.edge_attr)
topk_e = min(topk_e, e_prizes.unique().size(0))

topk_e_values, _ = torch.topk(e_prizes.unique(), topk_e, largest=True)
e_prizes[e_prizes < topk_e_values[-1]] = 0.0
last_topk_e_value = topk_e
for k in range(topk_e):
indices = e_prizes == topk_e_values[k]
value = min((topk_e-k)/sum(indices), last_topk_e_value-c)
e_prizes[indices] = value
last_topk_e_value = value
# cost_e = max(min(cost_e, e_prizes.max().item()-c), 0)
else:
e_prizes = torch.zeros(graph.num_edges)

costs = []
edges = []
vritual_n_prizes = []
virtual_edges = []
virtual_costs = []
mapping_n = {}
mapping_e = {}
for i, (src, dst) in enumerate(graph.edge_index.T.numpy()):
prize_e = e_prizes[i]
if prize_e <= cost_e:
mapping_e[len(edges)] = i
edges.append((src, dst))
costs.append(cost_e - prize_e)
else:
virtual_node_id = graph.num_nodes + len(vritual_n_prizes)
mapping_n[virtual_node_id] = i
virtual_edges.append((src, virtual_node_id))
virtual_edges.append((virtual_node_id, dst))
virtual_costs.append(0)
virtual_costs.append(0)
vritual_n_prizes.append(prize_e - cost_e)

prizes = np.concatenate([n_prizes, np.array(vritual_n_prizes)])
num_edges = len(edges)
if len(virtual_costs) > 0:
costs = np.array(costs+virtual_costs)
edges = np.array(edges+virtual_edges)

vertices, edges = pcst_fast(edges, prizes, costs, root, num_clusters, pruning, verbosity_level)

selected_nodes = vertices[vertices < graph.num_nodes]
selected_edges = [mapping_e[e] for e in edges if e < num_edges]
virtual_vertices = vertices[vertices >= graph.num_nodes]
if len(virtual_vertices) > 0:
virtual_vertices = vertices[vertices >= graph.num_nodes]
virtual_edges = [mapping_n[i] for i in virtual_vertices]
selected_edges = np.array(selected_edges+virtual_edges)

edge_index = graph.edge_index[:, selected_edges]
selected_nodes = np.unique(np.concatenate([selected_nodes, edge_index[0].numpy(), edge_index[1].numpy()]))

n = textual_nodes.iloc[selected_nodes]
e = textual_edges.iloc[selected_edges]
desc = n.to_csv(index=False)+'\n'+e.to_csv(index=False, columns=['src', 'edge_attr', 'dst'])

mapping = {n: i for i, n in enumerate(selected_nodes.tolist())}

x = graph.x[selected_nodes]
edge_attr = graph.edge_attr[selected_edges]
src = [mapping[i] for i in edge_index[0].tolist()]
dst = [mapping[i] for i in edge_index[1].tolist()]
edge_index = torch.LongTensor([src, dst])
data = Data(x=x, edge_index=edge_index, edge_attr=edge_attr, num_nodes=len(selected_nodes))

return data, desc

** 原始代码资源 :https://github.com/XiaoxinHe/G-Retriever

功能参数:


- `graph`: 提取子图的原始图。预计是一个PyTorch Geometric的`Data`对象。

- `q_emb`: 代表查询语义内容的查询嵌入向量。

- `textual_nodes`,`textual_edges`: 包含关于`graph`节点和边信息的Pandas DataFrames。

- `topk`,`topk_e`: 根据与 `q_emb` 相似性而考虑的顶部节点和边的数量的参数。

- `cost_e`: 包括边的解决方案中的阈值成本。

主要步骤解释:


1. **空图组件提前返回**:如果没有文字节点或边,它会立即返回原始图以及从“textual_nodes”和“textual_edges”派生的描述。

2. **初始化**:为PCST设置变量,包括根节点(在这种情况下未根化),簇数以及修剪方法。

3. **节点和边奖励计算**:

— 使用余弦相似度计算查询嵌入和图组件之间的相似度分数(节点为`n_prizes`,边为`e_prizes`)。

— 调整这些分数以确定包含每个节点或边在子图中的“奖励”。对于边,根据`cost_e`阈值进一步过滤它们。

4. **PCST图转换**:

— 通过可能引入 “虚拟” 节点并根据计算的奖励和成本调整边及其成本,将原始图转换为适合PCST的格式。

5. **PCST算法执行**:

— 在转换后的图上运行PCST算法(`pcst_fast`),以选择一组节点和边,形成基于给定奖励和成本的最佳子图。

6. **子图重建**:

— 根据PCST算法的输出提取所选节点和边。

— 使用所选组件重建子图,确保生成的子图连通且与查询相关。

7. **子图描述生成**:

— 通过将“textual_nodes”和“textual_edges”的相关部分转换为CSV格式,生成所选子图的文字描述。

8. **返回**:该函数返回重建的子图作为PyTorch Geometric `Data`对象以及其文字描述。

### Annotations for Clarity:


- **奖励计算**:节点和边的奖励来自它们与查询的语义相关性。更高的相似性得分会导致更高的奖励,表明更倾向于将这些组件包含在子图中。

- **虚拟节点和边**:引入以促进PCST算法。它们代表对原始图的结构的潜在修改,以适应奖励和成本模型。虚拟节点充当中介,根据优化过程调整连接性。

- **PCST算法**:函数的核心,`pcst_fast`,是一个外部算法,它接受转换后的带有奖励和成本的图,并识别最佳子图。这一步是实际优化发生的地方。

- **映射和重建**:在识别出最佳组件后,函数将它们映射回原始图的上下文,确保生成的子图准确表示并与查询相关。

这个函数包含了一个基于PCST模型的图优化复杂过程,旨在提取基于语义的相关子图,使其成为诸如文档摘要、信息检索和知识图探索等任务的强大工具。






欢迎光临 链载Ai (https://www.lianzai.com/) Powered by Discuz! X3.5