关联规则——Apriori算法

Apriori算法是基于Apriori定律：

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

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

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

Apriori算法的过程如下：

 

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

 

<?php


/**
 * *实现Apriori算法
 * @author tju_zyt@tju.edu.cn
 *
 */
class Apriori{
    public static $dCountMap = array(); //频繁集的记数表
    private static $MIN_SUP = 0.2; //最小支持度
    private static $MIN_CONF = 0.8; //最小置信度
    private static $confCount = array(); //置信度记录表
    private static $confItemset = array(); //满足支持度的集合
    
    /**
     * 算法的第一次迭代，对每个项出现次数计数
     * @param $data 存储数据的二维数组
     * @return $list 返回候选1项集
     */
    public function getFristCandiate($data){
        $list = array();
        for($i = 0; $i < count($data); $i++){
            for($j = 0; $j < count($data[$i]); $j++){
                if (!isset($list[$data[$i][$j]] ))
                $list[$data[$i][$j]] = [$data[$i][$j]];
            }
        }
        return array_values($list);
    }
    
    /**
     * 求出CItemset中满足最低支持度集合
     * @param $CItemset 备选集
     */
    public function getSupportedItemset($data, $CItemset){
        $end = true;
        $supportedItemset = array();
        $n = count($CItemset[0])-1;//记录这是第几项集
        $k = 0;
        for($i = 0; $i < count($CItemset); $i++){
            $count = $this->countFrequent($data, $CItemset[$i]);//统计 $CItemset[$i] 在 $data 中出现的次数
            if($count >= self::$MIN_SUP * (count($data) )){ //- 1源代码次数有-1 感觉不用-1吧 总数×比例威慑呢买要-1呢
                $supportedItemset[$k] = $CItemset[$i];
                self::$dCountMap[$n][$k] = $count;
                $k++;
            }
        }
        return $supportedItemset;
    }
    
    /**
     * 统计备选集出现了多少次
     * @param $data 数据表
     * @param $list 备选集中的某一项
     */
    public function countFrequent($data, $list){
        $count = 0;
        for($i = 0; $i < count($data); $i++){
            $record = true;
            for($k = 0; $k < count($list); $k++){
                if(!in_array($list[$k], $data[$i])){
                    $record = false;
                    break;
                }
            }
            if($record){
                $count++;
            }
        }
        
        return $count;
    }
    
    /**
     * 根据cItemset求出下一级的备选集合组，求出的备选集合组中的每个集合的元素的个数
     * 比cItemset中的集合的元素大1
     * @param $CItemset
     * @return $nextItemset
     */
    public function getNextCandidate($CItemset){
        $nextItemset = array();
        $count = 0;
        //取出每一项集
        for($k = 0; $k < count($CItemset); $k++){
            //遍历其他项集的每一个元素，判断是否存在于该项集，如果不存在，则该加入该元素
            for($i = $k + 1; $i < count($CItemset); $i++){
                for($j = 0; $j < count($CItemset[$i]); $j++){
                    if(!in_array($CItemset[$i][$j], $CItemset[$k])){
                        $tmp = $CItemset[$k];//先临时储存，满足条件后在加入进去
                        //剪枝：即去掉子集不是频繁的项集
                        if($this->isSubsetInC($tmp, $CItemset[$i][$j], $CItemset)){
                            array_push($tmp, $CItemset[$i][$j]);
                            //去掉重复项
                            if(!$this->isHave($tmp, $nextItemset)){
                                $nextItemset[$count] = $tmp;
                                $count++;
                            }
                        }
                    }
                }
            }
        }
        
        return $nextItemset;
    }
    
    /**
     * 剪枝：即去掉子集不是频繁的项集
     * @param $itemset 前一项集的某一项，判断能否加入新项后是否是平凡集
     * @param $key 即将加入的一项
     * @param $CItemset 全部项集
     */
    public function isSubsetInC($itemset, $key, $CItemset){
        $record = 0; //记录子集匹配的个数
        for($i = 0; $i < count($itemset); $i++){
            for($j = 0; $j < count($CItemset); $j++){//用于逐项比较
                $subset = $itemset;
                $subset[$i] = $key;//分别替换掉每一项就是子集
                //如果相等，则记录加一
                if(count(array_diff($subset, $CItemset[$j])) == 0){//和上一级的比较 差集为0表示相同，为频繁项
                    $record++;
                    break;
                }
            }
        }
        if($record == count($itemset)){//每一个子项都是频繁项
            return true;
        }
        
        return false;
    }
    
    /**
     * 判断将要加入的项是否已经存在是否已经存在
     * @param $list 将要加入的项
     * @param $itemset 项集
     */
    public function isHave($list, $itemset){
        for($i = 0; $i < count($itemset); $i++){
            if(count(array_diff($list, $itemset[$i])) == 0){
                return true;
            }
        }
        
        return false;
    }
}
$data =[
    ['牛奶','面包'],
    ['面包','尿布','啤酒','鸡蛋'],
    ['牛奶','尿布','啤酒','可乐'],
    ['面包','牛奶','尿布','啤酒'],
    ['面包','牛奶','尿布','可乐']
];
$CItemset = array();//备选集
$lItemset = array();//获取备选集$CItemset满足支持度的集合
$n = 0;
$apriori = new Apriori();
$CItemset[$n] = $apriori->getFristCandiate($data); //获取第一次的备选集
$lItemset[$n] = $apriori->getSupportedItemset($data, $CItemset[$n]); //过滤备选集 去掉不满足最小支持度的项 。获取备选集$CItemset满足支持度的集合
$flag = true;
while ($flag) {
    $itemset = $apriori->getNextCandidate($lItemset[$n]);// 获取第下一次的备选集
    if(count($itemset) == 0){
        $flag = false;
        break;
    }
    $CItemset[$n+1] = $itemset;
    $lItemset[$n+1] = $apriori->getSupportedItemset($data, $CItemset[$n+1]); //获取本次备选集$CItemset满足支持度的集合
    $n++;
}
print_r($CItemset);
print_r($lItemset);
print_r(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) 

以下图为例来说明，假设由{bcd}生成{a}这一规则不满足置信度公式，也就是说{bcd}在数据库中出现的次数偏多，而{a}出现的次数偏少，根据命题1，{bcd}的子集也是频繁项，根据命题2，{a}的父集也很少出现，从而{bc}生成{ad}等规则的置信度更低，然后将其从集合树上减去。

 

所以

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

参考代码：

/**
    * 计算一个项集产生的关联规则的所有置信度
    * @param $itemset 要计算的某一项集
    * @param $lItemset 所有满足支持度的集合
    * @param $count 该项集的支持度
    * @return $confidence 求出满足最小置信度的关联数组
    */
    public function confidence($itemset, $lItemset, $count){
        $n = sizeof($itemset)-2;
        $lkItemset = $lItemset[$n];
        $confidence = array();
        $this->subset = array();
        $this->getAllSubSet(0, $itemset);//获得所有子集
        for($i = 0; $i < sizeof($this->subset); $i++){
            $n = sizeof($this->subset[$i])-1;
            if($n >= 0 && $n < sizeof($itemset)-1){
                $dkCountMap = self::$dCountMap[$n]; //根据大小，取出频繁集对应的支持度
                //比较取出每个子集对应的支持度，并计算出置信度
                for($j = 0; $j < sizeof($lItemset[$n]); $j++){
                    if(!array_diff($this->subset[$i], $lItemset[$n][$j])){
                        $conf = $count / $dkCountMap[$j] * 1.0;
                        if($conf >= self::$MIN_CONF){
                            $from = implode(",", $this->subset[$i]);
                            $to = implode(",", array_diff($itemset, $this->subset[$i]));
                            $confidence["$from ==> $to"] = $conf;
                        }
                    }
                }
            }

        }

        return $confidence;
    }

    /**
    * 递归排列组合，获得一个项集所有子集,包括全集和空集
    * @param $pos 记录将要放入子集的位置
    * @param $itemset 要计算子集的项集
    */
    public $p = array(); //记录将要放入子集的位置,每一次递归就有0,1两种选择，最后即可获得所有选择
    public $subset = array();
    public $subsetCount = 0;
    public function getAllSubSet($pos, $itemset){
        if($pos == sizeof($itemset)){
            $tmp = array();
            for($i = 0; $i < sizeof($itemset); $i++){
                if($this->p[$i] == 1){
                    array_push($tmp, $itemset[$i]);
                }
            }
            $count = $this->subsetCount;
            $this->subset[] = $tmp;
            $this->subsetCount++;
            return;
        }
        $this->p[$pos] = 0;
        $this->getAllSubSet($pos+1, $itemset);
        $this->p[$pos] = 1;
        $this->getAllSubSet($pos+1, $itemset);
    }

 

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