基于Apriori算法的XML文档挖掘

我试图用Apriori算法从XML文档中挖掘关联规则。为此，有两种通用方法：1）将XML映射到关系格式并应用经典的Apriori，2）直接挖掘XML。我想用后者，但有几个问题

经过研究，我发现了两个不完整的解决方案：

这为生成k-itemset提供了解决方案

这就提出了通过XQuery模拟Apriori（提供的代码不完整）

请让我知道你的想法和建议，我可以如何做到这一点（两种方法）

更新：

根据上述论文的另一个版本，数据集如下所示：

<transactions>
<transaction id="1">
 <items>
<item>a</item> 
<item>d</item>
<item>e</item>
 </items>
</transaction>

<transaction id="2">
 <items>
<item>b</item> 
<item>c</item>
<item>d</item>
 </items>
</transaction>

<transaction id="3">
 <items>
<item>a</item> 
<item>c</item>
 </items>
</transaction>

<transaction id="4">
 <items>
<item>b</item> 
<item>c</item>
<item>d</item>
 </items>
</transaction>

<transaction id="5">
 <items>
<item>a</item> 
<item>b</item>
 </items>
</transaction>

</transactions>

A.
D
E
B
C
D
A.
C
B
C
D
A.
B

然后，功能如下所示

define function join(element $X, element $Y) returns element {
let $items := (for $item in $Y
where every $i in $X satisfies
$i != $item
return $item)
return $X union $items
}

define function commonIts(element $X, element $Y) returns
element {
for $item in $X
where some $i in $Y satisfies $i = $item
return $item
}

define function removeIts(element $X, element $Y) returns
element {
for $item in $X
where every $i in $Y satisfies $i != $item
return $item
}

define function candidateGen(element $l) returns element {
for $freqSet1 in $l
let $items1 := $freqSet1//items/*
for $freqSet2 in $l
let $items2 := $freqSet2//items/*
where $freqSet2 >> $freqSet1 and
count($items1)+1 =  count($items1 union $items2)
and prune(join($items1,$items2), $l)
return <items>
{join($items1,$items2)}
</items>
}

define function prune(element $X, element $Y) returns boolean
{
every $item in $X satisfies
some $items in $Y//items satisfies
count(commonIts(removeIts($X,$item),$items/*))
= count($X) - 1
}

define function removeDuplicate(element $C) returns element
{
for $itemset1 in $C
let $items1 := $itemset1/*
let $items :=(for $itemset2 in $C
let $items2 := $itemset2/*
where $itemset2>>$itemset1 and
count($items1) =
count(commonIts($items1, $items2))
return $items2)
where count($items) = 0
return $itemset1
}

define function getLargeItemsets(element $C, element $minsup,
element $total, element $src) returns element {
for $items in $C
let $trans := (for $tran in $src
where every $item1 in $items/* satisfies
some $item2 in $tran/*
satisfies $item1 = $item2
return $tran)
let $sup := (count($trans) * 1.00) div $total
where $sup >= $minsup
return <largeItemset> {$items}
<support> {$sup} </support>
</largeItemset>
}

define function apriori(element $l, element $L, element $minsup,
element $total, element $src) returns element {
let $C := removeDuplicate(candidateGen($l))
let $l := getLargeItemsets($C, $minsup, $total, $src)
let $L := $l union $L
return if (empty($l)) then
$L
else
apriori($l, $L, $minsup, $total, $src)
}

let $src := document(“/transactions.xml”)//items
let $minsup := 0.4
let $items := (for $item in $src/*
where $itemset = $item
let $total := count($src) * 1.00
let $C := distinct-values($src/*)
let $l :=(for $itemset in $C
return $item)
let $sup := (count($items) * 1.00) div $total
where $sup >= $minsup
return <largeItemset>
<items> {$itemset} </items>
<support> {$sup} </support>
</largeItemset>)
let $L := $l
return <largeItemsets> { apriori($l, $L,$minsup, $total, $src) }
</largeItemsets>

define函数连接（元素$X，元素$Y）返回元素{
让$items:=（对于$Y中的$item
其中$X中的每个$i满足
$i！=$item
退回$item）
返回$X union$项目
}
定义函数commonIts（元素$X，元素$Y）返回
元素{
对于$X中的$item
其中$Y中的某些$i满足$i=$item
退货$item
}
定义函数removits（元素$X，元素$Y）返回
元素{
对于$X中的$item
其中$Y中的每个$i满足$i！=$item
退货$item
}
定义函数candidateGen（元素$l）返回元素{
对于$l中的$freqSet1
设$items1:=$freqSet1//items/*
对于$freqSet2，单位为$l
设$items2:=$freqSet2//items/*
其中$freqSet2>>$freqSet1和
计数（$items1）+1=计数（$items1联合$items2）
和修剪（join（$items1，$items2），$l）
返回
{加入（$items1，$items2）}
}
定义函数prune（元素$X，元素$Y）返回布尔值
{
$X中的每个$item都满足
$Y//items中的某些$items满足
计数（commonIts（删除（$X，$item），$items/*））
=计数（$X）-1
}
定义函数RemovedUpplicate（元素$C）返回元素
{
对于$C中的$itemset1
让$items1:=$itemset1/*
让$items:=（对于$C中的$itemset2
让$items2:=$itemset2/*
其中$itemset2>>$itemset1和
计数（$items1）=
计数（常用（$items1，$items2））
返回$items2）
其中计数（$items）=0
返回$itemset1
}
定义函数getLargeItemsets（元素$C、元素$minsup、，
元素$total，元素$src）返回元素{
对于$C中的$items
让$trans:=（对于$src中的$tran
其中$items/*中的每个$item1满足
$tran中的一些$item2/*
满足$item1=$item2
返回$tran）
let$sup:=（计数（$trans）*1.00）div$total
其中$sup>=$minsup
返回{$items}
{$sup}
}
定义函数apriori（元素$l、元素$l、元素$minsup、，
元素$total，元素$src）返回元素{
let$C:=移除的副本（候选项（$l））
let$l:=getLargeItemsets（$C、$minsup、$total、$src）
让$L:=$L联合$L
如果返回（空（$l）），则返回
1美元
其他的
apriori（$l，$l，$minsup，$total，$src）
}
让$src:=document（“/transactions.xml”）//项
让$minsup:=0.4
让$items:=（对于$src中的$item/*
其中$itemset=$item
合计：=计数（$src）*1.00
设$C:=不同的值（$src/*）
让$l:=（对于$C中的$itemset
退回$item）
let$sup:=（计数（$items）*1.00）div$total
其中$sup>=$minsup
返回
{$itemset}
{$sup}
)
设$L:=$L
返回{apriori（$l，$l，$minsup，$total，$src）}

为了计算规则文档，他们引入了以下表达式：

let $minconf := 1.00
let $src := document(“/large.xml”)//largeItemset
for $itemset1 in $src
let $items1 := $itemset1/items/*
for $itemset2 in $src
let $items2 := $itemset2/items/*
where count($items1) > count($items2) and
count(commonIts($items1, $items2)) =
count($items2) and $itemset1/support div
$itemset2/support >= $minconf
return <rule support =“{$itemset1/support}”
confidence = “{($itemset1/support*1.0) div
($itemset2/support*1.0)}”>
<antecedent> {$items2} </antecedent>
<consequent>
{removeItems($items1,$items2)}
</consequent>
</rule>

让$minconf:=1.00
让$src:=document（“/large.xml”）//largeItemset
对于$src中的$itemset1
让$items1:=$itemset1/项/*
对于$src中的$itemset2
让$items2:=$itemset2/项/*
其中count（$items1）>count（$items2）和
计数（常用（$items1，$items2））=
计数（$items2）和$itemset1/支持部门
$itemset2/support>=$minconf
返回
{$items2}
{removitems（$items1，$items2）}

---

现在，我面临的最大挑战是将这些功能集成在一起工作。

第一种方法会快得多。只需将数据预处理一次（处理XML的成本相当高），将其转换为非常适合您的算法的输入格式

关于查找源代码的问题在这里是离题的。试着解决这个问题，带着你所写代码的具体问题回来，试着用一种简洁的格式表达它们，这样它们就可以用一种自包含的QA风格得到很好的回答

---

还请注意，上述使用Xquery实现Apriori的尝试缺少一些基本的优化，这些优化弥补了Apriori算法的不足。对于一个真正可用的Apriori实现，您将需要使用优化的数据结构，这在XQuery中是无法实现的。试着在一些经典数据集上运行这个实现，它就会死掉。让Apriori实现可伸缩性已经够难了，但使用XQuery实现这一点是一条疯狂之路——一个关键的挑战是保持低内存使用率，即使在C语言中也是如此

你的答案似乎主要是一个评论，而不是一个实际的答案。只有你的前两句话多少能回答这个问题，单凭这两句话还不足以回答一个高质量的问题。简单地说一种方法快得多并没有真正的帮助——为什么它会更快呢？而且，你关于第一种方法会更快的回答完全是错误的。您也可以在XQuery中实现一种先验算法，并使用XML作为数据源。重复处理XML的成本很高。你只想做一次。这就是为什么它更快。您似乎提倡XQuery，但您是否实现了APRIORI？（还要注意，这个问题是在我的回答之后编辑的…）没错，重复处理XML的成本很高，但是有几个本地XML数据库（eXist、BaseX…）只处理一次，然后将其以处理效率高的格式保存在主内存中。在XQuery中实现这个问题与在Haskell等所有其他函数式语言中实现这个问题一样困难。另外，我并不提倡XQuery，我只是每天使用它，因此我非常熟悉它的可能性和限制