【机器学习】【Apriori算法-2】Apriori算法的Python实现 + 代码讲解

1.Apriori算法原理详解

    请详见：Apriori算法原理详解+示例展示数学求解过程

2.Python实现Apriori算法

2.1算法的重要Python操作知识点

实现Apriori算法时，重要Python知识点：

1）如何实现二维list 转化为set

2）如何判断list A是list B的子集

    此处A和B是一维序列；另外A是B的有序子集，比如[1, 3]是[1,2,3]的有序子集，但不是[3, 2, 1]的有序子集

3）如何实现由[[1], [2], [3]]得到[[1, 2], [1, 3], [2, 3]]

4）如何实现由[[1, 2], [1, 3], [2, 3], [2, 4], [3, 4]]得到[[1,2,3], [1,2,4], [1,3,4], [2,3,4]]

    这个是Apriori的重要操作。是根据旧的支持数据集得到新的支持数据集的关键操作。

5）算法的另外一个关键操作是，计算一个序列在序列列表里面的出现次数

注：下面2.2是精简的Python代码，2.3是展示数学求解过程的Python代码，如果是理解算法思路可以看2.3的代码，其他可以看2.2代码。

2.2精简的Python代码

# -*- coding: utf-8 -*-
"""
@author: Tom
Talk is cheap, show me the code
Aim:实现Apriori算法
"""

import numpy as np

class CApriori(object):
    '''
    实现Apriori算法
    '''
    def __init__(self, goods, minSupport):
        self.goods = goods           #交易商品列表
        #最小支持度，支持度过滤时支持度小于此值的频繁项会被过滤掉
        self.minSupport = minSupport 
        
        self.N = np.shape(goods)[0]  #交易次数
        self.goodsSet = set([])      #商品集合, 元素是单个商品
        self.max_len  = 0            #最长交易的商品总数
        #支持数据集，元素是[频繁项, 支持项]，频繁项=商品序列list, 支持项=支持度*交易总次数
        self.supportData = []        
        
        self._init() #初始化
        self._work() #开始迭代运算直到找到支持数据集
        
    def _isSubset(self, A, B):
        '''判断序列a是否序列b的子集，且是有序子集，此处有序子集详见下面Note
        :param a, 一维序列
        :param b, 一维序列
        :return True:a是b的子集，False：a不是b的子集
        :Note [1, 3] 是 [1, 2, 3]的有序子集，[3, 1]不是[1, 2, 3]的有序子集
        '''
        A,B = list(A),list(B)
        if np.shape(A)[0] == 0:
            return False

        pre_ind = -1
        for e in A:
            if e not in B: #不是子集
                return False
            elif B.index(e) < pre_ind: #不满足有序
                return False
            pre_ind = B.index(e)

        return True

    def _support(self, item, goods):
        '''
        :param item, 频繁项
        :param goods, 交易商品列表
        :return 频繁项的支持度
        '''
        subset_cnt = [self._isSubset(item, e) for e in goods]
        cnt = subset_cnt.count(True)
        support = cnt * 1.0 / self.N
        return support
        
    def _init(self):
        '''初始化支持数据集和迭代计数器
        '''
        self.supportData = []
        #设置迭代计数器
        for item in self.goods:
            if np.shape(item)[0] > self.max_len:
                self.max_len = np.shape(item)[0]
        #交易商品数据，一维list
        goods_data = []
        for e in self.goods:
            goods_data.extend(e)

        #交易商品集合，set
        self.goodsSet = set(goods_data)
        
        #初始数据集(频繁项，支持项)
        for i in range(len(self.goodsSet)):
            e = list(self.goodsSet)[i] #频繁项，单个商品
            cnt = goods_data.count(e)  #支持项
            support = cnt *1.0 / self.N
            if (support >= self.minSupport):