python 调用·apriori库实例

好的，以下是 Python 调用 `apriori` 库的示例代码：

from efficient_apriori import apriori

# 准备数据集
transactions = [('牛奶', '面包', '尿布'),
                ('可乐', '面包', '尿布', '啤酒'),
                ('牛奶', '尿布', '啤酒', '鸡蛋'),
                ('面包', '牛奶', '尿布', '啤酒'),
                ('面包', '牛奶', '尿布', '可乐')]

# 调用 apriori 函数
itemsets, rules = apriori(transactions, min_support=0.5,  min_confidence=1)

# 输出结果
print('频繁项集：', itemsets)
print('关联规则：', rules)

上面的代码使用了 `efficient_apriori` 库，它是一个 Apriori 算法的 Python 实现。首先，我们准备了一个包含多个交易记录的数据集 `transactions`。然后，我们调用了 `apriori` 函数，并指定了最小支持度和最小置信度的阈值。最后，我们输出了频繁项集和关联规则。

相关问题

python调用apriori算法实例

下面是一个用Python调用Apriori算法的简单示例：

首先，你需要安装一个叫做`mlxtend`的Python库，它提供了Apriori算法的实现。你可以通过pip命令来安装：

pip install mlxtend

然后，你可以使用以下代码来调用Apriori算法：

from mlxtend.preprocessing import TransactionEncoder
from mlxtend.frequent_patterns import apriori

# 假设我们有以下交易数据
dataset = [['葡萄酒', '面包', '牛奶'],
           ['葡萄酒', '面包', '尿布', '啤酒', '鸡肉'],
           ['牛奶', '尿布', '啤酒', '可乐'],
           ['面包', '牛奶', '尿布', '啤酒'],
           ['面包', '牛奶', '啤酒', '鸡肉'],
           ['面包', '葡萄酒', '牛奶', '啤酒']]

# 将交易数据转换成布尔矩阵
te = TransactionEncoder()
te_ary = te.fit(dataset).transform(dataset)

# 将布尔矩阵转换成DataFrame
df = pd.DataFrame(te_ary, columns=te.columns_)

# 使用Apriori算法找到频繁项集
frequent_itemsets = apriori(df, min_support=0.5, use_colnames=True)

# 打印频繁项集和它们的支持度
print(frequent_itemsets)

在这个示例中，我们首先定义了一个包含交易数据的列表`dataset`，然后使用`TransactionEncoder`将交易数据转换成布尔矩阵，再将布尔矩阵转换成DataFrame。接着，我们使用`apriori`函数找到频繁项集，并指定最小支持度为0.5。最后，我们打印出频繁项集和它们的支持度。

你可以根据自己的数据和需求来调整代码。

python写的关联规则算法实例

以下是一个简单的 Python 实现 Apriori 关联规则算法的示例代码：

def create_C1(data_set):
    """
    生成候选项集 C1
    :param data_set: 数据集
    :return: 候选项集 C1
    """
    C1 = []
    for transaction in data_set:
        for item in transaction:
            if [item] not in C1:
                C1.append([item])
    C1.sort()
    return list(map(frozenset, C1))

def scan_D(D, Ck, min_support):
    """
    计算候选项集 Ck 中的项集在数据集 D 中的支持度，并返回支持度大于等于 min_support 的项集
    :param D: 数据集
    :param Ck: 候选项集
    :param min_support: 最小支持度
    :return: 支持度大于等于 min_support 的项集，以及所有项集的支持度字典
    """
    ss_cnt = {}
    for tid in D:
        for can in Ck:
            if can.issubset(tid):
                ss_cnt[can] = ss_cnt.get(can, 0) + 1
    num_items = float(len(D))
    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):
    """
    根据频繁项集 Lk 生成候选项集 Ck+1
    :param Lk: 频繁项集 Lk
    :param k: 项集大小
    :return: 候选项集 Ck+1
    """
    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):
    """
    Apriori 算法主函数
    :param data_set: 数据集
    :param min_support: 最小支持度
    :return: 所有频繁项集，以及所有项集的支持度字典
    """
    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, sup_k = scan_D(D, Ck, min_support)
        support_data.update(sup_k)
        L.append(Lk)
        k += 1
    return L, support_data

def generate_rules(L, support_data, min_confidence=0.7):
    """
    根据频繁项集及其支持度字典，生成关联规则
    :param L: 频繁项集列表
    :param support_data: 支持度字典
    :param min_confidence: 最小置信度
    :return: 满足最小置信度的关联规则
    """
    big_rule_list = []
    for i in range(1, len(L)):
        for freq_set in L[i]:
            H1 = [frozenset([item]) for item in freq_set]
            if i > 1:
                rules_from_conseq(freq_set, H1, support_data, big_rule_list, min_confidence)
            else:
                calc_confidence(freq_set, H1, support_data, big_rule_list, min_confidence)
    return big_rule_list

def calc_confidence(freq_set, H, support_data, brl, min_confidence=0.7):
    """
    计算置信度并筛选出满足最小置信度要求的关联规则
    :param freq_set: 频繁项集
    :param H: 可出现在规则右部的项集列表
    :param support_data: 支持度字典
    :param brl: 关联规则列表
    :param min_confidence: 最小置信度
    """
    pruned_h = []
    for conseq in H:
        conf = support_data[freq_set] / support_data[freq_set - conseq]
        if conf >= min_confidence:
            print(freq_set - conseq, '-->', conseq, 'conf:', conf)
            brl.append((freq_set - conseq, conseq, conf))
            pruned_h.append(conseq)
    return pruned_h

def rules_from_conseq(freq_set, H, support_data, brl, min_confidence=0.7):
    """
    根据当前规则右部的项集列表，生成新的候选规则右部的项集列表
    :param freq_set: 频繁项集
    :param H: 可出现在规则右部的项集列表
    :param support_data: 支持度字典
    :param brl: 关联规则列表
    :param min_confidence: 最小置信度
    """
    m = len(H[0])
    if len(freq_set) > (m + 1):
        Hmp1 = apriori_gen(H, m + 1)
        Hmp1 = calc_confidence(freq_set, Hmp1, support_data, brl, min_confidence)
        if len(Hmp1) > 1:
            rules_from_conseq(freq_set, Hmp1, support_data, brl, min_confidence)

以上代码实现了 Apriori 算法的主要功能，包括生成候选项集、计算支持度、生成频繁项集、计算置信度、生成关联规则等。通过调用 `apriori()` 函数和 `generate_rules()` 函数，可以得到所有频繁项集和满足最小置信度要求的关联规则。