【ML】Apriori算法原理及代码实现

最新推荐文章于 2024-08-02 18:20:17 发布

Sonhhxg_柒

最新推荐文章于 2024-08-02 18:20:17 发布

阅读量1k

点赞数 7

分类专栏：机器学习（ML）文章标签：算法人工智能机器学习

本文链接：https://blog.csdn.net/sikh_0529/article/details/127167345

版权

机器学习（ML）专栏收录该内容

147 篇文章 139 订阅

订阅专栏

🔎大家好，我是Sonhhxg_柒，希望你看完之后，能对你有所帮助，不足请指正！共同学习交流🔎

📝个人主页－Sonhhxg_柒的博客_CSDN博客 📃

🎁欢迎各位→点赞👍 + 收藏⭐️ + 留言📝

📣系列专栏 - 机器学习【ML】自然语言处理【NLP】深度学习【DL】

🖍foreword

✔说明⇢本人讲解主要包括Python、机器学习（ML）、深度学习（DL）、自然语言处理（NLP）等内容。

如果你对这个系列感兴趣的话，可以关注订阅哟👋

文章目录

简介

1. 频繁项集的评估标准

2. Apriori算法思想

3. Apriori算法流程

4. Aprior算法总结

5.Apriori算法基于零的代码实现

简介

　　　　Apriori算法是常用的用于挖掘出数据关联规则的算法，它用来找出数据值中频繁出现的数据集合，找出这些集合的模式有助于我们做一些决策。比如在常见的超市购物数据集，或者电商的网购数据集中，如果我们找到了频繁出现的数据集，那么对于超市，我们可以优化产品的位置摆放，对于电商，我们可以优化商品所在的仓库位置，达到节约成本，增加经济效益的目的。下面我们就对Apriori算法做一个总结。

1. 频繁项集的评估标准

　　　　什么样的数据才是频繁项集呢？也许你会说，这还不简单，肉眼一扫，一起出现次数多的数据集就是频繁项集吗！的确，这也没有说错，但是有两个问题，第一是当数据量非常大的时候，我们没法直接肉眼发现频繁项集，这催生了关联规则挖掘的算法，比如Apriori, PrefixSpan, CBA。第二是我们缺乏一个频繁项集的标准。比如10条记录，里面A和B同时出现了三次，那么我们能不能说A和B一起构成频繁项集呢？因此我们需要一个评估频繁项集的标准。

　　　　常用的频繁项集的评估标准有支持度,置信度和提升度三个。

　　　　支持度就是几个关联的数据在数据集中出现的次数占总数据集的比重。或者说几个数据关联出现的概率。如果我们有两个想分析关联性的数据X和Y，则对应的支持度为:

　　　　以此类推，如果我们有三个想分析关联性的数据X，Y和Z，则对应的支持度为:

　　　　一般来说，支持度高的数据不一定构成频繁项集，但是支持度太低的数据肯定不构成频繁项集。

　　　　置信度体现了一个数据出现后，另一个数据出现的概率，或者说数据的条件概率。如果我们有两个想分析关联性的数据X和Y，X对Y的置信度为

　　　　也可以以此类推到多个数据的关联置信度，比如对于三个数据X，Y，Z,则X对于Y和Z的置信度为：

　　　　举个例子，在购物数据中，纸巾对应鸡爪的置信度为40%，支持度为1%。则意味着在购物数据中，总共有1%的用户既买鸡爪又买纸巾;同时买鸡爪的用户中有40%的用户购买纸巾。

　　　　提升度表示含有Y的条件下，同时含有X的概率，与X总体发生的概率之比，即:

　　　　提升度体先了X和Y之间的关联关系, 提升度大于1则X⇐YX⇐Y是有效的强关联规则，提升度小于等于1则X⇐YX⇐Y是无效的强关联规则。一个特殊的情况，如果X和Y独立，则有Lift(X⇐Y)=1Lift(X⇐Y)=1，因为此时P(X|Y)=P(X)P(X|Y)=P(X)。

　　　　一般来说，要选择一个数据集合中的频繁数据集，则需要自定义评估标准。最常用的评估标准是用自定义的支持度，或者是自定义支持度和置信度的一个组合。

2. Apriori算法思想

　　　　对于Apriori算法，我们使用支持度来作为我们判断频繁项集的标准。Apriori算法的目标是找到最大的K项频繁集。这里有两层意思，首先，我们要找到符合支持度标准的频繁集。但是这样的频繁集可能有很多。第二层意思就是我们要找到最大个数的频繁集。比如我们找到符合支持度的频繁集AB和ABE，那么我们会抛弃AB，只保留ABE，因为AB是2项频繁集，而ABE是3项频繁集。那么具体的，Apriori算法是如何做到挖掘K项频繁集的呢？

　　　　Apriori算法采用了迭代的方法，先搜索出候选1项集及对应的支持度，剪枝去掉低于支持度的1项集，得到频繁1项集。然后对剩下的频繁1项集进行连接，得到候选的频繁2项集，筛选去掉低于支持度的候选频繁2项集，得到真正的频繁二项集，以此类推，迭代下去，直到无法找到频繁k+1项集为止，对应的频繁k项集的集合即为算法的输出结果。

　　　　可见这个算法还是很简洁的，第i次的迭代过程包括扫描计算候选频繁i项集的支持度，剪枝得到真正频繁i项集和连接生成候选频繁i+1项集三步。

　　　　我们下面这个简单的例子看看：

　　　　我们的数据集D有4条记录，分别是134,235,1235和25。现在我们用Apriori算法来寻找频繁k项集，最小支持度设置为50%。首先我们生成候选频繁1项集，包括我们所有的5个数据并计算5个数据的支持度，计算完毕后我们进行剪枝，数据4由于支持度只有25%被剪掉。我们最终的频繁1项集为1235，现在我们链接生成候选频繁2项集，包括12,13,15,23,25,35共6组。此时我们的第一轮迭代结束。

　　　　进入第二轮迭代，我们扫描数据集计算候选频繁2项集的支持度，接着进行剪枝，由于12和15的支持度只有25%而被筛除，得到真正的频繁2项集，包括13,23,25,35。现在我们链接生成候选频繁3项集,123, 135和235共3组，这部分图中没有画出。通过计算候选频繁3项集的支持度，我们发现123和135的支持度均为25%，因此接着被剪枝，最终得到的真正频繁3项集为235一组。由于此时我们无法再进行数据连接，进而得到候选频繁4项集，最终的结果即为频繁3三项集235。

3. Apriori算法流程

　　　　下面我们对Aprior算法流程做一个总结。

　　　　输入：数据集合D，支持度阈值αα

　　　　输出：最大的频繁k项集

　　　　1）扫描整个数据集，得到所有出现过的数据，作为候选频繁1项集。k=1，频繁0项集为空集。

　　　　2）挖掘频繁k项集

　　　　　　a) 扫描数据计算候选频繁k项集的支持度

　　　　　　b) 去除候选频繁k项集中支持度低于阈值的数据集,得到频繁k项集。如果得到的频繁k项集为空，则直接返回频繁k-1项集的集合作为算法结果，算法结束。如果得到的频繁k项集只有一项，则直接返回频繁k项集的集合作为算法结果，算法结束。

　　　　　　c) 基于频繁k项集，连接生成候选频繁k+1项集。

　　　　3）令k=k+1，转入步骤2。

　　　　从算法的步骤可以看出，Aprior算法每轮迭代都要扫描数据集，因此在数据集很大，数据种类很多的时候，算法效率很低。

4. Aprior算法总结

　　　　 Aprior算法是一个非常经典的频繁项集的挖掘算法，很多算法都是基于Aprior算法而产生的，包括FP-Tree,GSP, CBA等。这些算法利用了Aprior算法的思想，但是对算法做了改进，数据挖掘效率更好一些，因此现在一般很少直接用Aprior算法来挖掘数据了，但是理解Aprior算法是理解其它Aprior类算法的前提，同时算法本身也不复杂，因此值得好好研究一番。

　　　　不过scikit-learn中并没有频繁集挖掘相关的算法类库，这不得不说是一个遗憾，不知道后面的版本会不会加上。

5.Apriori算法基于零的代码实现

from __future__ import division, print_function
import numpy as np
import itertools


class Rule():
    def __init__(self, antecedent, concequent, confidence, support):
        self.antecedent = antecedent
        self.concequent = concequent
        self.confidence = confidence
        self.support = support


class Apriori():
    """用于确定事务数据库中频繁项集的方法，以及
    也用于为这些项集生成规则。
    参数：
    -----------
    min_sup：浮子
        项式集所需的交易的最小分数
        发生于 被视为频繁
    min_conf： float：
        前置项需要暗示的最小倍数
        证明规则合理性的rule
    """
    def __init__(self, min_sup=0.3, min_conf=0.81):

        self.min_sup = min_sup
        self.min_conf = min_conf
        self.freq_itemsets = None       # 常用项集列表
        self.transactions = None        # 交易列表

    def _calculate_support(self, itemset):
        count = 0
        for transaction in self.transactions:
            if self._transaction_contains_items(transaction, itemset):
                count += 1
        support = count / len(self.transactions)
        return support


    def _get_frequent_itemsets(self, candidates):
        """ 修剪不频繁的候选项 => 返回列表
        仅频繁的项目集 """
        frequent = []
        # 查找常用项目
        for itemset in candidates:
            support = self._calculate_support(itemset)
            if support >= self.min_sup:
                frequent.append(itemset)
        return frequent


    def _has_infrequent_itemsets(self, candidate):
        """ 真或假取决于候选人有任何
        大小为 k - 1 的子集，但不在常用项集中 """
        k = len(candidate)
        # 在候选项中查找大小 k-1 的所有组合
        # E.g [1,2,3] => [[1,2],[1,3],[2,3]]
        subsets = list(itertools.combinations(candidate, k - 1))
        for t in subsets:
            # t - is tuple. If size == 1 get the element
            subset = list(t) if len(t) > 1 else t[0]
            if not subset in self.freq_itemsets[-1]:
                return True
        return False


    def _generate_candidates(self, freq_itemset):
        """ 连接频繁项集中的元素并修剪
        结果集（如果它们包含已确定的子集）
        不经常。"""
        candidates = []
        for itemset1 in freq_itemset:
            for itemset2 in freq_itemset:
                # 如果每个元素（但最后一个元素相同）有效
                # 和项集 1 中的最后一个元素小于最后一个元素
                # 在项目集 2
                valid = False
                single_item = isinstance(itemset1, int)
                if single_item and itemset1 < itemset2:
                    valid = True
                elif not single_item and np.array_equal(itemset1[:-1], itemset2[:-1]) and itemset1[-1] < itemset2[-1]:
                    valid = True

                if valid:
                    # JOIN：将项集 2 中的最后一个元素添加到项集 1 中，以
                    # 创建新候选人
                    if single_item:
                        candidate = [itemset1, itemset2]
                    else:
                        candidate = itemset1 + [itemset2[-1]]
                    # PRUNE: 检查是否已确定候选项的任何子集
                    # 不经常
                    infrequent = self._has_infrequent_itemsets(candidate)
                    if not infrequent:
                        candidates.append(candidate)
        return candidates


    def _transaction_contains_items(self, transaction, items):
        """ 真或假，具体取决于项集中的每个项是
        在交易中 """
        # 如果项目实际上只有一个项目
        if isinstance(items, int):
            return items in transaction
        # 循环访问项目列表，并确保
        # 所有项目都在交易中
        for item in items:
            if not item in transaction:
                return False
        return True

    def find_frequent_itemsets(self, transactions):
        """ 返回事务列表中的频繁项集集 """
        self.transactions = transactions
        # 获取交易中的所有唯一项目
        unique_items = set(item for transaction in self.transactions for item in transaction)
        # 获取常用项目
        self.freq_itemsets = [self._get_frequent_itemsets(unique_items)]
        while(True):
            # 从上次添加的常用项集中生成新的候选项
            candidates = self._generate_candidates(self.freq_itemsets[-1])
            # 获取这些候选项中的常用项集
            frequent_itemsets = self._get_frequent_itemsets(candidates)

            # 如果没有频繁的项集，我们就完成了
            if not frequent_itemsets:
                break

            # 将它们添加到常用项集的总列表中并重新开始
            self.freq_itemsets.append(frequent_itemsets)

        # 拼合数组并返回每个常用项集
        frequent_itemsets = [
            itemset for sublist in self.freq_itemsets for itemset in sublist]
        return frequent_itemsets


    def _rules_from_itemset(self, initial_itemset, itemset):
        """ 递归函数，返回置信度> = min_confidence
        从大型项集开始，并以递归方式浏览子集的规则 """
        rules = []
        k = len(itemset)
        # 从项集中获取大小为 k - 1 的子项集的所有组合
        # E.g [1,2,3] => [[1,2],[1,3],[2,3]]
        subsets = list(itertools.combinations(itemset, k - 1))
        support = self._calculate_support(initial_itemset)
        for antecedent in subsets:
            # 组合返回元组 = >转换为列表
            antecedent = list(antecedent)
            antecedent_support = self._calculate_support(antecedent)
            # Calculate the confidence as sup(A and B) / sup(B), if antecedent
            # is B in an itemset of A and B
            confidence = float("{0:.2f}".format(support / antecedent_support))
            if confidence >= self.min_conf:
                # 自负物是除前置物外initial_itemset
                concequent = [itemset for itemset in initial_itemset if not itemset in antecedent]
                # 如果单个项目 = >获取项目
                if len(antecedent) == 1:
                    antecedent = antecedent[0]
                if len(concequent) == 1:
                    concequent = concequent[0]
                # 创建新规则
                rule = Rule(
                        antecedent=antecedent,
                        concequent=concequent,
                        confidence=confidence,
                        support=support)
                rules.append(rule)
                    
                # 如果存在可能导致规则的子集
                # 递归地从子集添加规则
                if k - 1 > 1:
                    rules += self._rules_from_itemset(initial_itemset, antecedent)
        return rules

    def generate_rules(self, transactions):
        self.transactions = transactions
        frequent_itemsets = self.find_frequent_itemsets(transactions)
        # 仅考虑大小为 > = 2 个项目的项目集
        frequent_itemsets = [itemset for itemset in frequent_itemsets if not isinstance(
                itemset, int)]
        rules = []
        for itemset in frequent_itemsets:
            rules += self._rules_from_itemset(itemset, itemset)
        # 删除空值
        return rules

Sonhhxg_柒

关注

7
点赞
踩
19

收藏

觉得还不错? 一键收藏
打赏
10
评论
【ML】Apriori算法原理及代码实现

Apriori算法是常用的用于挖掘出数据关联规则的算法，它用来找出数据值中频繁出现的数据集合，找出这些集合的模式有助于我们做一些决策。比如在常见的超市购物数据集，或者电商的网购数据集中，如果我们找到了频繁出现的数据集，那么对于超市，我们可以优化产品的位置摆放，对于电商，我们可以优化商品所在的仓库位置，达到节约成本，增加经济效益的目的。下面我们就对Apriori算法做一个总结。Aprior算法是一个非常经典的频繁项集的挖掘算法，很多算法都是基于Aprior算法而产生的，包括FP-Tree,GSP, CBA等。
复制链接

扫一扫