Apriori算法的用法 给出代码

Apriori算法是一种经典的关联规则挖掘方法，用于发现数据中频繁出现的项集，并生成关联规则。该算法的核心思想是：如果某个项集是频繁出现的，那么它的所有子集都是频繁出现的。

以下是 Python 实现的 Apriori 算法示例代码：

def load_data():
    '''
    加载数据集
    '''
    return [[1,3,4],[2,3,5],[1,2,3,5],[2,5]]

def create_C1(data_set):
    '''
    生成候选集 C1
    '''
    C1 = set()
    for transaction in data_set:
        for item in transaction:
            item_set = frozenset([item])
            C1.add(item_set)
    return C1

def scan_D(data_set, Ck, min_support):
    '''
    从候选集 Ck 生成支持度大于等于 min_support 的频繁项集 Lk
    '''
    cnt = {}
    trans_cnt = len(data_set)
    for transaction in data_set:
        for item in Ck:
            if item.issubset(transaction):
                if not item in cnt:
                    cnt[item] = 1
                else:
                    cnt[item] += 1
    ret_list = []
    support_data = {}
    for key in cnt:
        support = cnt[key] / trans_cnt
        if support >= min_support:
            ret_list.append(key)
            support_data[key] = support
    return ret_list, support_data

def apriori_gen(Lk, k):
    '''
    从频繁项集 Lk 生成候选集 Ck+1
    '''
    ret_list = []
    len_Lk = len(Lk)
    for i in range(len_Lk):
        for j in range(i+1, len_Lk):
            L1, L2 = list(Lk[i])[:k-2], list(Lk[j])[:k-2]
            L1.sort()
            L2.sort()
            if L1 == L2:
                ret_list.append(Lk[i].union(Lk[j]))
    return ret_list

def apriori(data_set, min_support=0.5):
    '''
    Apriori算法
    '''
    C1 = create_C1(data_set)
    D = list(map(set, data_set))
    L1, support_data = scan_D(D, C1, min_support)
    L = [L1]
    k = 2
    while len(L[k-2]) > 0:
        Ck = apriori_gen(L[k-2], k)
        Lk, support_k = scan_D(D, Ck, min_support)
        support_data.update(support_k)
        L.append(Lk)
        k += 1
    return L, support_data

if __name__ == '__main__':
    data_set = load_data()
    L, support_data = apriori(data_set, min_support=0.5)
    print('频繁项集:', L)
    print('频繁项集支持度:', support_data)

以上代码实现了 Apriori 算法的主要功能，并能够找出频繁项集和其支持度。在调用 apriori 函数时，可以传递数据集和最小支持度参数，以生成相应的频繁项集。