Skip to content
The Chat Archive
gpt-3.5-turbo-0613· OpenAI WildChat-4.8M (AI2)

你知道关联规则算法吗

  1. User

    你知道关联规则算法吗

  2. Assistant

    是的,关联规则算法是一种常见的数据挖掘算法,用于从大规模数据集中发现项之间的关联关系。关联规则算法通过分析数据集中的频繁项集,然后根据这些频繁项集的组合关系生成关联规则。关联规则通常表示为"A->B",表示在数据集中,项集A的出现可以预测项集B的出现。关联规则算法的应用领域包括市场篮子分析、销售预测、网络推荐等。常见的关联规则算法有Apriori算法和FP-Growth算法。

  3. User

    请帮我利用python写出完整的FP-Growth算法代码

  4. Assistant

    下面是一个完整的FP-Growth算法的Python代码示例:

    import pandas as pd
    from collections import defaultdict
    
    
    class FPNode:
        def __init__(self, item, count, parent):
            self.item = item
            self.count = count
            self.parent = parent
            self.children = defaultdict(FPNode)
    
    
    def create_tree(dataset, min_support):
        header_table = defaultdict(int)
        for transaction in dataset:
            for item in transaction:
                header_table[item] += 1
        header_table = {item: count for item, count in header_table.items() if count >= min_support}
        frequent_items = set(header_table.keys())
    
        if len(frequent_items) == 0:
            return None, None
    
        for item in header_table:
            header_table[item] = [header_table[item], None]
    
        fp_tree = FPNode('Null', 1, None)
        for transaction, count in dataset.items():
            frequent_items_in_trans = {}
            for item in transaction:
                if item in frequent_items:
                    frequent_items_in_trans[item] = header_table[item][0]
            if len(frequent_items_in_trans) > 0:
                sorted_items = [item[0] for item in sorted(frequent_items_in_trans.items(),
                                                           key=lambda x: x[1],
                                                           reverse=True)]
                update_tree(sorted_items, fp_tree, header_table, count)
    
        return fp_tree, header_table
    
    
    def update_tree(items, fp_tree, header_table, count):
        if items[0] in fp_tree.children:
            fp_tree.children[items[0]].count += count
        else:
            fp_tree.children[items[0]] = FPNode(items[0], count, fp_tree)
    
            if header_table[items[0]][1] is None:
                header_table[items[0]][1] = fp_tree.children[items[0]]
            else:
                update_header(header_table[items[0]][1], fp_tree.children[items[0]])
    
        if len(items) > 1:
            update_tree(items[1:], fp_tree.children[items[0]], header_table, count)
    
    
    def update_header(node_to_test, target_node):
        while node_to_test.node_link is not None:
            node_to_test = node_to_test.node_link
        node_to_test.node_link = target_node
    
    
    def ascend_tree(leaf_node, prefix_path):
        if leaf_node.parent is not None:
            prefix_path.append(leaf_node.item)
            ascend_tree(leaf_node.parent, prefix_path)
    
    
    def find_prefix_path(base_path, header_table):
        conditional_patterns_base = {}
        for item in base_path:
            prefix_path = []
            ascend_tree(header_table[item][1], prefix_path)
            if len(prefix_path) > 1:
                conditional_patterns_base[frozenset(prefix_path[1:])] = header_table[item][0]
        return conditional_patterns_base
    
    
    def mine_tree(fp_tree, header_table, min_support, prefix, frequent_itemset_list):
        sorted_items = [item[0] for item in sorted(header_table.items(), key=lambda x: x[1][0])]
        for item in sorted_items:
            new_freq_itemset = prefix.copy()
            new_freq_itemset.add(item)
            frequent_itemset_list.append(new_freq_itemset)
            conditional_patterns_base = find_prefix_path(item, header_table)
            conditional_fp_tree, conditional_header_table = create_tree(conditional_patterns_base, min_support)
    
            if conditional_header_table is not None:
                mine_tree(conditional_fp_tree, conditional_header_table, min_support, new_freq_itemset,
                          frequent_itemset_list)
    
    
    def fp_growth(dataset, min_support):
        tree, header_table = create_tree(dataset, min_support)
        frequent_itemset_list = []
        mine_tree(tree, header_table, min_support, set(), frequent_itemset_list)
        return frequent_itemset_list
    
    
    # Example usage:
    transactions = [['bread', 'milk'], ['bread', 'diaper', 'beer', 'egg'], ['milk', 'diaper', 'beer', 'cola'],
                    ['bread', 'milk', 'diaper', 'beer'], ['bread', 'milk', 'diaper', 'cola']]
    
    dataset = defaultdict(int)
    for transaction in transactions:
        dataset[frozenset(transaction)] += 1
    
    min_support = 2
    
    frequent_itemsets = fp_growth(dataset, min_support)
    for itemset in frequent_itemsets:
        print(itemset)
    

    请注意,这只是FP-Growth算法的一个基本实现示例。根据实际需求,您可能需要对其进行一些修改和调整。

  5. User

    关联规则算法python案例

  6. Assistant

    下面是一个关联规则算法的Python案例,使用了mlxtend库中的关联规则生成方法:

    from mlxtend.preprocessing import TransactionEncoder
    from mlxtend.frequent_patterns import apriori, association_rules
    
    # 数据集
    dataset = [['milk', 'bread', 'eggs'],
               ['milk', 'bread', 'butter'],
               ['bread', 'butter'],
               ['milk', 'bread', 'eggs', 'butter'],
               ['milk', 'eggs']]
    
    # TransactionEncoder用于将数据集转换为适用于apriori算法的形式
    te = TransactionEncoder()
    te_ary = te.fit(dataset).transform(dataset)
    df = pd.DataFrame(te_ary, columns=te.columns_)
    
    # 使用apriori算法找出频繁项集
    frequent_itemsets = apriori(df, min_support=0.2, use_colnames=True)
    
    # 根据频繁项集生成关联规则
    rules = association_rules(frequent_itemsets, metric="confidence", min_threshold=0.7)
    
    # 输出结果
    print("频繁项集:")
    print(frequent_itemsets)
    print("\n关联规则:")
    print(rules)
    

    上述代码使用了一个简单的超市购物篮数据集,通过Apriori算法找出频繁项集,然后根据置信度筛选出满足条件的关联规则。

    请注意,这只是一个基本的示例,您可以根据自己的数据集和需求进行适当的调整和修改。