频繁模式挖掘中的剪枝策略

合集下载

基于滑动窗口数据流频繁项集挖掘模型综述

基于滑动窗口数据流频繁项集挖掘模型综述

基于滑动窗口数据流频繁项集挖掘模型综述王红梅;李芬田;王泽儒【摘要】给出了频繁项集和滑动窗口的相关定义,根据数据流中不同的时序范围对数据流模型进行了分类,从数据处理模型的角度对滑动窗口进行了分类.分析了典型的频繁项集挖掘算法中滑动窗口的使用方法,总结了各模型中典型频繁项集挖掘算法的挖掘技术和效率.【期刊名称】《长春工业大学学报(自然科学版)》【年(卷),期】2017(038)005【总页数】7页(P484-490)【关键词】数据流;频繁项集;滑动窗口;数据处理模型【作者】王红梅;李芬田;王泽儒【作者单位】长春工业大学计算机科学与工程学院,吉林长春 130012;长春工业大学计算机科学与工程学院,吉林长春 130012;长春工业大学计算机科学与工程学院,吉林长春 130012【正文语种】中文【中图分类】TP301数据流是一种潜在无限、快速、连续、随时间不断变化的数据序列[1]。

数据流是一种新型的数据模型,至今为止已经出现在许多种应用中,如通信数据管理、网络监控、股票交易数据分析以及商品销售分析等。

与传统的静态数据相比,数据流具有无序性、连续性、实时性和无界性的特点[2],使得数据流挖掘算法满足以下几个条件[3]:1)当分析数据流的时候,最多只能访问一次所有的数据元素;2)虽然在数据流中连续不断地产生数据元素,但是必须满足有限的分析数据流所需要的内存空间;3)新产生的数据必须尽可能快地处理,要求具有很高的算法实时性;4)当用户提交查询时,最新的数据流分析结果必须被快速并且及时反馈出来,它有很高的算法时间效率。

因此在今后的发展中,数据流挖掘具有更大的挑战意义。

在实际应用中,近期数据是大部分人感兴趣的焦点,所以在一般情况下,数据流的挖掘都是基于某个时间段内对数据进行挖掘和研究,从而出现了很多种不同的窗口模型。

在此基础上根据数据流中不同的时序范围,可以把数据流的模型分为以下3种[4]:1)界标窗口模型。

起始时间是固定的,而结束时间是变化的。

频繁项集挖掘算法

频繁项集挖掘算法

频繁项集挖掘算法 FP-GrowthApriori算法和FPTree算法都是数据挖掘中的关联规则挖掘算法,处理的都是最简单的单层单维布尔关联规则。

Apriori算法Apriori算法是⼀种最有影响的挖掘布尔关联规则频繁项集的算法。

是基于这样的事实:算法使⽤频繁项集性质的先验知识。

Apriori使⽤⼀种称作逐层搜索的迭代⽅法,k-项集⽤于探索(k+1)-项集。

⾸先,找出频繁1-项集的集合。

该集合记作L1。

L1⽤于找频繁2-项集的集合L2,⽽L2⽤于找L3,如此下去,直到不能找到频繁k-项集。

找每个L k需要⼀次数据库扫描。

这个算法的思路,简单的说就是如果集合I不是频繁项集,那么所有包含集合I的更⼤的集合也不可能是频繁项集。

算法原始数据如下:TID List of item_ID’sT100 T200 T300 T400 T500 T600 T700 T800 T900I1,I2,I5 I2,I4I2,I3I1,I2,I4 I1,I3I2,I3I1,I3I1,I2,I3,I5 I1,I2,I3算法的基本过程如下图:⾸先扫描所有事务,得到1-项集C1,根据⽀持度要求滤去不满⾜条件项集,得到频繁1-项集。

下⾯进⾏递归运算:已知频繁k-项集(频繁1-项集已知),根据频繁k-项集中的项,连接得到所有可能的K+1_项,并进⾏剪枝(如果该k+1_项集的所有k项⼦集不都能满⾜⽀持度条件,那么该k+1_项集被剪掉),得到项集,然后滤去该项集中不满⾜⽀持度条件的项得到频繁k+1-项集。

如果得到的项集为空,则算法结束。

连接的⽅法:假设项集中的所有项都是按照相同的顺序排列的,那么如果[i]和[j]中的前k-1项都是完全相同的,⽽第k项不同,则[i]和[j]是可连接的。

⽐如中的{I1,I2}和{I1,I3}就是可连接的,连接之后得到{I1,I2,I3},但是{I1,I2}和{I2,I3}是不可连接的,否则将导致项集中出现重复项。

基于关联图的频繁闭模式挖掘

基于关联图的频繁闭模式挖掘

第 2期

璇 :基 于关联 图的频 繁 闭模 式挖 掘
・l5・ 5
八 … 八 结果中 “ ” 的数 目 (“ 1 ^” 表示 逻辑与运算 ) 。 例如 ,表 1 所示 的一个事务数据库 D,每条记 录是为该事务所对应 的项的集合 。
表 1 事务数据库 D
B BV4
Байду номын сангаас
事 务标 识
提 出基 于 关 联 图 的 频 繁 闭 模 式 挖 掘 算 法 MF IG CB
( nn rq et l e e e ae n G ah 。 MiigFe u n o dI mst B sdo rp ) Cs t s 1 构造 关联 图
远小于频繁模式 ,但从中可以推导出所有的频繁模 式。最大频繁模式是频繁模式的最小压缩 ,但没有 记录相应频繁子集的支持度信息 ,不便产生关联规 则 ;而 频繁 闭模 式虽 然规模 比最 大频 繁 模式 大 ,但 同时包含了频繁子集的支持度信息 ,在生成关联规 则 时可 以直 接使用 。
与 以上算 法思 想不 同 的是 ,So hw—Jn e 出的 aeY n提
式转化成垂直 数据库形式 。项 的位 向量构造方 法 为 :位向量的每一位均对应着数据库中的事务项 , 其长度等于总事务数 ,若该项 在第 n 事务 中出 个
现 ,则其 位 向 量 的第 n位 置 1 ,否 则 置 0,项 i 的
1o o 2o o 3o 0
40 0
项集
口, b c , a, b c , ,d
b ,c,e a,c d,e , d,e

BV ;
图1根据表2 生成的关联图
5o 0
扫描数据库 ,将表 1中的每个项用相应的位 向 量 表 示 ,则 表 1的数据 库可 以表 示成 如 表 2所示 的 垂直数据库形式 。

频繁模式挖掘中Apriori、FP-Growth和Eclat算法的实现和对比(Python实现)

频繁模式挖掘中Apriori、FP-Growth和Eclat算法的实现和对比(Python实现)

频繁模式挖掘中Apriori、FP-Growth和Eclat算法的实现和对⽐(Python实现)最近上数据挖掘的课程,其中学习到了频繁模式挖掘这⼀章,这章介绍了三种算法,Apriori、FP-Growth和Eclat算法;由于对于不同的数据来说,这三种算法的表现不同,所以我们本次就对这三种算法在不同情况下的效率进⾏对⽐。

从⽽得出适合相应算法的情况。

GitHub:(⼀)算法原理其中相应的算法原理在之前的博客中都有⾮常详细的介绍,这⾥就不再赘述,这⾥给出三种算法⼤概的介绍但是这⾥给出每个算法的关键点:1.1 Apriori算法:限制候选产⽣发现频繁项集重要性质:频繁项集所有⾮空⼦集也⼀定是频繁的。

主要步骤:1. 连接2. 剪枝特点:需要多次扫描数据库,对于⼤规模数据效率很低!1.2 FP-Growth算法通过模式增长挖掘频繁模式主要步骤:1. 构建频繁模式树2. 构造条件模式基3. 挖掘频繁模式特点:两次扫描数据库,采⽤分治的策略有效降低搜索开销1.3 Eclat算法使⽤垂直格式挖掘频繁项集主要步骤:1. 将数据倒排{ item:TID_set }2. 通过求频繁k项集的交集来获取k+1项集特点:仅需要⼀次扫描数据库,TID集合很长的话需要消耗⼤量的内存和计算时间(⼆)算法实现由于各个博客给出的算法实现并不统⼀,⽽且本⼈在实现《机器学习实战》中FP-Growth算法的时候发现,在在创建FP-Tree时根据headTable中元素的⽀持度顺序的排序过程中,这个地⽅的排序⽅法写的有问题,当在模式稠密时,具有很多⽀持度相同的项集,书中的代码并没有考虑着⼀点,所以如果遇到⽀持度相同的项集那个就会出现⼀定的随机性,导致建树过程出错,最后的频繁项集结果会偏⼩,因此这⾥对改错误进⾏了纠正,在⽀持度相同时,添加了按照项集排序的规则,这样建⽴的FP-Tree才完全正确。

1.1 Apriori算法实现:1# -*- coding: utf-8 -*-2'''3@author: Infaraway4@time: 2017/4/15 12:545@Function:6'''789def init_c1(data_set_dict, min_support):10 c1 = []11 freq_dic = {}12for trans in data_set_dict:13for item in trans:14 freq_dic[item] = freq_dic.get(item, 0) + data_set_dict[trans]15# 优化初始的集合,使不满⾜最⼩⽀持度的直接排除16 c1 = [[k] for (k, v) in freq_dic.iteritems() if v >= min_support]17 c1.sort()18return map(frozenset, c1)192021def scan_data(data_set, ck, min_support, freq_items):22"""23计算Ck中的项在数据集合中的⽀持度,剪枝过程24 :param data_set:25 :param ck:26 :param min_support: 最⼩⽀持度27 :param freq_items: 存储满⾜⽀持度的频繁项集28 :return:29"""30 ss_cnt = {}31# 每次遍历全体数据集32for trans in data_set:33for item in ck:34# 对每⼀个候选项集,检查是否是 term中的⼀部分(⼦集),即候选项能否得到⽀持35if item.issubset(trans):36 ss_cnt[item] = ss_cnt.get(item, 0) + 137 ret_list = []38for key in ss_cnt:39 support = ss_cnt[key] # 每个项的⽀持度40if support >= min_support:41 ret_list.insert(0, key) # 将满⾜最⼩⽀持度的项存⼊集合42 freq_items[key] = support #43return ret_list444546def apriori_gen(lk, k):47"""48由Lk的频繁项集⽣成新的候选项集连接过程49 :param lk: 频繁项集集合50 :param k: k 表⽰集合中所含的元素个数51 :return: 候选项集集合52"""53 ret_list = []54for i in range(len(lk)):55for j in range(i+1, len(lk)):56 l1 = list(lk[i])[:k-2]57 l2 = list(lk[j])[:k-2]58 l1.sort()59 l2.sort()60if l1 == l2:61 ret_list.append(lk[i] | lk[j]) # 求并集62# retList.sort()63return ret_list646566def apriori_zc(data_set, data_set_dict, min_support=5):67"""68 Apriori算法过程69 :param data_set: 数据集70 :param min_support: 最⼩⽀持度,默认值 0.571 :return:72"""73 c1 = init_c1(data_set_dict, min_support)74 data = map(set, data_set) # 将dataSet集合化,以满⾜scanD的格式要求75 freq_items = {}76 l1 = scan_data(data, c1, min_support, freq_items) # 构建初始的频繁项集77 l = [l1]78# 最初的L1中的每个项集含有⼀个元素,新⽣成的项集应该含有2个元素,所以 k=279 k = 280while len(l[k - 2]) > 0:81 ck = apriori_gen(l[k - 2], k)82 lk = scan_data(data, ck, min_support, freq_items)83 l.append(lk)84 k += 1 # 新⽣成的项集中的元素个数应不断增加85return freq_itemsView Code1.2 FP-Growth算法实现:1)FP_Growth⽂件:在create_tree()函数中修改《机器学习实战》中的代码:############################################################################################## # 这⾥修改机器学习实战中的排序代码:ordered_items = [v[0] for v in sorted(local_data.items(), key=lambda kv: (-kv[1], kv[0]))]##############################################################################################1# -*- coding: utf-8 -*-2"""3@author: Infaraway4@time: 2017/4/15 16:075@Function:6"""7from DataMining.Unit6_FrequentPattern.FP_Growth.TreeNode import treeNode8910def create_tree(data_set, min_support=1):11"""12创建FP树13 :param data_set: 数据集14 :param min_support: 最⼩⽀持度15 :return:16"""17 freq_items = {} # 频繁项集18for trans in data_set: # 第⼀次遍历数据集19for item in trans:20 freq_items[item] = freq_items.get(item, 0) + data_set[trans]2122 header_table = {k: v for (k, v) in freq_items.iteritems() if v >= min_support} # 创建头指针表23# for key in header_table:24# print key, header_table[key]2526# ⽆频繁项集27if len(header_table) == 0:28return None, None29for k in header_table:30 header_table[k] = [header_table[k], None] # 添加头指针表指向树中的数据31# 创建树过程32 ret_tree = treeNode('Null Set', 1, None) # 根节点3334# 第⼆次遍历数据集35for trans, count in data_set.items():36 local_data = {}37for item in trans:38if header_table.get(item, 0):39 local_data[item] = header_table[item][0]40if len(local_data) > 0:41############################################################################################## 42# 这⾥修改机器学习实战中的排序代码:43 ordered_items = [v[0] for v in sorted(local_data.items(), key=lambda kv: (-kv[1], kv[0]))]44############################################################################################## 45 update_tree(ordered_items, ret_tree, header_table, count) # populate tree with ordered freq itemset46return ret_tree, header_table474849def update_tree(items, in_tree, header_table, count):50'''51 :param items: 元素项52 :param in_tree: 检查当前节点53 :param header_table:54 :param count:55 :return:56'''57if items[0] in in_tree.children: # check if ordered_items[0] in ret_tree.children58 in_tree.children[items[0]].increase(count) # incrament count59else: # add items[0] to in_tree.children60 in_tree.children[items[0]] = treeNode(items[0], count, in_tree)61if header_table[items[0]][1] is None: # update header table62 header_table[items[0]][1] = in_tree.children[items[0]]63else:64 update_header(header_table[items[0]][1], in_tree.children[items[0]])65if len(items) > 1: # call update_tree() with remaining ordered items66 update_tree(items[1::], in_tree.children[items[0]], header_table, count)676869def update_header(node_test, target_node):70'''71 :param node_test:72 :param target_node:73 :return:74'''75while node_test.node_link is not None: # Do not use recursion to traverse a linked list!76 node_test = node_test.node_link77 node_test.node_link = target_node787980def ascend_tree(leaf_node, pre_fix_path):81'''82遍历⽗节点,找到路径83 :param leaf_node:84 :param pre_fix_path:85 :return:86'''87if leaf_node.parent is not None:88 pre_fix_path.append(leaf_)89 ascend_tree(leaf_node.parent, pre_fix_path)909192def find_pre_fix_path(base_pat, tree_node):93'''94创建前缀路径95 :param base_pat: 频繁项96 :param treeNode: FP树中对应的第⼀个节点97 :return:98'''99# 条件模式基100 cond_pats = {}101while tree_node is not None:102 pre_fix_path = []103 ascend_tree(tree_node, pre_fix_path)104if len(pre_fix_path) > 1:105 cond_pats[frozenset(pre_fix_path[1:])] = tree_node.count106 tree_node = tree_node.node_link107return cond_pats108109110def mine_tree(in_tree, header_table, min_support, pre_fix, freq_items):111'''112挖掘频繁项集113 :param in_tree:114 :param header_table:115 :param min_support:116 :param pre_fix:117 :param freq_items:118 :return:119'''120# 从⼩到⼤排列table中的元素,为遍历寻找频繁集合使⽤121 bigL = [v[0] for v in sorted(header_table.items(), key=lambda p: p[1])] # (sort header table) 122for base_pat in bigL: # start from bottom of header table123 new_freq_set = pre_fix.copy()124 new_freq_set.add(base_pat)125# print 'finalFrequent Item: ',new_freq_set #append to set126if len(new_freq_set) > 0:127 freq_items[frozenset(new_freq_set)] = header_table[base_pat][0]128 cond_patt_bases = find_pre_fix_path(base_pat, header_table[base_pat][1])129 my_cond_tree, my_head = create_tree(cond_patt_bases, min_support)130# print 'head from conditional tree: ', my_head131if my_head is not None: # 3. mine cond. FP-tree132# print 'conditional tree for: ',new_freq_set133# my_cond_tree.disp(1)134 mine_tree(my_cond_tree, my_head, min_support, new_freq_set, freq_items)135136137def fp_growth(data_set, min_support=1):138 my_fp_tree, my_header_tab = create_tree(data_set, min_support)139# my_fp_tree.disp()140 freq_items = {}141 mine_tree(my_fp_tree, my_header_tab, min_support, set([]), freq_items)142return freq_itemsView Code2)treeNode对象⽂件1# -*- coding: utf-8 -*-2'''3@author: Infaraway4@time: 2017/3/31 0:145@Function:6'''789class treeNode:10def__init__(self, name_value, num_occur, parent_node):11 = name_value # 节点元素名称12 self.count = num_occur # 出现的次数13 self.node_link = None # 指向下⼀个相似节点的指针,默认为None14 self.parent = parent_node # 指向⽗节点的指针15 self.children = {} # 指向孩⼦节点的字典⼦节点的元素名称为键,指向⼦节点的指针为值1617def increase(self, num_occur):18"""19增加节点的出现次数20 :param num_occur: 增加数量21 :return:22"""23 self.count += num_occur2425def disp(self, ind=1):26print'' * ind, , '', self.count27for child in self.children.values():28 child.disp(ind + 1)View Code1.3 Eclat算法实现1# -*- coding: utf-8 -*-2"""3@author: Infaraway4@time: 2017/4/15 19:335@Function:6"""78import sys9import time10 type = sys.getfilesystemencoding()111213def eclat(prefix, items, min_support, freq_items):14while items:15# 初始遍历单个的元素是否是频繁16 key, item = items.pop()17 key_support = len(item)18if key_support >= min_support:19# print frozenset(sorted(prefix+[key]))20 freq_items[frozenset(sorted(prefix+[key]))] = key_support21 suffix = [] # 存储当前长度的项集22for other_key, other_item in items:23 new_item = item & other_item # 求和其他集合求交集24if len(new_item) >= min_support:25 suffix.append((other_key, new_item))26 eclat(prefix+[key], sorted(suffix, key=lambda item: len(item[1]), reverse=True), min_support, freq_items)27return freq_items282930def eclat_zc(data_set, min_support=1):31"""32 Eclat⽅法33 :param data_set:34 :param min_support:35 :return:36"""37# 将数据倒排38 data = {}39 trans_num = 040for trans in data_set:41 trans_num += 142for item in trans:43if item not in data:44 data[item] = set()45 data[item].add(trans_num)46 freq_items = {}47 freq_items = eclat([], sorted(data.items(), key=lambda item: len(item[1]), reverse=True), min_support, freq_items)48return freq_itemsView Code(三)试验阶段:这样我们就统⼀了三种算法的调⽤以及返回值,现在我们可以开始试验阶段了,我们在试验阶段分别根据最⼩⽀持度阈值和数据规模的变化来判断这三种算法的效率:⾸先我们先统⼀调⽤者三个算法:1def test_fp_growth(minSup, dataSetDict, dataSet):2 freqItems = fp_growth(dataSetDict, minSup)3 freqItems = sorted(freqItems.iteritems(), key=lambda item: item[1])4return freqItems567def test_apriori(minSup, dataSetDict, dataSet):8 freqItems = apriori_zc(dataSet, dataSetDict, minSup)9 freqItems = sorted(freqItems.iteritems(), key=lambda item: item[1])10return freqItems111213def test_eclat(minSup, dataSetDict, dataSet):14 freqItems = eclat_zc(dataSet, minSup)15 freqItems = sorted(freqItems.iteritems(), key=lambda item: item[1])16return freqItems然后实现数据规模变化的效率改变1def do_experiment_min_support():23 data_name = 'unixData8_pro.txt'4 x_name = "Min_Support"5 data_num = 15006 minSup = data_num / 678 dataSetDict, dataSet = loadDblpData(open("dataSet/" + data_name), ',', data_num)9 step = minSup / 5 # #################################################################10 all_time = []11 x_value = []12for k in range(5):1314 x_value.append(minSup) # ################################################################# 15if minSup < 0: # #################################################################16break17 time_fp = 018 time_et = 019 time_ap = 020 freqItems_fp = {}21 freqItems_eclat = {}22 freqItems_ap = {}23for i in range(10):24 ticks0 = time.time()25 freqItems_fp = test_fp_growth(minSup, dataSetDict, dataSet)26 time_fp += time.time() - ticks027 ticks0 = time.time()28 freqItems_eclat = test_eclat(minSup, dataSetDict, dataSet)29 time_et += time.time() - ticks030 ticks0 = time.time()31 freqItems_ap = test_apriori(minSup, dataSetDict, dataSet)32 time_ap += time.time() - ticks033print"minSup :", minSup, " data_num :", data_num, \34" freqItems_fp:", len(freqItems_fp), " freqItems_eclat:", len(freqItems_eclat), " freqItems_ap:", len(35 freqItems_ap)36print"fp_growth:", time_fp / 10, " eclat:", time_et / 10, " apriori:", time_ap / 1037# print_freqItems("show", freqItems_eclat)38 minSup -= step # #################################################################39 use_time = [time_fp / 10, time_et / 10, time_ap / 10]40 all_time.append(use_time)41# print use_time42 y_value = []43for i in range(len(all_time[0])):44 tmp = []45for j in range(len(all_time)):46 tmp.append(all_time[j][i])47 y_value.append(tmp)48 plot_pic(x_value, y_value, data_name, x_name)49return x_value, y_valueView Code然后实现最⼩⽀持度变化的效率改变1def do_experiment_data_size():23 data_name = 'kosarakt.txt'4 x_name = "Data_Size"5 data_num = 20000067 step = data_num / 5 # #################################################################8 all_time = []9 x_value = []10for k in range(5):11 minSup = data_num * 0.01012 dataSetDict, dataSet = loadDblpData(open("dataSet/"+data_name), '', data_num)13 x_value.append(data_num) # #################################################################14if data_num < 0: # #################################################################15break16 time_fp = 017 time_et = 018 time_ap = 019 freqItems_fp = {}20 freqItems_eclat = {}21 freqItems_ap = {}22for i in range(2):23 ticks0 = time.time()24 freqItems_fp = test_fp_growth(minSup, dataSetDict, dataSet)25 time_fp += time.time() - ticks026 ticks0 = time.time()27 freqItems_eclat = test_eclat(minSup, dataSetDict, dataSet)28 time_et += time.time() - ticks029 ticks0 = time.time()30# freqItems_ap = test_apriori(minSup, dataSetDict, dataSet)31# time_ap += time.time() - ticks032print"minSup :", minSup, " data_num :", data_num, \33" freqItems_fp:", len(freqItems_fp), " freqItems_eclat:", len(freqItems_eclat), " freqItems_ap:", len(freqItems_ap) 34print"fp_growth:", time_fp / 10, " eclat:", time_et / 10, " apriori:", time_ap / 1035# print_freqItems("show", freqItems_eclat)36 data_num -= step # #################################################################37 use_time = [time_fp / 10, time_et / 10, time_ap / 10]38 all_time.append(use_time)39# print use_time4041 y_value = []42for i in range(len(all_time[0])):43 tmp = []44for j in range(len(all_time)):45 tmp.append(all_time[j][i])46 y_value.append(tmp)47 plot_pic(x_value, y_value, data_name, x_name)48return x_value, y_valueView Code同时为了观察⽅便,我们需要对三种算法返回的结果进⾏绘图1# -*- coding: utf-8 -*-2"""3@author: Infaraway4@time: 2017/4/16 20:485@Function:6"""78import matplotlib.pyplot as plt91011def plot_pic(x_value, y_value, title, x_name):12 plot1 = plt.plot(x_value, y_value[0], 'r', label='Kulc') # use pylab to plot x and y13 plot2 = plt.plot(x_value, y_value[1], 'g', label='IR') # use pylab to plot x and y14# plot3 = plt.plot(x_value, y_value[2], 'b', label='Apriori') # use pylab to plot x and y15 plt.title(title) # give plot a title16 plt.xlabel(x_name) # make axis labels17 plt.ylabel('value ')18 plt.legend(loc='upper right') # make legend1920 plt.show() # show the plot on the screenView Code将两个部分统⼀执⾏:1if__name__ == '__main__':23# x_value, y_value = do_experiment_min_support()4# x_value, y_value = do_experiment_data_size()5# do_test()(四)实验结果分析:本次实验我们主要从以下⼏个⽅⾯来讨论三种算法的效率:数据规模⼤⼩最⼩⽀持度阈值长事物数据模式的稠密性4.1 数据规模⼤⼩:数据集:unxiData8规模:900-1500Min_support = 1/30时 Min_support = 1/20时数据集:kosarakt规模:6000-10000Min_support = 1/50 Min_support = 1/80 Min_support = 1/100结论:⼀般情况下,数据规模越⼤,使⽤Apriori算法的效率越低,因为该算法需要多次扫描数据库,当数据量越⼤时,扫描数据库带来的消耗越多。

《基于并行频繁模式挖掘算法的博客推荐系统的设计与实现》范文

《基于并行频繁模式挖掘算法的博客推荐系统的设计与实现》范文

《基于并行频繁模式挖掘算法的博客推荐系统的设计与实现》篇一一、引言随着互联网的飞速发展,信息过载问题日益严重。

对于用户来说,如何在海量的信息中快速找到自己感兴趣的内容成为了一个亟待解决的问题。

推荐系统因此应运而生,其中,基于频繁模式挖掘的推荐系统因其准确性和有效性受到了广泛关注。

本文将介绍一种基于并行频繁模式挖掘算法的博客推荐系统的设计与实现。

二、系统需求分析1. 用户需求:系统需要能够为用户推荐其可能感兴趣的博客文章,同时提供个性化推荐服务。

2. 数据特点:博客文章数据量大,且具有时效性,需要设计高效的数据处理和存储方案。

3. 技术要求:系统需要支持并行计算,以提高数据处理速度和推荐准确性。

三、系统设计1. 数据预处理:对博客文章进行分词、去除停用词等操作,提取出特征词。

2. 频繁模式挖掘:采用并行频繁模式挖掘算法,对特征词进行频繁模式挖掘,得出博客文章的关联规则。

3. 用户行为分析:通过分析用户的历史浏览记录和点击行为,得出用户的兴趣偏好。

4. 推荐算法:结合频繁模式挖掘结果和用户兴趣偏好,采用协同过滤等算法进行推荐。

5. 系统架构:采用分布式架构,将数据存储在Hadoop等大数据平台上,利用Spark等计算框架进行并行计算。

四、并行频繁模式挖掘算法1. 算法原理:并行频繁模式挖掘算法是一种基于分布式计算的频繁模式挖掘算法。

它通过将数据集分割成多个子集,并在多个计算节点上并行处理子集,从而加快了数据处理速度。

2. 算法实现:在实现过程中,需要设计合理的任务划分策略、数据传输策略和结果合并策略。

同时,为了确保算法的准确性,需要采用一定的剪枝策略来减少搜索空间。

五、系统实现1. 数据存储:将博客文章数据存储在Hadoop等大数据平台上,以便进行高效的读写操作。

2. 数据处理:利用Spark等计算框架进行并行计算,提高数据处理速度。

3. 推荐服务:结合频繁模式挖掘结果和用户兴趣偏好,采用协同过滤等算法进行推荐。

一种分布式全局频繁项集挖掘方法

一种分布式全局频繁项集挖掘方法
C m ue n ier ga dA pi t n 计算机工程与应用 o p t E gnei n lai s r n p c o

种 分布 式全 局频繁项 集挖 掘 方法
群, 贾 洞

L U Qu ,I in I n A J g o
浙江师范 大学 数理与信息工程学院 , 浙江 金华 3 0 2 4 1 0
p c f n , 0 1 4 ( 9 : 3 -3 . i i f a o s 2 1 ,7 2 ) 1 4 1 6
Ab ta t sr c :A id o loi m BF MGF S( s d n rq e t atr t e n Mo t rq e t tms kn f ag rt h M— I Ba e o F e u n— t n r a d p e e s e u n i f e Miig nn Glb l r. o a F e
C l g fMa e t sP yisad Ifr t nE gneig Z ei g Noma Unv rt ,i u ,hj n 2 0 4 C ia ol e o t ma c, h s n nomai n ier ,hj n r l iesy J h a Z ei g 3 10 , hn e h i c o n a i n a
挖掘 的核 心 内容 , 它计算 量大 , O负载集 中”耗 费挖掘 算法 I / , 绝大部 分时 间 ; 且频繁 项集挖 掘的实 际应用涉 及到海 量数 而 据 , 这种 情况下 , 在 分布式频繁 项集挖掘技术 的研 究成了近年 来一个非常 重要的研究课题 。在 分布式环境 中全 局频繁项集 的挖掘 比较典 型 的算 法有 C D算 法 、D 算法 与改进 C 】 M P , D 算法 F DM算法哪 。在分布式环 境下 F M算 法较 C D D算法在性 能上有 了较 大改进 , 但是 F M算法也有其不 足 :IF M算法 D ()D 是 A r r1e 法 , 要 生 成 频繁 k数 据集 才 能 计 算 频 繁 pi ii 算 o .k 需 +1 数据 集 , 在分 布式环 境 中会 大大 影响延迟 计算 时间与 影 响并行度口 () 1 2 若 是候选 数据集 , 。 在一些站点是非局部频繁 项集 , 远程 站点需要询 问这些 站点 , 且没有充分利用 非频繁项 集进行 全局剪枝 , 这都将 大大增 加网络 通信 量 。本文针 对此 提出了一种分布式环境中全局频繁项集的挖掘 算法 。

模式识别与数据挖掘期末总结

模式识别与数据挖掘期末总结

模式识别与数据挖掘期末总结第一章概述1.数据分析是指采用适当的统计分析方法对收集到的数据进行分析、概括和总结,对数据进行恰当地描述,提取出有用的信息的过程。

2.数据挖掘(Data Mining,DM) 是指从海量的数据中通过相关的算法来发现隐藏在数据中的规律和知识的过程。

3.数据挖掘技术的基本任务主要体现在:分类与回归、聚类、关联规则发现、时序模式、异常检测4.数据挖掘的方法:数据泛化、关联与相关分析、分类与回归、聚类分析、异常检测、离群点分析、5.数据挖掘流程:(1)明确问题:数据挖掘的首要工作是研究发现何种知识。

(2)数据准备(数据收集和数据预处理):数据选取、确定操作对象,即目标数据,一般是从原始数据库中抽取的组数据;数据预处理一般包括:消除噪声、推导计算缺值数据、消除重复记录、完成数据类型转换。

(3)数据挖掘:确定数据挖掘的任务,例如:分类、聚类、关联规则发现或序列模式发现等。

确定了挖掘任务后,就要决定使用什么样的算法。

(4)结果解释和评估:对于数据挖掘出来的模式,要进行评估,删除冗余或无关的模式。

如果模式不满足要求,需要重复先前的过程。

6.分类(Classification)是构造一个分类函数(分类模型),把具有某些特征的数据项映射到某个给定的类别上。

7.分类过程由两步构成:模型创建和模型使用。

8.分类典型方法:决策树,朴素贝叶斯分类,支持向量机,神经网络,规则分类器,基于模式的分类,逻辑回归9.聚类就是将数据划分或分割成相交或者不相交的群组的过程,通过确定数据之间在预先指定的属性上的相似性就可以完成聚类任务。

划分的原则是保持最大的组内相似性和最小的组间相似性10.机器学习主要包括监督学习、无监督学习、半监督学习等1.(1)标称属性(nominal attribute):类别,状态或事物的名字(2):布尔属性(3)序数属性(ordinal attribute):尺寸={小,中,大},军衔,职称【前面三种都是定性的】(4)数值属性(numeric attribute): 定量度量,用整数或实数值表示●区间标度(interval-scaled)属性:温度●比率标度(ratio-scaled)属性:度量重量、高度、速度和货币量●离散属性●连续属性2.数据的基本统计描述三个主要方面:中心趋势度量、数据分散度量、基本统计图●中心趋势度量:均值、加权算数平均数、中位数、众数、中列数(最大和最小值的平均值)●数据分散度量:极差(最大值与最小值之间的差距)、分位数(小于x的数据值最多为k/q,而大于x的数据值最多为(q-k)/q)、说明(特征化,区分,关联,分类,聚类,趋势/跑偏,异常值分析等)、四分位数、五数概括、离群点、盒图、方差、标准差●基本统计图:五数概括、箱图、直方图、饼图、散点图3.数据的相似性与相异性相异性:●标称属性:d(i,j)=1−m【p为涉及属性个数,m:若两个对象匹配为1否则p为0】●二元属性:d(i,j)=p+nm+n+p+q●数值属性:欧几里得距离:曼哈顿距离:闵可夫斯基距离:切比雪夫距离:●序数属性:【r是排名的值,M是排序的最大值】●余弦相似性:第三章数据预处理1.噪声数据:数据中存在着错误或异常(偏离期望值),如:血压和身高为0就是明显的错误。

一种自底向上的最大频繁项集挖掘方法

一种自底向上的最大频繁项集挖掘方法

一种自底向上的最大频繁项集挖掘方法赵阳;吴廖丹【期刊名称】《计算机技术与发展》【年(卷),期】2017(027)008【摘要】频繁项集挖掘是关联规则挖掘中最关键的步骤.最大频繁项集是一种常用的频繁项集简化表示方法.自顶向下的最大频繁项集挖掘方法在最大频繁项集维度远小于频繁项数时往往会产生过多的候选频繁项集.已有的自底向上的最大频繁项集挖掘方法或者需多次遍历数据库,或者需递归生成条件频繁模式树,而预测剪枝策略有进一步提升的空间.为此,提出了基于最小非频繁项集的最大频繁项集挖掘算法(BNFIA),采用基于DFP-tree的存储结构,通过自底向上的方式挖掘出最小非频繁项集,利用最小非频繁项集的性质进行预测剪枝,以缩小搜索空间,再通过边界频繁项集快速挖掘出最大频繁项集.验证实验结果表明,提出算法的性能较同类算法有较为明显的提升.%Mining frequent itemsets is the most critical step in mining association rules.Maximum frequent itemsets is a common compressed representation of frequent itemsets.In mining maximum frequent itemsets,the top-down methods would produce lots of candidate itemsets when the dimensions of maximum frequent itemsets is smaller than the number of frequent itemsets.The existing bottom-up methods need either traversal in database many times or building FP-tree recursively,and the prediction pruning strategies have further room for improvement.The algorithm of discovering maximum frequent itemsets based on minimum non-frequent itemsets named BNFIA has been proposed,which usesstorage structure based on FP-tree and digs out the minimum non-frequent itemsets through a bottom-up approach first,then prunes with the minimum non-frequent itemsets to narrow search space for acquiring the maximum frequent itemsets fast through boundary frequent itemsets.Experimental results show that the proposed algorithm has performed better than the algorithm with same type.【总页数】5页(P57-60,65)【作者】赵阳;吴廖丹【作者单位】江南计算技术研究所,江苏无锡 214083;江南计算技术研究所,江苏无锡 214083【正文语种】中文【中图分类】TP311【相关文献】1.一种有效的负频繁项集挖掘方法 [J], 董祥军;马亮2.数据流上的最大频繁项集挖掘方法 [J], 李海峰;章宁3.MLFI:新的最大长度频繁项集挖掘方法 [J], 张忠平;郭静;韩丽霞4.一种不确定性数据中最大频繁项集挖掘方法 [J], 汪金苗;张龙波;闫光辉;王凤英5.一种基于倒排索引的频繁项集挖掘方法 [J], 贾丽波;姜晓明;叶青;陈占芳因版权原因,仅展示原文概要,查看原文内容请购买。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

1
引言
个采用该剪枝策略的最大频繁模式挖掘算法, 我 们称之为 MinMax 算法。理论分析和试验表明: 由 于该剪枝策略的采用 , 搜索空间被大幅度削减, 算 法效率得到明显提高。
频繁模式挖掘是关联规则、 序列模式、 因果关 系、 最大模式、 多维模式等众多挖掘问题的核心, 已成为近年数据挖掘领域的研究热点。频繁模式 挖掘是挖掘算法中最耗时的部分。挖掘算法的时 间复杂性通常是数据库中项数的指数函数 , 剪枝 优化策略被广泛应用于改善挖掘算法的效率。目 前, 频 繁模式 挖掘中 的剪枝 策略主 要有以 下三 类 : ( 1) 利用不频繁的子模式剪枝 ; ( 2) 利用 频繁的超模式剪枝; ( 3) 利用父子关系剪枝。这 些剪枝策略通常会被综合使用, 但它们仍然会产 生冗余节点, 搜索效率尚不令人满意。本文提出
王 卉1, 2 , 李庆华1 , 马传香1 , 李肯立1 WANG Hui1 , 2 , LI Qing hua1 , MA Chuan xiang1, LI Ken li1 ( 1. 华中科技大学计算机学院, 湖北, 武汉 430074; 2. 通信学院, 湖北 , 武汉 430010) ( 1. School of Computer Science and Technology, Huazhong University of Science and Technology, Wuhan 430074; 2. Wuhan Communication College, Wuhan 430010, China) 摘 要 : 本文在研究已有剪枝策略的基础上, 提出一种基于堆栈的多层回退剪枝新技术, 并给出一 个采用该剪枝策略的最大频繁模式挖掘算法 。分析与试验证明 , 该算法大大削减了搜索空间 , 效率优于 已有同类算法。 Abstract: redundant nodes. A new pruning strategy called the mult i level backtracking strategy is presented in this paper, along with a maximal frequent pattern mining algorithm called MinMax , which adopts mult i level back tracking. The analysis and experimental results show that MinMax prunes the search space more strongly and effi ciently than most other algorithms. 关键词: 频繁模式; 剪枝; 模式挖掘 Key words: frequent pattern; pruning strategy; pattern mining 中图分类号 : TP311. 13 文献标识码 : A 一种基于堆栈的多层回退剪枝新方法 , 并给出一
为频繁模式。 含有 k 个元素的频繁模式称为频繁 k 模式, 频繁 1 模式也称频繁项, 中所有频繁 k 模式的 , 且不 集合记做 Fk 。 定义 4 最大频繁模式: 如果 f ( X ) 存在 Y 使 Y ! X 且 f ( Y ) 模式。 设
, 则称 X 为最大频繁 中所有频繁模 I !f ( X )
CN43 1258/TP ISSN 1007 130X
计算机工程与科学
COMPUTER ENGINEERING & SCIENCE
2003 年第 25 卷第 4 期 Vol 25, No 4, 2003
文章编号: 1007 130X( 2003) 04 0065 04
频繁模式挖掘中的剪枝策略 The Pruning Strategies for Frequent Pattern Mining
}| 推论 1 如果 g ( x 1) > g ( x 2) , 则 x 2 比 x 1 造 成的不频繁模式多。 证明 由定义 5 可知推论 1 成立。 ∃ 推论 2 如果 f ( x 1) < f ( x 2) , 则 x 1 比 x 2 造 成的不频繁模式多。 证明 设 tid 是数据库 中任意一个事务的 识别号 , x 1、 x 2 和 y 是 I 中任意项 , P ( { x } ) 是 tid 在 x 中发生的概率 , P ( { x , y } ) 是 tid 在 x 和 y 中 同时 发 生 的 概 率。由 f ( x 1 ) < f ( x 2 ) 可 知 P ( { x 1} ) < P( { x 2} ) 。因为 P( { x , y } ) = P ( { x } ) * P ( { y } ) , 故 P ( { x 1, y } ) < P ( { x 2, y } ) , f ( { x 1, y } ) < f ( { x 2, y } ) , x 1 比 x 2 造成的频繁模式少, x 1 比 x 2 造成的不频繁模式多。 ∃ 定理 3 设以节点 node ( head, tail ) 为根的子 树中 有最 大频 繁模 式 P, P = head # tail , 则以 node 为根的子树中所有节点都是频繁模式。 证明 由节点扩展的过程可知: 在以 node 为 根的 子树中 , 任 何节 点 son _node 均有 son _node head # tail 成立。由 P = head # tail 知 son_node P 。已知 P 是频繁的, 故 son_node 是频繁的。 ∃
前节点, head 是当前 频繁模 式, tail 是 可使 head 进一步扩展的所有元素, f lagbits 表示与 tail 中各 元素对应的标志位, 0 表示对应的元素尚未考虑, 1 表示已考虑。初始状态下 , head = , tail = F 1, 所有的标志位 为 0。结束状态下 , 所有的标志位 为 1。
收稿日期 : 2002 12 12; 修订日期 : 2003 03 01 基金项目 : 国家自然科学基金资助项目 ( 60273075) 作者简介 : 王卉 ( 1962- ) , 女 , 湖北武汉人 , 博士生 , 副教授 , 研究方向为数据挖掘和并行算法。 通讯地址 : 430074 湖北省武汉市华中科技大学西三区 1 栋 204 室 ; Tel: 13554063330 Address: Room 204, Building 1, t he 3rd Region West, Huazhong U niversity of Science and Technology, Wuhan, Hubei 430074, P. R. China
tid 1 2 3 4 5 6
ቤተ መጻሕፍቲ ባይዱ
it emset A BCE CDE A BCE ACDE ABCDE BCD
item A B C D E
f 4 4 6 4 5
g 1 1 0 2 0
4 最大频繁模式挖掘算法 MinMax
MinMax 算法采用深度优先搜索 方法求出所 有最大频繁模式的集合M 。用一个栈保持搜索路 径, 实现多层回退剪枝。在初始情况下 , 将频繁项 集 F 1 按 g % f & 进行排序。这样会使 head 得到 较小的 tail , 可尽快到达一个叶节点, 利用已知的 最大频繁模式进行剪枝。除了采用多层回退剪枝 策略( 算法第 7 行 ) 以外 , MinMax 也利用定理 1( 算 法第 6 行) 和定理 2( 算法第 5 行) 进行剪枝。 4. 1 算法描述
和 M 分别表示数据库
式和最大频繁模式的集合 ,
= {X | X
}, M= { X | X ∀ ! ∀ Y( Y ! X ! Y ∀ } , 有 ! 。由于一个长度为 m 的最大频繁模式 含有 2 个频繁模式 , 因此, | M | = |
m
| 。给定最
小频度阈值 和数据库 , 挖掘频繁模式的目标 就是从数据库 中找出 。根据定义可知 , 最大 频繁模式中包含了所有的频繁模式。因此 , 求 的问题也就等价于求 M 。 将频繁模 式的挖掘问题看 作是一个 搜索问 题。设每个节点 node 由 head 和 tail 两部分组成。 初始状态时 , head = , tail = I 。节点 node 的 tail 中元素的个数是该节 点可扩展的下 一层的节点 数。设 tail = { a1 , a2 , , an } , 那么 节点 ( head, tail ) 对应的下一层节点有 n 个, 每个节点是( head # { ai } , { ai + 1 , a i+ 2 , , a n } ) , i = 1, 2, , n 。这 样, 挖掘具有 n 个项的数据库中的频繁模式的搜 索空间( 也有文献称 lattice) 有 2 个节点。搜索的 目标就是找出所有 频繁的 head 。我们用节点的 名称或其 head 和 tail 的并集 head # tail 来表示该 节点。 根据频繁模式的定义, 有如下定理 1 和定理 2。 定理 1 频繁模式的任何子模式都是频繁模 式。 定理 2 不频繁模式的任何超模式都不是频 繁模式。 定义 5 不频度 : 频繁项 x 的不频度 g ( x ) 是 它在数据库 中能造成不频繁 2 模式的个数。 g( x ) = | { y | y ∀ F 1 ! x ∀ F 1 ! f ( { x , y } ) < 66
[ 1~ 4]
2
有关术语和定义
为叙述的完整性和方便性, 本文归纳整理了
定义 1~ 4 和定理 1~ 2, 并提出定义 5、 推论 1~ 2 和定理 3 。设 I = { i 1 , i 2 , , i n } 是由 n 个不同的 项组成的集合。 是由事务组成的数据库 , T 为 中的一条事务 , 并由一个唯一的 id 来标识。 定义 1 模式: 称集合 X I 为模式 , 也称为
n
3
多层回退剪枝策略
相关文档
最新文档