关联规则——Apriori算法

Posted 2020-10-03

Apriori算法是基于Apriori定律：

1、如果一个集合是频繁项集，则它的所有子集都是频繁项集。

2、如果一个集合不是频繁项集，则它的所有超集都不是频繁项集。

Apriori是由a priori合并而来的，它的意思是后面的是在前面的基础上推出来的，即先验推导，怎么个先验法，其实就是二级频繁项集是在一级频繁项集的基础上产生的，三级频繁项集是在二级频繁项集的基础上产生的，以此类推。

Apriori算法的过程如下：

 

1、抄来的php示例代码，有改动

  1 <?php
  2 
  3 
  4 /**
  5  * *实现Apriori算法
  6  * 
  7  *
  8  */
  9 class Apriori{
 10     public static $dCountMap = array(); //频繁集的记数表
 11     private static $MIN_SUP = 0.2; //最小支持度
 12     private static $MIN_CONF = 0.8; //最小置信度
 13     private static $confCount = array(); //置信度记录表
 14     private static $confItemset = array(); //满足支持度的集合
 15     
 16     /**
 17      * 算法的第一次迭代，对每个项出现次数计数
 18      * @param $data 存储数据的二维数组
 19      * @return $list 返回候选1项集
 20      */
 21     public function getFristCandiate($data){
 22         $list = array();
 23         for($i = 0; $i < sizeof($data); $i++){
 24             for($j = 0; $j < sizeof($data[$i]); $j++){
 25                 if (!isset($list[$data[$i][$j]] ))
 26                 $list[$data[$i][$j]] = [$data[$i][$j]];
 27             }
 28         }
 29         return array_values($list);
 30     }
 31     
 32     /**
 33      * 求出CItemset中满足最低支持度集合
 34      * @param $CItemset 备选集
 35      */
 36     public function getSupportedItemset($data, $CItemset){
 37         $end = true;
 38         $supportedItemset = array();
 39         $n = sizeof($CItemset[0])-1;//记录这是第几项集
 40         $k = 0;
 41         for($i = 0; $i < sizeof($CItemset); $i++){
 42             $count = $this->countFrequent($data, $CItemset[$i]);//统计 $CItemset[$i] 在 $data 中出现的次数
 43             if($count >= self::$MIN_SUP * (sizeof($data) )){ //- 1源代码次数有-1 感觉不用-1吧 总数×比例威慑呢买要-1呢
 44                 $supportedItemset[$k] = $CItemset[$i];
 45                 self::$dCountMap[$n][$k] = $count;
 46                 $k++;
 47             }
 48         }
 49         return $supportedItemset;
 50     }
 51     
 52     /**
 53      * 统计备选集出现了多少次
 54      * @param $data 数据表
 55      * @param $list 备选集中的某一项
 56      */
 57     public function countFrequent($data, $list){
 58         $count = 0;
 59         for($i = 0; $i < sizeof($data); $i++){
 60             $record = true;
 61             for($k = 0; $k < sizeof($list); $k++){
 62                 if(!in_array($list[$k], $data[$i])){
 63                     $record = false;
 64                     break;
 65                 }
 66             }
 67             if($record){
 68                 $count++;
 69             }
 70         }
 71         
 72         return $count;
 73     }
 74     
 75     /**
 76      * 根据cItemset求出下一级的备选集合组，求出的备选集合组中的每个集合的元素的个数
 77      * 比cItemset中的集合的元素大1
 78      * @param $CItemset
 79      * @return $nextItemset
 80      */
 81     public function getNextCandidate($CItemset){
 82         $nextItemset = array();
 83         $count = 0;
 84         //取出每一项集
 85         for($k = 0; $k < sizeof($CItemset); $k++){
 86             //遍历其他项集的每一个元素，判断是否存在于该项集，如果不存在，则该加入该元素
 87             for($i = $k + 1; $i < sizeof($CItemset); $i++){
 88                 for($j = 0; $j < sizeof($CItemset[$i]); $j++){
 89                     if(!in_array($CItemset[$i][$j], $CItemset[$k])){
 90                         $tmp = $CItemset[$k];//先临时储存，满足条件后在加入进去
 91                         //剪枝：即去掉子集不是频繁的项集
 92                         if($this->isSubsetInC($tmp, $CItemset[$i][$j], $CItemset)){
 93                             array_push($tmp, $CItemset[$i][$j]);
 94                             //去掉重复项
 95                             if(!$this->isHave($tmp, $nextItemset)){
 96                                 $nextItemset[$count] = $tmp;
 97                                 $count++;
 98                             }
 99                         }
100                     }
101                 }
102             }
103         }
104         
105         return $nextItemset;
106     }
107     
108     /**
109      * 剪枝：即去掉子集不是频繁的项集
110      * @param $itemset 前一项集的某一项，判断能否加入新项后是否是平凡集
111      * @param $key 即将加入的一项
112      * @param $CItemset 前一项集
113      */
114     public function isSubsetInC($itemset, $key, $CItemset){
115         $record = 0; //记录子集匹配的个数
116         for($i = 0; $i < sizeof($itemset); $i++){
117             for($j = 0; $j < sizeof($CItemset); $j++){
118                 $subset = $itemset;
119                 $subset[$i] = $key;//分别替换掉每一项就是子集
120                 //如果相等，则记录加一
121                 if(sizeof(array_diff($subset, $CItemset[$j])) == 0){
122                     $record++;
123                     break;
124                 }
125             }
126         }
127         if($record == sizeof($itemset)){
128             return true;
129         }
130         
131         return false;
132     }
133     
134     /**
135      * 判断将要加入的项是否已经存在是否已经存在
136      * @param $list 将要加入的项
137      * @param $itemset 项集
138      */
139     public function isHave($list, $itemset){
140         for($i = 0; $i < sizeof($itemset); $i++){
141             if(sizeof(array_diff($list, $itemset[$i])) == 0){
142                 return true;
143             }
144         }
145         
146         return false;
147     }
148 }
149 $data =[[1,2,3],[1,3,4],[1,3,5],[1,4],[1,3,7],[5,8],[1,3,9]];
150 $CItemset = array();//备选集
151 $lItemset = array();//获取备选集$CItemset满足支持度的集合
152 $n = 0;
153 $apriori = new Apriori();
154 $CItemset[$n] = $apriori->getFristCandiate($data); //获取第一次的备选集
155 $lItemset[$n] = $apriori->getSupportedItemset($data, $CItemset[$n]); //获取备选集$CItemset满足支持度的集合
156 $flag = true;
157 while ($flag) {
158     $itemset = $apriori->getNextCandidate($lItemset[$n]);// 获取第下一次的备选集
159     if(sizeof($itemset) == 0){
160         $flag = false;
161         break;
162     }
163     $CItemset[$n+1] = $itemset;
164     $lItemset[$n+1] = $apriori->getSupportedItemset($data, $CItemset[$n+1]); //获取本次备选集$CItemset满足支持度的集合
165     $n++;
166 }
167 var_dump($CItemset);
168 var_dump($lItemset);
169 var_dump(Apriori::$dCountMap);

 

2、计算置信度

对于一个频繁集L，找到所有的L的非空子集非空子集f，如果f -> L - f，的概率满足最小置信度，则这是一个强规则。 
如果{A,B,C,D}是一个频繁集，则它有如下候选规则 
ABC -> D, ABD -> C, ACD -> B, BCD -> A, A -> BCD, B -> ACD, C -> ABD, D -> ABC，AB -> CD, AC -> BD, AD -> BC, BC -> AD, BD -> AC, CD -> AB 
从中我们可以看出： 
如果L的大小|L| = k， 则一共有（2的k次方减2） 个候选关联规则（除去 空集和全集）。 

 

简化计算

根据公式我们可以推导出如下规则： 
对于L = {A,B,C,D},它的子集的置信度有如下规则， 
c(ABC -> D)>=c(AB -> CD) >= c(A -> BCD) 

所以

图中被红圈标注的皆是不满足最小置信度的规则。 

参考代码：

 1 /**
 2     * 计算一个项集产生的关联规则的所有置信度
 3     * @param $itemset 要计算的某一项集
 4     * @param $lItemset 所有满足支持度的集合
 5     * @param $count 该项集的支持度
 6     * @return $confidence 求出满足最小置信度的关联数组
 7     */
 8     public function confidence($itemset, $lItemset, $count){
 9         $n = sizeof($itemset)-2;
10         $lkItemset = $lItemset[$n];
11         $confidence = array();
12         $this->subset = array();
13         $this->getAllSubSet(0, $itemset);//获得所有子集
14         for($i = 0; $i < sizeof($this->subset); $i++){
15             $n = sizeof($this->subset[$i])-1;
16             if($n >= 0 && $n < sizeof($itemset)-1){
17                 $dkCountMap = self::$dCountMap[$n]; //根据大小，取出频繁集对应的支持度
18                 //比较取出每个子集对应的支持度，并计算出置信度
19                 for($j = 0; $j < sizeof($lItemset[$n]); $j++){
20                     if(!array_diff($this->subset[$i], $lItemset[$n][$j])){
21                         $conf = $count / $dkCountMap[$j] * 1.0;
22                         if($conf >= self::$MIN_CONF){
23                             $from = implode(",", $this->subset[$i]);
24                             $to = implode(",", array_diff($itemset, $this->subset[$i]));
25                             $confidence["$from ==> $to"] = $conf;
26                         }
27                     }
28                 }
29             }
30 
31         }
32 
33         return $confidence;
34     }
35 
36     /**
37     * 递归排列组合，获得一个项集所有子集,包括全集和空集
38     * @param $pos 记录将要放入子集的位置
39     * @param $itemset 要计算子集的项集
40     */
41     public $p = array(); //记录将要放入子集的位置,每一次递归就有0,1两种选择，最后即可获得所有选择
42     public $subset = array();
43     public $subsetCount = 0;
44     public function getAllSubSet($pos, $itemset){
45         if($pos == sizeof($itemset)){
46             $tmp = array();
47             for($i = 0; $i < sizeof($itemset); $i++){
48                 if($this->p[$i] == 1){
49                     array_push($tmp, $itemset[$i]);
50                 }
51             }
52             $count = $this->subsetCount;
53             $this->subset[] = $tmp;
54             $this->subsetCount++;
55             return;
56         }
57         $this->p[$pos] = 0;
58         $this->getAllSubSet($pos+1, $itemset);
59         $this->p[$pos] = 1;
60         $this->getAllSubSet($pos+1, $itemset);
61     }

 

todo 从写上面两处代码，合并为1个类

todo 优化 https://wizardforcel.gitbooks.io/dm-algo-top10/content/apriori.html