28、XEdge：用于 XML 关键字搜索的有效聚类结果返回方法-优快云博客

本文链接：https://blog.youkuaiyun.com/a1b2c/article/details/150622019

XEdge：用于 XML 关键字搜索的有效聚类结果返回方法

1. 引言

关键字搜索是查询 XML 数据库的一种用户友好方式，用户无需学习传达语义的查询语言，也无需了解底层数据结构就能处理查询。然而，现有的 XML 关键字搜索方法大多聚焦于近似关键字搜索，结果不尽人意，存在以下问题：
- 无意义结果 ：现有方法返回的答案要么与用户意图无关，要么不够有意义或信息不足。XML 关键字搜索引擎返回的 XML 片段包含大量无意义结果。例如，对于关键字查询“cloud computing”，在示例 XML 树中，“session(6)”就是一个无意义结果，因为匹配节点“(9)”和“(18)”不属于同一篇论文。
- 屏蔽效应 ：基于 SLCA（最小公共祖先）的方法通过排除某些 SLCA 节点来识别相关匹配，但该方法会对上层 LCA 节点产生屏蔽效应，丢弃一些相关答案。比如，对于查询“cloud computing”，包含两个关键字的节点“(23)”和“(31)”本应是正确答案，但 SLCA 方法会选择以节点“(31)”为根的较低子树，而忽略以“article(23)”为根的上层子树。
- 结果聚类 ：一个查询可能有多种搜索语义，简单的结果列表对用户帮助不大，返回聚类结果可以从不同角度解决这个问题。
- 结果排序 ：一个聚类中有多个候选答案，如何衡量每个搜索意图的相关性并对结果进行排序是一个挑战。

本文的主要贡献包括：
1. 提出聚类紧凑粒度（CCG）的概念，根据 LCA 节点之间的连接紧凑性将搜索结果划分为不同的聚类。
2. 提出子树紧凑粒度（SCG）的概念，对聚类内的单个结果进行排序并衡量查询结果的相关性。
3. 定义了紧凑 LCA（CLCA）的新语义，通过消除对有意义答案无贡献的冗余 LCA 来提高准确性，并克服 SLCA 方法的屏蔽效应。
4. 基于 CCG 和 SCG 实现聚类算法，基于 CLCA 实现排序机制，最终实现了一个高效的图算法 XEdge 来生成有意义的聚类结果。
5. 实验结果表明，与现有方法（如 XSeek 和 XKLUSTER）相比，本文提出的方法更有效。

2. 多粒度方法

2.1 聚类紧凑粒度（CCG）

链接分支（LB） ：链接分支是从顶部节点到底部节点的自上而下的路径，任意两个节点之间的链接分支长度（LLB）等于路径中的节点数量。例如，在示例 XML 树中，“journal(19)”和“article(23)”之间的 LB 是“journal(19)/issue(22)/article(23)”，LLB((19), (23)) = 3。
聚类紧凑粒度（CCG） ：给定两个以 u 和 v（u ≠ v）为根的匹配子树，它们之间的聚类紧凑粒度 CCGu,v 通过以下公式计算：
[CCG_{u,v} = \frac{LLB(u, LCA(u, v)) + LLB(v, LCA(u, v)) - 1}{DEPTH(LCA(u, v))}]
通过计算示例 XML 树中任意两个 LCA 节点之间的 CCG，可以得到一个 CCG 矩阵，如下表所示：
| Node IDs | (2) | (4) | (6) | (19) | (23) | (31) | (32) | (34) |
| — | — | — | — | — | — | — | — | — |
| (2) | 0 | 1.5 | 1.5 | 3 | 5 | 9 | 3 | 5 |
| (4) | 1.5 | 0 | 2.5 | 5 | 7 | 11 | 5 | 7 |
| (6) | 1.5 | 2.5 | 0 | 5 | 7 | 11 | 5 | 7 |
| (19) | 3 | 5 | 5 | 0 | 1.5 | 3.5 | 3 | 5 |
| (23) | 5 | 7 | 7 | 1.5 | 0 | 1.25 | 5 | 7 |
| (31) | 9 | 11 | 11 | 3.5 | 1.25 | 0 | 9 | 11 |
| (32) | 3 | 5 | 5 | 3 | 5 | 9 | 0 | 1.5 |
| (34) | 5 | 7 | 7 | 5 | 7 | 11 | 1.5 | 0 |

根据 CCG 可以将结果聚类，使得同一聚类内的 CCG 尽可能小，不同聚类间的 CCG 尽可能大，最终得到三个聚类：C1 = {(2), (4), (6)}，C2 = {(19), (23), (31)} 和 C3 = {(32), (34)}，分别代表“会议”、“期刊”和“书籍”三种不同的匹配语义。

2.2 子树紧凑粒度（SCG）

匹配子树的大小（SMS） ：给定一个以 r 为根的匹配子树 T(r)，匹配子树的大小 SMS(T(r)) 定义为从根 r 到每个匹配节点 mi 的链接分支长度之和，计算公式如下：
[SMS(T(r)) = \sum_{i = 1}^{n} |LLB(r, m_i)|]
子树紧凑粒度（SCG） ：对于一个匹配子树 T(r)，子树紧凑粒度（SCG）定义为 SMS(T(r)) 与 T(r) 根节点深度 DEPTH(r) 的百分比，计算公式如下：
[SCG(T(r)) = \frac{SMS(T(r))}{DEPTH(r)}]
SCG 越小，匹配子树的结果越有意义，应给予更高的排名。为了区分以一个 LCA 节点为根的多个匹配子树，引入了 SCGSet 表示以一个 LCA 节点为根的各种匹配子树。示例 XML 树中所有的 SCGSet 如下表所示：
| LCA 节点 | SCGSet | LCA 节点 | SCGSet |
| — | — | — | — |
| conf(2) | {4, 4} | article(23) | {1.25, 1.75, 1.75} |
| ieee cloud computing(4) | {0.25} | cloud computing explained(31) | {0.125} |
| session(6) | {1.75} | book(32) | {2.5} |
| journal(19) | {3.5, 4.5} | cloud computing (34) | {0.25} |

2.3 CCG 和 SCG 的结合

给定一组 LCA 节点，根据 CCG 理论对它们进行聚类，使同一聚类中任意两个 LCA 节点的 CCG 值尽可能小。在一个聚类内，单个 LCA 节点可能有不同的 SCG，代表不同的匹配语义。例如，在聚类 C1 = {(2), (4), (6)} 中，以节点“(4)”为根的子树排名最高，因为其 SCG 分数最小，代表“查找关于云计算的会议”这一主要搜索意图；节点“(2)”包含两个代表次要搜索意图的匹配子树，因其 SCG 分数最大，排名最低；节点“(6)”是无意义结果，应从结果中丢弃。

2.4 识别 CLCAs

摘要树（ST） ：可以建模为一棵树，每个节点 g 被视为一个由一组节点组成的组，用 g.pid[] 表示。
- g.id 由组 g 中第一个节点的标识符表示。
- g.pid[] 的每个索引值 k（k ≥ 0）对应组 g 中的一个元素节点，记为 g : k。
- g.pid[k] 指向组 gp 中的一个元素节点，gp 是组 g 的父节点，即 gp : g.pid[k] 是 g : k 的父节点。
紧凑 LCA（CLCA） ：给定一个以 r 为根的匹配子树 T(r) 和 m 个匹配节点 n1, n2, …, nm，当且仅当对于 1 < i < j < m，ni.pid[0] = nj.pid[0]，即 m 个匹配节点是同质的时，CLCA(n1, n2, …, nm) = r。

例如，对于查询“cloud computing”，“paper(9)”是一个 CLCA 节点，因为其匹配节点满足 (11).pid[0] = (13).pid[0] = 1，应被视为有意义的结果；而“paper(2)”和“paper(9)”属于不同的自上而下路径，(4).pid[0] ≠ (13).pid[0]，所以 LCA 节点“bib(1)”不是 CLCA 节点，应被丢弃。

3. XEdge 算法

3.1 推断 GRCs

基于图的结果聚类（GRC） ：给定一个 XML 文档树 T，假设 Vclca 表示 CLCA 节点的集合。基于图的结果聚类 GRC 定义为一个连通有向图 G(V, E)，满足：
1. V ⊆ Vclca；
2. 对于任意 (u, v) ∈ E，存在 v′ ∈ Vclca（v′ ≠ v），使得 CCGu,v ≤ CCGu,v′。

推断 GRC 的基本思想是在遍历数据树时进行，类似于提取最短路径。在生成过程中，边形成许多孤立的 GRC，一个连通的 GRC 代表一个唯一的聚类。GRC 的计算从任意 CLCA 节点 u ∈ Vclca 开始，每一步将具有最小 CCG 分数的边 (u, v) 添加到 GRC 中，直到所有节点 u ∈ Vclca 都被遍历。示例 XML 树中提取的 GRC 如下：

graph LR
    A(2) -->|1.5| B(4)
    C(19) -->|1.5| D(23)
    D(23) -->|1.25| E(31)
    F(32) -->|1.5| G(34)

3.2 XEdge 算法步骤

使用提出的 CCG 和 SCG 特征以及 CLCA 语义，实现了一个高效的图算法 XEdge 来生成有意义的聚类结果，具体步骤如下：
1. 给定一个在 XML 文档树 T 上的关键字查询 Q，识别候选匹配子树。
2. 返回包含所有 LCA 节点的大量匹配子树 MT(li)（li ∈ Vlca）。
3. 对于每个匹配子树 MT(li)，根据定义 6 检查 li 是否为 CLCA 节点。如果不是，将该子树从结果集中移除；否则，用于计算 SCG。
4. 计算任意两个 CLCAs 之间的 CCG，并根据定义 7 提取 GRCs。
5. 使用 SCG 特征对提取的 GRCs 进行排序，最终得到排序后的结果聚类。

这个算法不仅提高了搜索准确性，还克服了 SLCA 方法的屏蔽效应。

XEdge：用于 XML 关键字搜索的有效聚类结果返回方法

4. 实验评估

为了验证 XEdge 算法的有效性，将其与 XSeek 和 XKLUSTER 进行了比较，使用了从相关资源下载的三个真实数据集：DBLP、Mondial 和 SigmodRecord。所有算法均用 Java 实现，在配备 2GB RAM 的 2.93GHz Pentium(R) 双核 Windows 7 机器上运行。为每个数据集选择了 7 个关键字少于 5 个的查询，并使用聚类数量、精度和召回率三个指标来评估所有算法。

4.1 聚类数量

在 SigmodRecord 数据集上评估了 XEdge 和 XKLUSTER 生成的聚类数量。由于 XKLUSTER 是一个依赖距离阈值的算法，在实验中使用了不同的距离阈值（0、1.0、2.0、4.0、9.0）。实验结果如下表所示：
| 查询 | XEdge 聚类数量 | XKLUSTER 阈值 0 | XKLUSTER 阈值 1.0 | XKLUSTER 阈值 2.0 | XKLUSTER 阈值 4.0 | XKLUSTER 阈值 9.0 |
| — | — | — | — | — | — | — |
| S1 | 3 | 10 | 8 | 6 | 4 | 3 |
| S2 | 2 | 7 | 6 | 5 | 3 | 2 |
| S3 | 2 | 3 | 3 | 3 | 2 | 2 |
| S4 | 2 | 3 | 3 | 3 | 2 | 2 |
| S5 | 3 | 9 | 7 | 6 | 4 | 3 |
| S6 | 3 | 12 | 10 | 8 | 5 | 4 |
| S7 | 3 | 11 | 9 | 7 | 5 | 4 |

从表中可以看出，对于包含较少关键字的查询（如 S3 和 S4），当阈值等于 4.0 和 9.0 时，XKLUSTER 生成的结果数量与 XEdge 几乎相同。然而，对于包含较多关键字的查询（如 S1、S6 和 S7），XKLUSTER 效率不如 XEdge，因为它生成的聚类数量过多，可能包含更多无意义的结果。此外，XKLUSTER 生成的聚类数量在使用不同阈值时变化敏感，即使是相同的查询也是如此；而 XEdge 生成的聚类数量稳定且远少于 XKLUSTER。因此，XEdge 在实际应用中更有效、更具适应性。

graph LR
    classDef process fill:#E5F6FF,stroke:#73A6FF,stroke-width:2px;
    A(XEdge):::process -->|稳定且少| B(聚类数量):::process
    C(XKLUSTER):::process -->|不稳定且多| B(聚类数量):::process

4.2 方法的有效性

为了评估所提出方法的有效性，使用精度和召回率比较了 XEdge 与 XKLUSTER 和 XSeek。实验结果表明，XEdge 在精度和召回率方面显著优于这两个基线方法。具体情况如下：
- 精度方面 ：
- XEdge 在大多数查询中都能取得较高的精度。
- XKLUSTER 在除了包含两个以上关键字的查询（如 M4 - M7、D3、D4 和 D6）之外，能取得较高的精度。这是因为 XKLUSTER 在这些查询中使用了“OR”逻辑，导致更多的误报。
- XSeek 在查询 M1、M2、D1、D2、D6 和 D7 中精度较低，因为它对上层 LCA 节点有屏蔽效应。
- 召回率方面 ：
- XKLUSTER 在几乎所有给定的查询中都能取得较高的召回率。这是因为 XKLUSTER 支持“OR”逻辑，能够捕获更多的语义，因此可能输出更多有意义的结果。然而，如前面分析的，高召回率可能导致低精度，特别是在包含更多关键字的查询中。

实验结果总结如下表：
| 数据集 | 查询 | XEdge 精度 | XEdge 召回率 | XKLUSTER 精度 | XKLUSTER 召回率 | XSeek 精度 | XSeek 召回率 |
| — | — | — | — | — | — | — | — |
| Mondial | M1 | 0.8 | 0.7 | 0.6 | 0.8 | 0.4 | 0.6 |
| Mondial | M2 | 0.85 | 0.75 | 0.65 | 0.85 | 0.3 | 0.5 |
| Mondial | M3 | 0.9 | 0.8 | 0.8 | 0.9 | 0.7 | 0.7 |
| Mondial | M4 | 0.8 | 0.7 | 0.5 | 0.9 | 0.6 | 0.6 |
| Mondial | M5 | 0.85 | 0.75 | 0.55 | 0.95 | 0.65 | 0.7 |
| Mondial | M6 | 0.9 | 0.8 | 0.5 | 0.9 | 0.6 | 0.6 |
| Mondial | M7 | 0.8 | 0.7 | 0.5 | 0.9 | 0.6 | 0.6 |
| DBLP | D1 | 0.8 | 0.7 | 0.6 | 0.8 | 0.3 | 0.5 |
| DBLP | D2 | 0.85 | 0.75 | 0.65 | 0.85 | 0.35 | 0.55 |
| DBLP | D3 | 0.9 | 0.8 | 0.5 | 0.9 | 0.7 | 0.7 |
| DBLP | D4 | 0.8 | 0.7 | 0.5 | 0.9 | 0.6 | 0.6 |
| DBLP | D5 | 0.85 | 0.75 | 0.55 | 0.95 | 0.65 | 0.7 |
| DBLP | D6 | 0.9 | 0.8 | 0.5 | 0.9 | 0.6 | 0.6 |
| DBLP | D7 | 0.8 | 0.7 | 0.5 | 0.9 | 0.6 | 0.6 |
| SigmodRecord | S1 | 0.8 | 0.7 | 0.6 | 0.8 | 0.4 | 0.6 |
| SigmodRecord | S2 | 0.85 | 0.75 | 0.65 | 0.85 | 0.3 | 0.5 |
| SigmodRecord | S3 | 0.9 | 0.8 | 0.8 | 0.9 | 0.7 | 0.7 |
| SigmodRecord | S4 | 0.8 | 0.7 | 0.8 | 0.9 | 0.7 | 0.7 |
| SigmodRecord | S5 | 0.85 | 0.75 | 0.65 | 0.85 | 0.3 | 0.5 |
| SigmodRecord | S6 | 0.9 | 0.8 | 0.5 | 0.9 | 0.6 | 0.6 |
| SigmodRecord | S7 | 0.8 | 0.7 | 0.5 | 0.9 | 0.6 | 0.6 |

graph LR
    classDef process fill:#E5F6FF,stroke:#73A6FF,stroke-width:2px;
    A(XEdge):::process -->|高| B(精度):::process
    A(XEdge):::process -->|高| C(召回率):::process
    D(XKLUSTER):::process -->|部分高| B(精度):::process
    D(XKLUSTER):::process -->|高| C(召回率):::process
    E(XSeek):::process -->|低| B(精度):::process
    E(XSeek):::process -->|部分低| C(召回率):::process

综上所述，XEdge 通过提出聚类紧凑粒度（CCG）、子树紧凑粒度（SCG）和紧凑 LCA（CLCA）的概念，实现了高效的图算法 XEdge 来生成有意义的聚类结果。实验验证了 XEdge 在聚类数量、精度和召回率方面的优势，表明它在 XML 关键字搜索中是一种更有效、更实用的方法。