Apriori用Python代码实现

好的，以下是使用 Python 实现 Apriori 算法的代码示例：

# 导入所需库
import pandas as pd
from mlxtend.frequent_patterns import apriori
from mlxtend.frequent_patterns import association_rules

# 读入数据集
data = pd.read_csv('data.csv')

# 将数据转为适应 Apriori 算法的格式
basket_sets = data.groupby(['Transaction', 'Item'])['Item'].count().unstack().fillna(0)

# 使用 Apriori 算法获取频繁项集
frequent_items = apriori(basket_sets, min_support=0.2, use_colnames=True)

# 使用关联规则确定项集之间的关系及其强度
association_rules(frequent_items, metric="lift", min_threshold=1)

请注意，这只是个示例代码，实际使用时需要根据数据集的实际情况调整 min_support 和 min_threshold 等参数。

相关问题

Apriori算法python代码实现

我可以回答这个问题。以下是 Apriori 算法的 Python 代码实现示例：

def generate_C1(data_set):
    C1 = []
    for transaction in data_set:
        for item in transaction:
            if not [item] in C1:
                C1.append([item])
    C1.sort()
    return list(map(frozenset, C1))


def scan_D(data_set, candidates, min_support):
    ss_cnt = {}
    for tid in data_set:
        for can in candidates:
            if can.issubset(tid):
                if not can in ss_cnt:
                    ss_cnt[can] = 1
                else:
                    ss_cnt[can] += 1
    num_items = float(len(data_set))
    ret_list = []
    support_data = {}
    for key in ss_cnt:
        support = ss_cnt[key] / num_items
        if support >= min_support:
            ret_list.insert(0, key)
        support_data[key] = support
    return ret_list, support_data


def apriori_gen(Lk, k):
    ret_list = []
    len_Lk = len(Lk)
    for i in range(len_Lk):
        for j in range(i + 1, len_Lk):
            L1 = list(Lk[i])[:k - 2]
            L2 = list(Lk[j])[:k - 2]
            L1.sort()
            L2.sort()
            if L1 == L2:
                ret_list.append(Lk[i] | Lk[j])
    return ret_list


def apriori(data_set, min_support=0.5):
    C1 = generate_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, sup_k = scan_D(D, Ck, min_support)
        support_data.update(sup_k)
        L.append(Lk)
        k += 1
    return L, support_data

请注意，这只是一个示例，实际上可以有多种不同的实现方式。

apriori算法python代码实现

下面是Apriori算法的Python实现：

def loadDataSet():
    return [[1,3,4],[2,3,5],[1,2,3,5],[2,5]]

def createC1(dataSet):
    C1 = []
    for transaction in dataSet:
        for item in transaction:
            if not [item] in C1:
                C1.append([item])
    C1.sort()
    return map(frozenset, C1)

def scanD(D, Ck, minSupport):
    ssCnt = {}
    for tid in D:
        for can in Ck:
            if can.issubset(tid):
                if not can in ssCnt: ssCnt[can]=1
                else: ssCnt[can] += 1
    numItems = float(len(D))
    retList = []
    supportData = {}
    for key in ssCnt:
        support = ssCnt[key]/numItems
        if support >= minSupport:
            retList.insert(0,key)
        supportData[key] = support
    return retList, supportData

def aprioriGen(Lk, k): #creates Ck
    retList = []
    lenLk = len(Lk)
    for i in range(lenLk):
        for j in range(i+1, lenLk):
            L1 = list(Lk[i])[:k-2]; L2 = list(Lk[j])[:k-2]
            L1.sort(); L2.sort()
            if L1==L2:
                retList.append(Lk[i] | Lk[j])
    return retList

def apriori(dataSet, minSupport = 0.5):
    C1 = createC1(dataSet)
    D = map(set, dataSet)
    L1, supportData = scanD(D, C1, minSupport)
    L = [L1]
    k = 2
    while (len(L[k-2]) > 0):
        Ck = aprioriGen(L[k-2], k)
        Lk, supK = scanD(D, Ck, minSupport)
        supportData.update(supK)
        L.append(Lk)
        k += 1
    return L, supportData

dataSet = loadDataSet()
L, suppData = apriori(dataSet, minSupport=0.5)
print(L)
print(suppData)

在这个代码中，我们首先定义了一个数据集。然后我们使用`createC1()`函数创建了初始候选项集。接下来，我们使用`scanD()`函数计算支持度，并得到频繁项集。接着使用`aprioriGen()`函数生成新的候选项集，并使用它计算新的支持度。最后，我们使用`apriori()`函数得到所有的频繁项集以及他们的支持度。