广州大学机器学习与数据挖掘实验四：Apriori算法

相关资料

广州大学机器学习与数据挖掘实验一：线性回归
广州大学机器学习与数据挖掘实验二：决策树算法
广州大学机器学习与数据挖掘实验三：图像分类
广州大学机器学习与数据挖掘实验四：Apriori算法
四份实验报告下载链接

一、实验目的

本实验课程是计算机、智能、物联网等专业学生的一门专业课程，通过实验，帮助学生更好地掌握数据挖掘相关概念、技术、原理、应用等；通过实验提高学生编写实验报告、总结实验结果的能力；使学生对机器学习算法、数据挖掘实现等有比较深入的认识。
1.掌握机器学习中涉及的相关概念、算法。
2.熟悉数据挖掘中的具体编程方法；
3.掌握问题表示、求解及编程实现。

二、基本要求

1.实验前，复习《机器学习与数据挖掘》课程中的有关内容。
2.准备好实验数据。
3.编程要独立完成，程序应加适当的注释。
4.完成实验报告。

三、实验软件

使用Python或R语言实现。

四、实验内容

某个商场的事务数据库D如表1所示，包括9个事务，即|D|=9。假设最小支持度min_sup=2，请使用Apriori算法找到D中的频繁项集，并输出所有的关联规则（实验编程语言不限）。

表1 商场的事务数据库D

	商品ID的列表
1	l1, l2, l5
2	l2, l4
3	l2, l3
4	l1, l2, l4
5	l1, l3
6	l2,l3
7	l1, l3
8	l1, l2, l3, l5
9	l1, l2, l3

五、实验过程

六、实验结果与评估

输出D中的频繁项集（最小支持度计数为2）：

输出D中的频繁项集（最小支持度计数为1）：

七、实验代码

import numpy as np


def loadDataSet():  # 加载数据
    return [[1, 2, 5], [2, 4], [2, 3], [1, 2, 4], [1, 3], [2, 3], [1, 3], [1, 2, 3, 5], [1, 2, 3]]


def createC1(dataSet):  # 创建C1
    sets = set()
    for i in dataSet:
        sets = sets | set(i)
    C1 = []
    for i in sets:
        C1.append([i])

    return C1


def scanD(data, Ck, minSupport):  # 例子：输入C2，返回C2的支持度计数
    supportData = np.zeros(len(Ck))
    k = -1
    for j in Ck:
        k += 1
        for i in data:
            d = [False for c in j if c not in i]
            if len(d) == 0:
                supportData[k] += 1
    supportData = list(supportData)
    sup = supportData[:]
    ck = Ck[:]
    for i in range(len(sup)):
        if sup[i] < minSupport:
            Ck.remove(ck[i])
            supportData.remove(sup[i])

    return Ck, supportData


def join(Ck, k):  # 连接步  #例子：输入C2，3，输出为连接后的C3
    if (len(Ck) < 2):
        return Ck
    Lk = []
    if k > 2:
        for i in range(len(Ck) - 1):
            L = Ck[i]
            for j in range(len(Ck) - i - 1):
                flag = 1
                for kkk in range(k - 2):
                    if Ck[i][kkk] != Ck[j + i + 1][kkk]:
                        flag = 0
                        break
                if flag:
                    Lk.append(L + [Ck[j + i + 1][k - 2]])
    else:
        for i in range(len(Ck) - 1):
            for j in range(len(Ck) - i - 1):
                Lk.append(Ck[i] + Ck[j + i + 1])
    return Lk


def subsets(list):  # 产生子集，用于剪枝
    if len(list) == 0:
        return [list]
    else:
        sub_incl = []
        sub_excl = subsets(list[1:])
        for elem in sub_excl:
            sub_incl.append([list[0]] + elem)
        return sub_excl + sub_incl


def cut(Lk_1, Ck, k):  # 剪枝步  #例子：输入L2，C3，3，输出剪枝后的C3
    C3 = []
    for i in Ck:
        flag = 1
        sub_sets = subsets(i)
        for sub in sub_sets:
            if len(sub) != k - 1:
                continue
            if sub not in Lk_1:
                flag = 0
                break
        if flag:
            C3.append(i)
    return C3


def Out(L, supportData):  # 输出
    for i in range(len(L)):
        print(L[i], ':', supportData[i])


def apriori(dataSet, minSupport=2):
    print(f"产生最小支持度计数大于{minSupport}的频繁项集如下:")
    C1 = createC1(dataSet)
    L1, supportData = scanD(dataSet, C1, minSupport)
    L = L1
    K = 2
    L_last = []
    L_all = []
    sup = []
    Out(L1, supportData)
    L_all, sup = save(L_all, sup, L1, supportData)
    while (True):
        C = join(L, K)  # 连接步
        C = cut(L, C, K)  # 剪枝步
        L, supportData = scanD(dataSet, C, minSupport)  # 扫描，计算支持度，和筛选大于支持度的
        K += 1
        if len(L) == 0 or L == L_last:  # 没有元素，或者等于上次元素 为终止条件
            break
        else:
            L_last = L
        Out(L, supportData)
        L_all, sup = save(L_all, sup, L, supportData)
    return L_all, sup


def rule(L_all, sup, min_rate=0.7):
    print(f"由频繁项集产生关联规则(大于{min_rate * 100}%)如下:")
    for i in range(len(L_all)):
        sub = subsets(L_all[i])
        num = len(sub)

        for j in range(num - 2):
            for k in range(num - 3 - j):
                left = sub[j + 1]
                right = sub[k + 2 + j]

                up_num = 0
                down_num = 0
                down_num2 = 0
                if (len(list(set(right + left))) != len(L_all[i])): continue
                if (len(list(right + left)) != len(L_all[i])): continue
                for s in range(len(L_all)):
                    if set(left) == set(L_all[s]):
                        down_num = sup[s]
                    if set(right + left) == set(L_all[s]):
                        up_num = sup[s]
                    if set(right) == set(L_all[s]):
                        down_num2 = sup[s]
                if up_num == 0: continue
                if up_num / down_num > min_rate:
                    print(left, "->", right, f", confidence = {up_num}/{down_num} = {up_num / down_num * 100}%")
                if up_num / down_num2 > min_rate:
                    print(right, "->", left, f", confidence = {up_num}/{down_num2} = {up_num / down_num2 * 100}%")


if __name__ == '__main__':
    dataSet = loadDataSet()
    L_all, sup = apriori(dataSet, minSupport=1)
    rule(L_all, sup, min_rate=0.7)  # 产生关联规则