中南大学电子商务实验4.docx

中南大学电子商务实验4.docx

《中南大学电子商务实验4.docx》由会员分享，可在线阅读，更多相关《中南大学电子商务实验4.docx（23页珍藏版）》请在冰豆网上搜索。

中南大学电子商务实验4

《电子商务应用》

实验报告

项目名称睿健时代

专业班级1206

学号3901120604

姓名金初阳

实验成绩：

批阅教师：

年月日

实验4《电子商务数据挖掘实验》

实验学时：

2

每组人数：

1

实验类型：

2（1：

基础性2：

综合性3：

设计性4：

研究性）

实验要求：

1（1：

必修2：

选修3：

其它）

实验类别：

3（1：

基础2：

专业基础3：

专业4：

其它）

一、实验目的

1.加深对数据挖掘概念和主要任务的理解。

2.研究并学习几种常用的关联分析算法、分类算法、聚类算法和异常检测方法，了解它们的实现原理以及在电子商务中的应用。

3.研究并学习几种常用的个性化商品或信息推荐方法，并结合选题设计一个简单的商品或信息推荐模型。

二、实验内容

1.研究并学习两种常用的关联分析算法的实现原理并编程实现其中一种，编程语言不限。

2.研究并学习两种常用的分类算法的实现原理并编程实现其中一种，编程语言不限。

3.研究并学习两种常用的聚类算法的实现原理并编程实现其中一种，编程语言不限。

4.研究并学习两种常用的异常检测方法的实现原理。

5.研究并学习两种常用的个性化商品或信息推荐方法，了解其实现原理和特点。

6.结合选题，设计一个简单的商品或信息推荐模型。

【注意：

模型不一定要很复杂，关键是要能够说明其合理性，鼓励大家创新。

以下两种商品推荐模型（信息推荐模型思路相似）基本思想供参考，也可在此基础上进行改进：

①分析用户的购买记录，找出他经常购买的商品的类型，然后在该类型中找出购买量或者访问量最大但是该买家之前并未购买的商品，并将这些商品推荐给该用户。

②找出与该用户具有相似购物习惯的其他用户，例如他们曾经购买过一些相同的商品，然后将其他用户购买过但是该用户未曾购买的商品推荐给他。

】

三、实验要求

1.研究两种常用的关联分析算法，填写相应的表格，表格必须填写完整，任选一种编程语言实现其中的一种算法，要求提供详细源代码；

2.研究两种常用的分类算法，填写相应的表格，表格必须填写完整，任选一种编程语言实现其中的一种算法，要求提供详细源代码；

3.研究两种常用的聚类算法，填写相应的表格，表格必须填写完整，任选一种编程语言实现其中的一种算法，要求提供详细源代码；

4.研究两种常用的异常检测方法，填写相应的表格，表格必须填写完整；

5.研究两种常用的个性化商品或信息推荐方法，填写相应的表格，表格必须填写完整；

6.结合选题，设计一个简单的商品或信息推荐模型，要求详细说明其实现过程，包括公式、流程等，但无需编程实现。

四、实验步骤

1.通过使用搜索引擎并查阅相关资料，研究并整理两种常用的关联分析算法，填写相应的表格并选择一种编程实现；

2.通过使用搜索引擎并查阅相关资料，研究并整理两种常用的分类算法，填写相应的表格并选择一种编程实现；

3.通过使用搜索引擎并查阅相关资料，研究并整理两种常用的聚类算法，填写相应的表格并选择一种编程实现；

4.通过使用搜索引擎并查阅相关资料，研究并整理两种常用的异常检测方法，填写相应的表格；

5.通过使用搜索引擎并查阅相关资料，研究并整理两种常用的电子商务个性化商品或信息推荐方法，填写相应的表格；

6.结合选题，设计一个简单的商品或信息推荐模型。

五、实验结果

1.研究并整理两种常用的关联分析算法，编程实现其中一种，填写如下表格：

关联分析算法名称

实现原理

Apriori算法

算法使用频繁项集性质的先验知识。

Apriori使用一种称作逐层搜索的迭代方法，k项集用于探索（k+1）项集。

首先，通过扫描数据库，累积每个项的计数，并收集满足最小支持度的项，找出频繁1项集的集合。

该集合记作L1.然后，L1用于找频繁2项集的集合L2，L2用于找L3，如此迭代，直到不能再找到频繁k项集。

找每个Lk需要一次数据库全扫描。

Apriori性质可用于压缩搜索空间，提高频繁项集逐层产生的效率。

Apriori性质：

频繁项集的所有非空子集也必是频繁的。

Apriori算法主要包括连接步和剪枝步两步组成。

在连接步和剪枝步中采用Apriori性质可以提高算法的效率。

FP．growth算法

它采取了分治策略：

首先，构造频繁模式树FP．树，根据事务数据库及设定的最小支持度阀值，将包含频繁项集的数据库压缩到FP．树上；其次，在FP-树上进行频繁模式的挖掘，FP．树的挖掘进行如下，由长度为1的频繁模式（初始后缀模式）开始，构造它的条件模式基（FP．树中和后缀模式一起出现的前缀路径集），然后构造条件模式基的FP．树，即模式树的增长，并递归地在FP．树上进行挖掘。

这种方法对于挖掘长的和短的频繁模式，都是有效和可以伸缩的，并比Apriori方法快了1个数量级；但是当数据库很大时，构造基于内存的FP—tree不太现实。

关联分析算法名称：

Apriori算法

//核心实现代码

/***扫描事务数据库，计算频繁1-项集*@return*/publicMap,Float>getFreq1ItemSet（）{Map,Float>freq1ItemSetMap=newHashMap,Float>（）;Map,Integer>candFreq1ItemSet=this.getCandFreq1ItemSet（）;Iterator,Integer>>it=candFreq1ItemSet.entrySet（）.iterator（）;while（it.hasNext（））{Map.Entry,Integer>entry=it.next（）;//计算支持度Floatsupported=newFloat（entry.getValue（）.toString（））/newFloat（txDatabaseCount）;if（supported>=minSup）{freq1ItemSetMap.put（entry.getKey（）,supported）;}}returnfreq1ItemSetMap;}/***计算候选频繁1-项集*@return*/publicMap,Integer>getCandFreq1ItemSet（）{Map,Integer>candFreq1ItemSetMap=newHashMap,Integer>（）;Iterator>>it=txDatabase.entrySet（）.iterator（）;//统计支持数，生成候选频繁1-项集while（it.hasNext（））{Map.Entry>entry=it.next（）;SetitemSet=entry.getValue（）;for（Stringitem:

itemSet）{Setkey=newHashSet（）;key.add（item.trim（））;if（!

candFreq1ItemSetMap.containsKey（key））{Integervalue=1;candFreq1ItemSetMap.put（key,value）;}else{Integervalue=1+candFreq1ItemSetMap.get（key）;candFreq1ItemSetMap.put（key,value）;}}}returncandFreq1ItemSetMap;}/***根据频繁（k-1）-项集计算候选频繁k-项集**@paramm其中m=k-1*@paramfreqMItemSet频繁（k-1）-项集*@return*/publicSet>aprioriGen（intm,Set>freqMItemSet）{Set>candFreqKItemSet=newHashSet>（）;Iterator>it=freqMItemSet.iterator（）;SetoriginalItemSet=null;while（it.hasNext（））{originalItemSet=it.next（）;Iterator>itr=this.getIterator（originalItemSet,freqMItemSet）;while（itr.hasNext（））{SetidenticalSet=newHashSet（）;//两个项集相同元素的集合（集合的交运算）identicalSet.addAll（originalItemSet）;Setset=itr.next（）;identicalSet.retainAll（set）;//identicalSet中剩下的元素是identicalSet与set集合中公有的元素if（identicalSet.size（）==m-1）{//（k-1）-项集中k-2个相同SetdifferentSet=newHashSet（）;//两个项集不同元素的集合（集合的差运算）differentSet.addAll（originalItemSet）;differentSet.removeAll（set）;//因为有k-2个相同，则differentSet中一定剩下一个元素，即differentSet大小为1differentSet.addAll（set）;//构造候选k-项集的一个元素（set大小为k-1,differentSet大小为k）if（!

this.has_infrequent_subset（differentSet,freqMItemSet））candFreqKItemSet.add（differentSet）;//加入候选k-项集集合}}}returncandFreqKItemSet;}/***使用先验知识，剪枝。

若候选k项集中存在k-1项子集不是频繁k-1项集，则删除该候选k项集*@paramcandKItemSet*@paramfreqMItemSet*@return*/privatebooleanhas_infrequent_subset（SetcandKItemSet,Set>freqMItemSet）{SettempSet=newHashSet（）;tempSet.addAll（candKItemSet）;IteratoritItem=candKItemSet.iterator（）;while（itItem.hasNext（））{Stringitem=itItem.next（）;tempSet.remove（item）;//该候选去掉一项后变为k-1项集if（!

freqMItemSet.contains（tempSet））//判断k-1项集是否是频繁项集returntrue;tempSet.add（item）;//恢复}returnfalse;}/***根据一个频繁k-项集的元素（集合），获取到频繁k-项集的从该元素开始的迭代器实例*@paramitemSet*@paramfreqKItemSet频繁k-项集*@return*/privateIterator>getIterator（SetitemSet,Set>freqKItemSet）{Iterator>it=freqKItemSet.iterator（）;while（it.hasNext（））{if（itemSet.equals（it.next（）））{break;}}returnit;}/***根据频繁（k-1）-项集，调用aprioriGen方法，计算频繁k-项集**@paramk*@paramfreqMItemSet频繁（k-1）-项集*@return*/publicMap,Float>getFreqKItemSet（intk,Set>freqMItemSet）{Map,Integer>candFreqKItemSetMap=newHashMap,Integer>（）;//调用aprioriGen方法，得到候选频繁k-项集Set>candFreqKItemSet=this.aprioriGen（k-1,freqMItemSet）;//扫描事务数据库Iterator>>it=txDatabase.entrySet（）.iterator（）;//统计支持数while（it.hasNext（））{Map.Entry>entry=it.next（）;Iterator>kit=candFreqKItemSet.iterator（）;while（kit.hasNext（））{SetkSet=kit.next（）;Setset=newHashSet（）;set.addAll（kSet）;set.removeAll（entry.getValue（））;//候选频繁k-项集与事务数据库中元素做差运算if（set.isEmpty（））{//如果拷贝set为空，支持数加1if（candFreqKItemSetMap.get（kSet）==null）{Integervalue=1;candFreqKItemSetMap.put（kSet,value）;}else{Integervalue=1+candFreqKItemSetMap.get（kSet）;candFreqKItemSetMap.put（kSet,value）;}}}}//计算支持度，生成频繁k-项集，并返回returnsupport（candFreqKItemSetMap）;}/***根据候选频繁k-项集，得到频繁k-项集**@paramcandFreqKItemSetMap候选k项集（包含支持计数）*@returnfreqKItemSetMap频繁k项集及其支持度（比例）*/publicMap,Float>support（Map,Integer>candFreqKItemSetMap）{Map,Float>freqKItemSetMap=newHashMap,Float>（）;Iterator,Integer>>it=candFreqKItemSetMap.entrySet（）.iterator（）;while（it.hasNext（））{Map.Entry,Integer>entry=it.next（）;//计算支持度FloatsupportRate=newFloat（entry.getValue（）.toString（））/newFloat（txDatabaseCount）;if（supportRate>freqKItemSet=this.getFreq1ItemSet（）.keySet（）;freqItemSet.put（1,freqKItemSet）;//计算频繁k-项集（k>1）intk=2;while（true）{Map,Float>freqKItemSetMap=this.getFreqKItemSet（k,freqKItemSet）;if（!

freqKItemSetMap.isEmpty（））{this.freqItemSet.put（k,freqKItemSetMap.keySet（））;freqKItemSet=freqKItemSetMap.keySet（）;}else{break;}k++;}}/***

挖掘频繁关联规则*

首先挖掘出全部的频繁项集，在此基础上挖掘频繁关联规则*/publicvoidmineAssociationRules（）{freqItemSet.remove

（1）;//删除频繁1-项集Iterator>>>it=freqItemSet.entrySet（）.iterator（）;while（it.hasNext（））{Map.Entry>>entry=it.next（）;for（SetitemSet:

entry.getValue（））{//对每个频繁项集进行关联规则的挖掘mine（itemSet）;}}}/***对从频繁项集集合freqItemSet中每迭代出一个频繁项集元素，执行一次关联规则的挖掘*@paramitemSet频繁项集集合freqItemSet中的一个频繁项集元素*/publicvoidmine（SetitemSet）{intn=itemSet.size（）/2;//根据集合的对称性，只需要得到一半的真子集for（inti=1;i<=n;i++）{//得到频繁项集元素itemSet的作为条件的真子集集合Set>properSubset=ProperSubsetCombination.getProperSubset（i,itemSet）;//对条件的真子集集合中的每个条件项集，获取到对应的结论项集，从而进一步挖掘频繁关联规则for（SetconditionSet:

properSubset）{SetconclusionSet=newHashSet（）;conclusionSet.addAll（itemSet）;conclusionSet.removeAll（conditionSet）;//删除条件中存在的频繁项confide（conditionSet,conclusionSet）;//调用计算置信度的方法，并且挖掘出频繁关联规则}}}/***对得到的一个条件项集和对应的结论项集，计算该关联规则的支持计数，从而根据置信度判断是否是频繁关联规则*@paramconditionSet条件频繁项集*@paramconclusionSet结论频繁项集*/publicvoidconfide（SetconditionSet,SetconclusionSet）{//扫描事务数据库Iterator>>it=txDatabase.entrySet（）.iterator（）;//统计关联规则支持计数intconditionToConclusionCnt=0;//关联规则（条件项集推出结论项集）计数intconclusionToConditionCnt=0;//关联规则（结论项集推出条件项集）计数intsupCnt=0;//关联规则支持计数while（it.hasNext（））{Map.Entry>entry=it.next（）;SettxSet=entry.getValue（）;Setset1=newHashSet（）;Setset2=newHashSet（）;set1.addAll（conditionSet）;set1.removeAll（txSet）;//集合差运算：

set-txSetif（set1.isEmpty（））{//如果set为空，说明事务数据库中包含条件频繁项conditionSet//计数conditionToConclusionCnt++;}set2.addAll（conclusionSet）;set2.removeAll（txSet）;//集合差运算：

set-txSetif（set2.isEmpty（））{//如果set为空，说明事务数据库中包含结论频繁项conclusionSet//计数conclusionToConditionCnt++;}if（set1.isEmpty（）&&set2.isEmpty（））{supCnt++;}}//计算置信度FloatconditionToConclusionConf=newFloat（supCnt）/newFloat（conditionToConclusionCnt）;if（conditionToConclusionConf>=minConf）{if（assiciationRules.get（conditionSet）==null）{//如果不存在以该条件频繁项集为条件的关联规则Set>conclusionSetSet=newHashSet>（）;conclu