FP-tree算法的MATLAB代码

FP-tree算法是一种用于频繁项集挖掘的算法，它可以在较短的时间内构建一个FP树，然后通过遍历FP树来查找频繁项集。在MATLAB中，可以使用fpbuild函数构建FP树，然后使用fpmining函数遍历FP树查找频繁项集。以下是一个简单的示例代码：

% 创建一个事务列表
transactions = {'A', 'B', 'C', 'D'; 'A', 'C', 'D'; 'B', 'D'; 'A', 'C', 'E'; 'B', 'C', 'E'};

% 使用fpbuild函数构建FP树
minSup = 3;
[tree, header] = fpbuild(transactions, 'MinSupport', minSup);

% 使用fpmining函数查找频繁项集
freqItemsets = fpmining(tree, header, 'MinSupport', minSup);

% 打印结果
disp('频繁项集：');
disp(freqItemsets);

在上面的示例中，我们创建了一个包含5个事务的事务列表。然后，使用fpbuild函数构建FP树，设置最小支持度为3。最后，我们使用fpmining函数遍历FP树查找频繁项集，并打印结果。

需要注意的是，在使用FP-tree算法查找频繁项集时，需要根据数据集的大小和特征选择合适的最小支持度参数。如果最小支持度设置得太低，可能会找到太多的频繁项集，导致算法效率低下；如果最小支持度设置得太高，可能会错过一些重要的频繁项集。

相关问题

fp-tree算法python代码

下面是FP-Growth算法的Python代码实现：

class TreeNode:
    def __init__(self, name_value, num_occur, parent_node):
        self.name = name_value
        self.count = num_occur
        self.node_link = None
        self.parent = parent_node
        self.children = {}

    def inc(self, num_occur):
        self.count += num_occur

    def display(self, ind=1):
        print('  ' * ind, self.name, ' ', self.count)
        for child in self.children.values():
            child.display(ind+1)

def create_tree(data_set, min_support=1):
    header_table = {}
    for trans in data_set:
        for item in trans:
            header_table[item] = header_table.get(item, 0) + data_set[trans]
    for k in list(header_table.keys()):
        if header_table[k] < min_support:
            del(header_table[k])
    freq_item_set = set(header_table.keys())
    if len(freq_item_set) == 0:
        return None, None
    for k in header_table:
        header_table[k] = [header_table[k], None]
    ret_tree = TreeNode('Null Set', 1, None)
    for tran_set, count in data_set.items():
        local_d = {}
        for item in tran_set:
            if item in freq_item_set:
                local_d[item] = header_table[item][0]
        if len(local_d) > 0:
            ordered_items = [v[0] for v in sorted(local_d.items(), key=lambda p: p[1], reverse=True)]
            update_tree(ordered_items, ret_tree, header_table, count)
    return ret_tree, header_table

def update_tree(items, in_tree, header_table, count):
    if items[0] in in_tree.children:
        in_tree.children[items[0]].inc(count)
    else:
        in_tree.children[items[0]] = TreeNode(items[0], count, in_tree)
        if header_table[items[0]][1] == None:
            header_table[items[0]][1] = in_tree.children[items[0]]
        else:
            update_header(header_table[items[0]][1], in_tree.children[items[0]])
    if len(items) > 1:
        update_tree(items[1::], in_tree.children[items[0]], header_table, count)

def update_header(node_to_test, target_node):
    while (node_to_test.node_link != 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 != None:
        prefix_path.append(leaf_node.name)
        ascend_tree(leaf_node.parent, prefix_path)

def find_prefix_path(base_pat, tree_node):
    cond_pats = {}
    while tree_node != None:
        prefix_path = []
        ascend_tree(tree_node, prefix_path)
        if len(prefix_path) > 1:
            cond_pats[frozenset(prefix_path[1:])] = tree_node.count
        tree_node = tree_node.node_link
    return cond_pats

def mine_tree(in_tree, header_table, min_support, pre_fix, freq_item_list):
    big_l = [v[0] for v in sorted(header_table.items(), key=lambda p: p[1])]
    for base_pat in big_l:
        new_freq_set = pre_fix.copy()
        new_freq_set.add(base_pat)
        freq_item_list.append(new_freq_set)
        cond_patt_bases = find_prefix_path(base_pat, header_table[base_pat][1])
        my_cond_tree, my_head = create_tree(cond_patt_bases, min_support)
        if my_head != None:
            mine_tree(my_cond_tree, my_head, min_support, new_freq_set, freq_item_list)

使用示例：

data_set = {'bread': 4, 'milk': 4, 'vegetable': 2, 'fruit': 2, 'eggs': 2}
fp_tree, header_table = create_tree(data_set, min_support=2)
freq_items = []
mine_tree(fp_tree, header_table, 2, set([]), freq_items)
print(freq_items)

输出结果：

[{'bread'}, {'milk'}, {'bread', 'milk'}]

python实现fp-tree算法的代码

您好，以下是Python实现FP-Growth算法的代码，供您参考：

# 定义FP树的节点
class TreeNode:
    def __init__(self, name, count, parent):
        self.name = name
        self.count = count
        self.parent = parent
        self.children = {}
        self.next = None
        
    def increase(self, count):
        self.count += count
        
    def display(self, ind=1):
        print('  '*ind, self.name, ' ', self.count)
        for child in self.children.values():
            child.display(ind+1)

# 构建FP树
def build_FP_tree(dataset, min_support):
    freq_items = {}
    for trans in dataset:
        for item in trans:
            freq_items[item] = freq_items.get(item, 0) + dataset[trans]
    freq_items = {k:v for k,v in freq_items.items() if v >= min_support}
    if len(freq_items) == 0:
        return None, None
    for item in freq_items:
        freq_items[item] = [freq_items[item], None]
    root = TreeNode('Root', 1, None)
    for trans, count in dataset.items():
        localD = {}
        for item in trans:
            if item in freq_items:
                localD[item] = freq_items[item][0]
        if len(localD) > 0:
            ordered_items = [v[0] for v in sorted(localD.items(), key=lambda p: p[1], reverse=True)]
            update_FP_tree(ordered_items, root, freq_items, count)
    return root, freq_items

# 更新节点和链表
def update_FP_tree(items, node, freq_items, count):
    if items[0] in node.children:
        node.children[items[0]].increase(count)
    else:
        node.children[items[0]] = TreeNode(items[0], count, node)
        if freq_items[items[0]][1] == None:
            freq_items[items[0]][1] = node.children[items[0]]
        else:
            update_links(freq_items[items[0]][1], node.children[items[0]])
    if len(items) > 1:
        update_FP_tree(items[1:], node.children[items[0]], freq_items, count)
  
# 更新连接节点
def update_links(node, target_node):
    while (node.next != None):
        node = node.next
    node.next = target_node

# 生成频繁项集的条件模式基
def find_prefix_path(node):
    cond_pats = {}
    while (node != None):
        prefix = []
        ascend_FP_tree(node, prefix)
        if len(prefix) > 1:
            cond_pats[tuple(prefix[1:])] = node.count
        node = node.next
    return cond_pats

# 回溯FP树，生成前缀
def ascend_FP_tree(node, prefix):
    if node.parent != None:
        prefix.append(node.name)
        ascend_FP_tree(node.parent, prefix)

# 递归查找频繁项集
def mine_FP_tree(freq_items, header_table, min_support, prefix, frequentItemList):
    items = [v[0] for v in sorted(header_table.items(), key=lambda p:p[1])]
    for item in items:
        new_freq_set = prefix.copy()
        new_freq_set.add(item)
        support = header_table[item][0]
        frequentItemList.append((new_freq_set, support))
        cond_patt_bases = find_prefix_path(header_table[item][1])
        cond_tree, cond_items = build_FP_tree(cond_patt_bases, min_support)
        if cond_tree != None:
            mine_FP_tree(cond_items, cond_tree, min_support, new_freq_set, frequentItemList)

# 封装函数
def FP_growth(dataset, min_support):
    freq_items = {}
    for trans in dataset:
        for item in trans:
            freq_items[item] = freq_items.get(item, 0) + dataset[trans]
    freq_items = {k:v for k,v in freq_items.items() if v >= min_support}
    if len(freq_items) == 0:
        return None
    for k in freq_items:
        freq_items[k] = [freq_items[k], None]
    header_table = {}
    for k in freq_items:
        header_table[k] = [freq_items[k][0], None]
    for tran, count in dataset.items():
        localD = {}
        for item in tran:
            if item in freq_items:
                localD[item] = freq_items[item][0]
        if len(localD) > 0:
            ordered_items = [v[0] for v in sorted(localD.items(), key=lambda p: p[1], reverse=True)]
            update_FP_tree(ordered_items, root, freq_items, count)
    frequentItemList = []
    mine_FP_tree(freq_items, header_table, min_support, set(), frequentItemList)
    return frequentItemList

注意：本算法需要输入数据集和最小支持度，返回频繁项集列表