数据挖掘Apririo算法实验代码

Apriori算法是一种常用的关联规则挖掘算法。以下是一个使用Python实现的Apriori算法样例代码：

# 导入必要的库
import numpy as np
import pandas as pd

# 定义函数：读取数据集
def load_dataset():
    # 构造样本数据
    dataset = [['牛奶', '面包', '尿布'],
               ['可乐', '面包', '尿布', '啤酒'],
               ['牛奶', '尿布', '啤酒', '鸡蛋'],
               ['面包', '牛奶', '尿布', '啤酒'],
               ['面包', '牛奶', '尿布', '可乐']]
    # 将样本数据转换成DataFrame类型
    df = pd.DataFrame(np.zeros((len(dataset), 4)), columns=['面包', '牛奶', '尿布', '啤酒'])
    for i in range(len(dataset)):
        for j in range(len(dataset[i])):
            if dataset[i][j] == '面包':
                df.iloc[i, 0] = 1
            elif dataset[i][j] == '牛奶':
                df.iloc[i, 1] = 1
            elif dataset[i][j] == '尿布':
                df.iloc[i, 2] = 1
            elif dataset[i][j] == '啤酒':
                df.iloc[i, 3] = 1
    # 返回DataFrame类型数据
    return df

# 定义函数：获取项集C1
def get_C1(df):
    C1 = []
    for col in df.columns:
        C1.append([col])
    return C1

# 定义函数：从项集Lk-1中生成项集Ck
def get_Ck(Lk_1, k):
    Ck = []
    for i in range(len(Lk_1)):
        for j in range(i+1, len(Lk_1)):
            L1 = list(Lk_1[i])[:k-2]
            L2 = list(Lk_1[j])[:k-2]
            L1.sort()
            L2.sort()
            if L1 == L2:
                Ck.append(list(set(Lk_1[i]) | set(Lk_1[j])))
    return Ck

# 定义函数：计算项集Ck的支持度
def get_support(df, Ck, min_support):
    support = {}
    for i in range(df.shape[0]):
        for j in range(len(Ck)):
            if set(Ck[j]).issubset(set(df.iloc[i,:])):
                if tuple(Ck[j]) in support:
                    support[tuple(Ck[j])] += 1
                else:
                    support[tuple(Ck[j])] = 1
    support = {k:v for k,v in support.items() if v/df.shape[0] >= min_support}
    return support

# 定义函数：Apriori算法主函数
def apriori(df, min_support):
    C1 = get_C1(df)
    L1 = get_support(df, C1, min_support)
    Lk_1 = list(L1.keys())
    L = []
    L.append(Lk_1)
    for k in range(2, len(df.columns)+1):
        Ck = get_Ck(Lk_1, k)
        if len(Ck) == 0:
            break
        Lk = get_support(df, Ck, min_support)
        Lk_1 = list(Lk.keys())
        if len(Lk_1) == 0:
            break
        L.append(Lk_1)
    return L

# 测试代码
if __name__ == '__main__':
    # 读取数据集
    df = load_dataset()
    # 调用Apriori算法
    L = apriori(df, 0.6)
    # 输出结果
    for i in range(len(L)):
        if len(L[i]) > 0:
            print('L{}: {}'.format(i+1, L[i]))

代码中，首先定义了一个`load_dataset()`函数用于读取数据集并将其转换成DataFrame类型；接着，定义了`get_C1()`函数用于获取项集C1，即所有单个商品的集合；然后，定义了`get_Ck()`函数用于从项集Lk-1中生成项集Ck；接着，定义了`get_support()`函数用于计算项集Ck的支持度；最后，定义了`apriori()`函数作为Apriori算法的主函数。

在测试代码部分，我们读取了自定义的样本数据，并调用`apriori()`函数进行关联规则挖掘，最后输出了结果。