精华内容
下载资源
问答
  • weka 中,详细解读经典关联算法Apriori的源代码
  • 1) 测试文档中调用weka关联规则apriori算法,如下try{File file= new File("F:\\tools/lib/data/contact-lenses.arff");ArffLoader loader= newArffLoader();loader.setFile(file);Instances m_inst...

    相对于机器学习,关联规则的apriori算法更偏向于数据挖掘。

    1) 测试文档中调用weka的关联规则apriori算法,如下

    try{

    File file= new File("F:\\tools/lib/data/contact-lenses.arff");

    ArffLoader loader= newArffLoader();

    loader.setFile(file);

    Instances m_instances=loader.getDataSet();

    Discretize discretize= newDiscretize();

    discretize.setInputFormat(m_instances);

    m_instances=Filter.useFilter(m_instances, discretize);

    Apriori apriori= newApriori();

    apriori.buildAssociations(m_instances);

    System.out.println(apriori.toString());

    }catch(Exception e) {

    e.printStackTrace();

    }

    步骤

    1 读取数据集data,并提取样本集instances

    2 离散化属性Discretize

    3 创建Apriori 关联规则模型

    4 输出大频率项集和关联规则集

    2) 创建分类器的时候,调用设置默认参数方法

    public voidresetOptions() {

    m_removeMissingCols= false;

    m_verbose= false;

    m_delta= 0.05;

    m_minMetric= 0.90;

    m_numRules= 10;

    m_lowerBoundMinSupport= 0.1;

    m_upperBoundMinSupport= 1.0;

    m_significanceLevel= -1;

    m_outputItemSets= false;

    m_car= false;

    m_classIndex= -1;

    }

    参数详细解析,见后面的备注1

    3)buildAssociations方法的解析,源码如下

    public voidbuildAssociations(Instances instances) throws Exception {double[] confidences, supports;int[] indices;

    FastVector[] sortedRuleSet;int necSupport = 0;

    instances= newInstances(instances);if(m_removeMissingCols) {

    instances=removeMissingColumns(instances);

    }if (m_car && m_metricType !=CONFIDENCE)throw new Exception("For CAR-Mining metric type has to be confidence!");//only set class index if CAR is requested

    if(m_car) {if (m_classIndex == -1) {

    instances.setClassIndex(instances.numAttributes()- 1);

    }else if (m_classIndex <= instances.numAttributes() && m_classIndex > 0) {

    instances.setClassIndex(m_classIndex- 1);

    }else{throw new Exception("Invalid class index.");

    }

    }//can associator handle the data?

    getCapabilities().testWithFail(instances);

    m_cycles= 0;//make sure that the lower bound is equal to at least one instance

    double lowerBoundMinSupportToUse =(m_lowerBoundMinSupport* instances.numInstances() < 1.0) ? 1.0 /instances.numInstances()

    : m_lowerBoundMinSupport;if(m_car) {//m_instances does not contain the class attribute

    m_instances = LabeledItemSet.divide(instances, false);//m_onlyClass contains only the class attribute

    m_onlyClass = LabeledItemSet.divide(instances, true);

    }elsem_instances=instances;if (m_car && m_numRules ==Integer.MAX_VALUE) {//Set desired minimum support

    m_minSupport =lowerBoundMinSupportToUse;

    }else{//Decrease minimum support until desired number of rules found.

    m_minSupport = m_upperBoundMinSupport -m_delta;

    m_minSupport= (m_minSupport < lowerBoundMinSupportToUse) ?lowerBoundMinSupportToUse

    : m_minSupport;

    }do{//Reserve space for variables

    m_Ls = newFastVector();

    m_hashtables= newFastVector();

    m_allTheRules= new FastVector[6];

    m_allTheRules[0] = newFastVector();

    m_allTheRules[1] = newFastVector();

    m_allTheRules[2] = newFastVector();if (m_metricType != CONFIDENCE || m_significanceLevel != -1) {

    m_allTheRules[3] = newFastVector();

    m_allTheRules[4] = newFastVector();

    m_allTheRules[5] = newFastVector();

    }

    sortedRuleSet= new FastVector[6];

    sortedRuleSet[0] = newFastVector();

    sortedRuleSet[1] = newFastVector();

    sortedRuleSet[2] = newFastVector();if (m_metricType != CONFIDENCE || m_significanceLevel != -1) {

    sortedRuleSet[3] = newFastVector();

    sortedRuleSet[4] = newFastVector();

    sortedRuleSet[5] = newFastVector();

    }if (!m_car) {//Find large itemsets and rules

    findLargeItemSets();if (m_significanceLevel != -1 || m_metricType !=CONFIDENCE)

    findRulesBruteForce();elsefindRulesQuickly();

    }else{

    findLargeCarItemSets();

    findCarRulesQuickly();

    }//prune rules for upper bound min support

    if (m_upperBoundMinSupport < 1.0) {

    pruneRulesForUpperBoundSupport();

    }

    int j = m_allTheRules[2].size() - 1;

    supports= new double[m_allTheRules[2].size()];for (int i = 0; i < (j + 1); i++)

    supports[j- i] = ((double) ((ItemSet) m_allTheRules[1]

    .elementAt(j- i)).support()) * (-1);

    indices=Utils.stableSort(supports);for (int i = 0; i < (j + 1); i++) {

    sortedRuleSet[0].addElement(m_allTheRules[0].elementAt(indices[j -i]));

    sortedRuleSet[1].addElement(m_allTheRules[1].elementAt(indices[j -i]));

    sortedRuleSet[2].addElement(m_allTheRules[2].elementAt(indices[j -i]));if (m_metricType != CONFIDENCE || m_significanceLevel != -1) {

    sortedRuleSet[3].addElement(m_allTheRules[3]

    .elementAt(indices[j-i]));

    sortedRuleSet[4].addElement(m_allTheRules[4]

    .elementAt(indices[j-i]));

    sortedRuleSet[5].addElement(m_allTheRules[5]

    .elementAt(indices[j-i]));

    }

    }//Sort rules according to their confidence

    m_allTheRules[0].removeAllElements();

    m_allTheRules[1].removeAllElements();

    m_allTheRules[2].removeAllElements();if (m_metricType != CONFIDENCE || m_significanceLevel != -1) {

    m_allTheRules[3].removeAllElements();

    m_allTheRules[4].removeAllElements();

    m_allTheRules[5].removeAllElements();

    }

    confidences= new double[sortedRuleSet[2].size()];int sortType = 2 +m_metricType;for (int i = 0; i < sortedRuleSet[2].size(); i++)

    confidences[i]=((Double) sortedRuleSet[sortType].elementAt(i))

    .doubleValue();

    indices=Utils.stableSort(confidences);for (int i = sortedRuleSet[0].size() - 1; (i >= (sortedRuleSet[0].size() -m_numRules))&& (i >= 0); i--) {

    m_allTheRules[0].addElement(sortedRuleSet[0].elementAt(indices[i]));

    m_allTheRules[1].addElement(sortedRuleSet[1].elementAt(indices[i]));

    m_allTheRules[2].addElement(sortedRuleSet[2].elementAt(indices[i]));if (m_metricType != CONFIDENCE || m_significanceLevel != -1) {

    m_allTheRules[3].addElement(sortedRuleSet[3].elementAt(indices[i]));

    m_allTheRules[4].addElement(sortedRuleSet[4].elementAt(indices[i]));

    m_allTheRules[5].addElement(sortedRuleSet[5].elementAt(indices[i]));

    }

    }if(m_verbose) {if (m_Ls.size() > 1) {

    System.out.println(toString());

    }

    }if (m_minSupport ==lowerBoundMinSupportToUse|| m_minSupport - m_delta >lowerBoundMinSupportToUse)

    m_minSupport-=m_delta;elsem_minSupport=lowerBoundMinSupportToUse;

    necSupport= Math.round((float) ((m_minSupport *m_instances

    .numInstances())+ 0.5));

    m_cycles++;

    }while ((m_allTheRules[0].size() = lowerBoundNumInstancesSupport)*/

    /*(Utils.grOrEq(m_minSupport, m_lowerBoundMinSupport))*/&& (necSupport >= 1));

    m_minSupport+=m_delta;

    }

    主要步骤解析:

    1 使用removeMissingColumns方法,删除缺失属性的列

    2 如果参数m_car是真,则进行划分;因为m_car是真的意思是挖掘与关联规则的有关的规则,所以划分成两部分,一部分有关,一部分无关,删除无关的即可;

    3 方法findLargeItemSets查找大频率项集;具体源码见下面

    4 方法findRulesQuickly查找所有的关联规则集;

    5 方法pruneRulesForUpperBoundSupport删除不满足最小置信度的规则集;

    6)按照置信度把规则集排序;

    4)查找大频率项集findLargeItemSets源码如下:

    private voidfindLargeItemSets() throws Exception {

    FastVector kMinusOneSets, kSets;

    Hashtable hashtable;int necSupport, necMaxSupport, i = 0;//Find large itemsets//minimum support

    necSupport = (int) (m_minSupport * m_instances.numInstances() + 0.5);

    necMaxSupport= (int) (m_upperBoundMinSupport * m_instances.numInstances() + 0.5);

    kSets=AprioriItemSet.singletons(m_instances);

    AprioriItemSet.upDateCounters(kSets, m_instances);

    kSets=AprioriItemSet.deleteItemSets(kSets, necSupport,

    m_instances.numInstances());if (kSets.size() == 0)return;do{

    m_Ls.addElement(kSets);

    kMinusOneSets=kSets;

    kSets=AprioriItemSet.mergeAllItemSets(kMinusOneSets, i,

    m_instances.numInstances());

    hashtable=AprioriItemSet.getHashtable(kMinusOneSets,

    kMinusOneSets.size());

    m_hashtables.addElement(hashtable);

    kSets=AprioriItemSet.pruneItemSets(kSets, hashtable);

    AprioriItemSet.upDateCounters(kSets, m_instances);

    kSets=AprioriItemSet.deleteItemSets(kSets, necSupport,

    m_instances.numInstances());

    i++;

    }while (kSets.size() > 0);

    }

    主要步骤:

    1  类AprioriItemSet.singletons方法,将给定数据集的头信息转换成一个项集的集合, 头信息中的值的顺序是按字典序。

    2 方法upDateCounters查找一频繁项目集;

    3 AprioriItemSet.deleteItemSets方法,删除不满足支持度区间的项目集;

    4 使用方法mergeAllItemSets(源码如下)由k-1项目集循环生出k频繁项目集,并且使用方法deleteItemSets删除不满足支持度区间的项目集;

    5)由k-1项目集循环生出k频繁项目集的方法mergeAllItemSets,源码如下:

    public static FastVector mergeAllItemSets(FastVector itemSets, intsize,inttotalTrans) {

    FastVector newVector= newFastVector();

    ItemSet result;intnumFound, k;for (int i = 0; i < itemSets.size(); i++) {

    ItemSet first=(ItemSet) itemSets.elementAt(i);out: for (int j = i + 1; j < itemSets.size(); j++) {

    ItemSet second=(ItemSet) itemSets.elementAt(j);

    result= newAprioriItemSet(totalTrans);

    result.m_items= new int[first.m_items.length];//Find and copy common prefix of size 'size'

    numFound = 0;

    k= 0;while (numFound

    numFound++;

    result.m_items[k]=first.m_items[k];

    }else

    break out;

    k++;

    }//Check difference

    while (k

    result.m_items[k]=first.m_items[k];elseresult.m_items[k]=second.m_items[k];

    }

    k++;

    }if (k ==first.m_items.length) {

    result.m_counter= 0;

    newVector.addElement(result);

    }

    }

    }returnnewVector;

    }

    调用方法generateRules生出关联规则

    6)生出关联规则的方法generateRules,源码如下

    public FastVector[] generateRules(doubleminConfidence,

    FastVector hashtables,intnumItemsInSet) {

    FastVector premises= new FastVector(), consequences = new FastVector(), conf = newFastVector();

    FastVector[] rules= new FastVector[3], moreResults;

    AprioriItemSet premise, consequence;

    Hashtable hashtable= (Hashtable) hashtables.elementAt(numItemsInSet - 2);//Generate all rules with one item in the consequence.

    for (int i = 0; i < m_items.length; i++)if (m_items[i] != -1) {

    premise= newAprioriItemSet(m_totalTransactions);

    consequence= newAprioriItemSet(m_totalTransactions);

    premise.m_items= new int[m_items.length];

    consequence.m_items= new int[m_items.length];

    consequence.m_counter=m_counter;for (int j = 0; j < m_items.length; j++)

    consequence.m_items[j]= -1;

    System.arraycopy(m_items,0, premise.m_items, 0, m_items.length);

    premise.m_items[i]= -1;

    consequence.m_items[i]=m_items[i];

    premise.m_counter= ((Integer) hashtable.get(premise)).intValue();

    premises.addElement(premise);

    consequences.addElement(consequence);

    conf.addElement(newDouble(confidenceForRule(premise, consequence)));

    }

    rules[0] =premises;

    rules[1] =consequences;

    rules[2] =conf;

    pruneRules(rules, minConfidence);//Generate all the other rules

    moreResults = moreComplexRules(rules, numItemsInSet, 1, minConfidence,

    hashtables);if (moreResults != null)for (int i = 0; i < moreResults[0].size(); i++) {

    rules[0].addElement(moreResults[0].elementAt(i));

    rules[1].addElement(moreResults[1].elementAt(i));

    rules[2].addElement(moreResults[2].elementAt(i));

    }returnrules;

    }

    几个我想说的

    1)不想输出为0的项,可以设置成缺失值?,因为算法会自动删除缺失值的列,不参与关联规则的生成;

    2)按照置信度对关联规则排序,是关联规则分类器中使用的,只是提取关联规则,不需要排序;

    备注

    1)weka的关联规则中参数的详解

    1. car 如果设为真,则会挖掘类关联规则而不是全局关联规则。也就是只保留与类标签有关的关联规则,设置索引为-12. classindex 类属性索引。如果设置为-1,最后的属性被当做类属性。3. delta 以此数值为迭代递减单位。不断减小支持度直至达到最小支持度或产生了满足数量要求的规则。4. lowerBoundMinSupport 最小支持度下界。5. metricType 度量类型。设置对规则进行排序的度量依据。可以是:置信度(类关联规则只能用置信度挖掘),提升度(lift),杠杆率(leverage),确信度(conviction)。

    在 Weka中设置了几个类似置信度(confidence)的度量来衡量规则的关联程度,它们分别是:

    a) Lift : P(A,B)/(P(A)P(B)) Lift=1时表示A和B独立。这个数越大(>1),越表明A和B存在于一个购物篮中不是偶然现象,有较强的关联度.

    b) Leverage :P(A,B)-P(A)P(B)Leverage=0时A和B独立,Leverage越大A和B的关系越密切

    c) Conviction:P(A)P(!B)/P(A,!B) (!B表示B没有发生) Conviction也是用来衡量A和B的独立性。从它和lift的关系(对B取反,代入Lift公式后求倒数)可以看出,这个值越大, A、B越关联。6. minMtric 度量的最小值。7. numRules 要发现的规则数。8. outputItemSets 如果设置为真,会在结果中输出项集。9. removeAllMissingCols 移除全部为缺省值的列。10. significanceLevel 重要程度。重要性测试(仅用于置信度)。11. upperBoundMinSupport 最小支持度上界。 从这个值开始迭代减小最小支持度。12. verbose 如果设置为真,则算法会以冗余模式运行。

    2)控制台输出结果

    Apriori=======Minimum support:0.2 (5instances)

    Minimum metric: 0.9Number of cycles performed:16Generated sets of large itemsets:

    Size ofset of large itemsets L(1): 11Size ofset of large itemsets L(2): 21Size ofset of large itemsets L(3): 6Best rules found:1. tear-prod-rate=reduced 12 ==> contact-lenses=none 12 conf:(1)2. spectacle-prescrip=myope tear-prod-rate=reduced 6 ==> contact-lenses=none 6 conf:(1)3. spectacle-prescrip=hypermetrope tear-prod-rate=reduced 6 ==> contact-lenses=none 6 conf:(1)4. astigmatism=no tear-prod-rate=reduced 6 ==> contact-lenses=none 6 conf:(1)5. astigmatism=yes tear-prod-rate=reduced 6 ==> contact-lenses=none 6 conf:(1)6. contact-lenses=soft 5 ==> astigmatism=no 5 conf:(1)7. contact-lenses=soft 5 ==> tear-prod-rate=normal 5 conf:(1)8. tear-prod-rate=normal contact-lenses=soft 5 ==> astigmatism=no 5 conf:(1)9. astigmatism=no contact-lenses=soft 5 ==> tear-prod-rate=normal 5 conf:(1)10. contact-lenses=soft 5 ==> astigmatism=no tear-prod-rate=normal 5 conf:(1)

    转置请注明出处:http://www.cnblogs.com/rongyux/

    展开全文
  • WEKA软件进行Apriori算法数据挖掘测试最详细清楚解释 一、Apriori算法简介 “Apriori算法是一种挖掘关联规则的频繁项集算法,其核心思想是通过候选集生成和情节的向下封闭检测两个阶段来挖掘频繁项集。而且算法...

    用WEKA软件进行Apriori算法数据挖掘测试最详细清楚解释

    一、Apriori算法简介

    “Apriori算法是一种挖掘关联规则的频繁项集算法,其核心思想是通过候选集生成和情节的向下封闭检测两个阶段来挖掘频繁项集。而且算法已经被广泛的应用到商业、网络安全等各个领域。 算法简介 Apriori算法是一种最有影响的挖掘布尔关联规则频繁项集的算法。其核心是基于两阶段频集思想的递推算法。该关联规则在分类上属于单维、单层、布尔关联规则。在这里,所有支持度大于最小支持度的项集称为频繁项集,简称频集。算法思想 ”。

    二、因为WEKA能识别的文件类型是.arff文件,所以我们需要将已有数据转为.arff文件格式的数据(见下图紫色框中的内容)。

    在这里插入图片描述
    1、@relation:关系名(无硬性要求,但建议取和数据相关的名如下面的movie);
    2、@attribute:属性名 ;
    3、 { }:属性可取值的范围,可自定义;
    4、@data:之后每一行均为一个事务,未知属性值使用 “ ?”,也可以填写属性值范围{}的内容(下面的就是可以填“True”或者“False”),解释一下第一行:动作、战争,第二行:喜剧、爱情,第三行:剧情、动作、犯罪。规律就是“True”对应的属性值就是该行事务的取值内容,而“ ?”则不用显示。

    5、.arff文件可以用.txt文本文件修改后缀名生成。

    @relation movie
    @attribute 动作 {False, True}
    @attribute 战争 {False, True}
    @attribute 喜剧 {False, True}
    @attribute 爱情 {False, True}
    @attribute 剧情 {False, True}
    @attribute 犯罪 {False, True}
    @attribute 科幻 {False, True}
    @attribute 灾难 {False, True}
    @attribute 奇幻 {False, True}
     
    @data
    True,True,?,?,?,?,?,?,?
    ?,?,True,True,?,?,?,?,?
    True,?,?,?,True,True,?,?,?
    True,True,?,?,True,?,?,?,?
    ?,?,?,?,?,?,True,True,?
    ?,?,True,True,?,?,?,?,True
    True,True,?,?,?,?,?,?,?
    ?,?,True,?,?,?,?,?,True
    ?,?,?,?,True,?,?,?,?
    ?,?,?,?,True,?,?,?,?
    

    三、用WEKA进行数据预处理(点击紫色箭头指向的紫色框中的内容“Explorer”)。

    在这里插入图片描述
    1、Explorer
    用来进行数据实验、挖掘的环境,它提供了分类,聚类,关联规则,特征选择,数据可视化的功能。(An environment for exploring data with WEKA)
    2、Experimentor
    用来进行实验,对不同学习方案进行数据测试的环境。(An environment for performing experiments and conducting statistical tests between learning schemes.)
    3、KnowledgeFlow
    功能和Explorer差不多,不过提供的接口不同,用户可以使用拖拽的方式去建立实验方案。另外,它支持增量学习。(This environment supports essentially the same functions as the Explorer but with a drag-and-drop interface. One advantage is that it supports incremental learning.)
    4、SimpleCLI
    简单的命令行界面。(Provides a simple command-line interface that allows direct execution of WEKA commands for operating systems that do not provide their own command line interface.)

    四、进入新页面后,点击紫色箭头指向的紫色框中的内容“Open file”。

    在这里插入图片描述

    五、找到自己之前要进行数据预处理的.arff文件(博主进行示范的是movie.arff,见第二步红色箭头指向的红色框指向的内容)。

    在这里插入图片描述
    在这里插入图片描述

    六、可点击红色箭头指向的红色框中的内容“Edit”对.arff数据内容进行重新编辑,也可以不编辑(博主就没有重新编辑了,同时请注意:编辑不会改变原.arff文件内容也就是例子中的movie.arff文件)。

    在这里插入图片描述
    在这里插入图片描述

    七、点击红色箭头指向的红色框中的内容“Associate”(关联规则分析)。

    温馨提示:Preprocess(预处理)、Classify(分类)、Cluster(聚类)、Associate(关联规则)、Select attribute(特征选择)和Visualize(可视化)。
    在这里插入图片描述

    八、第一步点击红色箭头指向的红色框中的“choose”。

    在这里插入图片描述

    九、第二步选择红色箭头指向的红色框中的“Apriori”。进行算法选择为Apriori算法,为关联规则分析做准备。

    在这里插入图片描述

    十、点击红色箭头指向的红色框中的内容。

    在这里插入图片描述

    十一(重要)、页面中的参数值(见下图红色框的内容)都可以修改调动,但建议在修改调动之前现阅读下面各个参数所表达的含义和用法,若不需要修改调动,就直接可以采用系统默认的参数值;修改完之后点击紫色框内容(ok)确定修改。

    1、car: 如果设为True,则会挖掘类关联规则而不是全局关联规则。

    2、classindex :类属性索引。如果设置为-1,则倒数第一的属性也就是最后的属性被当做类属性。

    3、delta: 以该数值为迭代递减单位,然后不断减小支持度直至达到最小支持度或产生了满足数量要求的规则。根据delta可以计算理解Number of cycles performed的公式是:
    *(upperBoundMinSupport)-((Number of cycles performed)-1)delta >= (LowerBoundMinSupport)
    4、lowerBoundMinSupport :最小支持度下界。

    5、metricType :度量类型,设置对规则进行排序的度量依据。可以选择是:置信度(Confidence,
    注意:类关联规则只能用置信度挖掘),提升度(Lift),杠杆率(Leverage),确信度(Conviction)。
    (1)Confidence(conf):Confidence(A==>B)=Support(AUB)/Support(A)注意:AUB表
    示同时包含A和B的支持项。比如:剧情=True 4 ==> 动作=True 2 计算出 Confidence=2/4=0.5。

    (2)Lift (lift): P(A,B)/(P(A)P(B)) Lift=1时表示A和B独立。这个数越大(>1),越表明A和B存在于一个购物篮中不是偶然现象,有较强的关联度。注意:P(A)是指包含A属性数目在所有原始项目集数目的比例
    (3)Leverage (lev):P(A,B)-P(A)P(B)Leverage=0时A和B独立,Leverage越大A和B的关系越密切。
    (4)Conviction(conv):P(A)P(!B)/P(A,!B) (!B表示B没有发生) Conviction也是用来衡量A和B的独立性。从它和lift的关系(对B取反,代入Lift公式后求倒数)可以看出,这个值越大, A、B越关联。

    6、minMtric :度量的最小值,指的是你上一步选择的度量类型的度量最小值比如默认选择了Confidence,那么Confidence的度量最小值就是minMtric设置的值,在后面生成的Best rules found中Confidence若比这个度量最小值还小就会被直接删掉不会出现,比如minMtric=0.9,Conf=0.8,则不会出现。

    7、numRules :最多需要发现的规则数,会把发现的规则数进行排序,最多把前numRules个显示出来,比如numRules=10,那么就是最多显示十条规则数。

    8、outputItemSets :如果设置为True,会在结果Size of set of large itemsets L(X)中输出具体项集而不仅仅是项集数目(Size of set of large itemsets)。

    9、removeAllMissingCols: 移除全部为缺省值的列。

    10、significanceLevel :重要程度,重要性测试(仅用于置信度)。

    11、upperBoundMinSupport: 最小支持度上界,从这个值开始迭代减小到大于等于最小支持度。

    12、verbose :如果设置为True,则算法会以冗余模式运行。
    在这里插入图片描述

    十二、点击紫色箭头指向的紫色框中的内容(Start)。

    在这里插入图片描述

    十三:成功生成相应关联规则(见下图)。

    在这里插入图片描述

    十四(重要)、相应颜色框对应相应属性值设置内容,左边颜色框的内容随右边相应颜色框的修改内容改变而改变。注意:Minimum support: 0.2 (2 instances)中instances的计算过程是:0.2X10=2。公式:四舍五入(最小支持度x项目总数)。instances的作用是为挑选minsup_count>=instances的值组成X-频繁项目集(X取1,2,3…)如下图中的L(1)是频繁项目集。Minimum metric 值的作用是:下面的Best rules found:中的conf必须大于等于Minimum metric 值才能进入频繁项目集。

    在这里插入图片描述

    展开全文
  • weka-实现Apriori算法

    千次阅读 2018-12-03 18:42:01
    weka-实现Apriori算法

    weka实现Apriori算法有两种方式:第一种是可视化方式,直接使用weka软件进行关联规则挖掘;第二种是调用其提供的Java API

    0. 数据准备

    先将数据转化为csv或arff格式,若数据含有数值属性(numerical),则应先离散化,因为Apriori算法只能对标称属性(nominal)进行分析。样例数据如下:

    @relation stu
    
    @attribute Arbori_binari_de_cautare {TRUE, FALSE}
    @attribute Arbori_optimali {TRUE, FALSE}
    @attribute Arbori_echilibrati_in_inaltime {TRUE, FALSE}
    @attribute Arbori_Splay {TRUE, FALSE}
    @attribute Arbori_rosu_negru {TRUE, FALSE}
    @attribute Arbori_2_3 {TRUE, FALSE}
    @attribute Arbori_B {TRUE, FALSE}
    @attribute Arbori_TRIE {TRUE, FALSE}
    @attribute Sortare_topologica {TRUE, FALSE}
    @attribute Algoritmul_Dijkstra {TRUE, FALSE}
    
    @data
    TRUE,TRUE,TRUE,TRUE,FALSE,FALSE,TRUE,TRUE,FALSE,FALSE
    TRUE,TRUE,TRUE,TRUE,TRUE,TRUE,FALSE,TRUE,FALSE,FALSE
    FALSE,TRUE,TRUE,TRUE,FALSE,FALSE,FALSE,TRUE,FALSE,TRUE
    FALSE,TRUE,FALSE,FALSE,TRUE,FALSE,TRUE,TRUE,FALSE,TRUE
    TRUE,TRUE,FALSE,TRUE,TRUE,FALSE,TRUE,TRUE,FALSE,TRUE
    TRUE,FALSE,TRUE,FALSE,FALSE,TRUE,TRUE,TRUE,FALSE,FALSE
    FALSE,TRUE,FALSE,TRUE,TRUE,FALSE,TRUE,TRUE,FALSE,TRUE
    TRUE,FALSE,TRUE,TRUE,TRUE,FALSE,TRUE,TRUE,TRUE,FALSE
    FALSE,TRUE,TRUE,TRUE,TRUE,FALSE,FALSE,TRUE,FALSE,FALSE
    TRUE,FALSE,TRUE,FALSE,TRUE,TRUE,FALSE,TRUE,FALSE,TRUE
    FALSE,FALSE,TRUE,FALSE,TRUE,FALSE,FALSE,TRUE,TRUE,TRUE
    TRUE,FALSE,FALSE,TRUE,TRUE,TRUE,FALSE,TRUE,FALSE,TRUE
    FALSE,TRUE,TRUE,FALSE,TRUE,TRUE,FALSE,TRUE,FALSE,TRUE
    TRUE,TRUE,TRUE,FALSE,FALSE,TRUE,FALSE,TRUE,FALSE,FALSE
    TRUE,TRUE,FALSE,FALSE,TRUE,TRUE,FALSE,TRUE,FALSE,FALSE
    

    1. weka软件的方式

    Explorer→Open File→Associate→Choose Apriori→Click Apriori to set→Start
    weka-Apriori

    1.1 参数分析

    在这里插入图片描述

    1-car : 若设置为true,则会挖掘类关联规则而不是全局关联规则;
    2-classindex : 类属性索引,如果设置为-1,最后的属性被当做类属性;
    3-delta : 以此数值为迭代递减单位,不断减小支持度直至达到最小支持度或产生了满足数量要求的规则;
    4-lowerBoundMinSupport : 最小支持度下界;
    5-metricType : 度量类型,设置对规则进行排序的度量依据,可以是置信度(类关联规则只能用置信度挖掘),提升度(lift),杠杆率(leverage),确信度(conviction);
    5.1-Lift : P(A,B)/(P(A)P(B)),Lift=1时表示A和B独立,这个数越大(>1),越表明A和B存在于一个购物篮中不是偶然现象,有较强的关联度
    5.2-Leverage : P(A,B)-P(A)P(B),Leverage=0时A和B独立,Leverage越大A和B的关系越密切
    5.3-Conviction : P(A)P(!B)/P(A,!B),用来衡量A和B的独立性,这个值越大,A和B越关联
    6-minMtric : 度量的最小值;
    7-numRules : 要挖掘的规则数;
    8-outputItemSets : 如果设置为真,会在结果中输出项集;
    9-removeAllMissingCols : 移除全部为缺省值的列;
    10-significanceLevel : 重要程度,重要性测试(仅用于置信度);
    11-upperBoundMinSupport : 最小支持度上界,从这个值开始迭代减小最小支持度;
    12- verbose : 如果设置为真,则算法会以冗余模式运行.

    2. Java API方式

    public void apriori(String path) {
            Instances data = null;
            try {
                BufferedReader reader = new BufferedReader(new FileReader(path));
                data = new Instances(reader);
                reader.close();
                data.setClassIndex(data.numAttributes() - 1);
            } catch (IOException e) {
                e.printStackTrace();
            }
            Apriori apriori = new Apriori();
            double delta = 0.05;
            double lowerBoundMinSupport = 0.1;
            double upperBoundMinSupport = 1.0;
            double minMetric = 0.5;
            int numRules = 20;
            String res;
            apriori.setDelta(delta);
            apriori.setLowerBoundMinSupport(lowerBoundMinSupport);
            apriori.setUpperBoundMinSupport(upperBoundMinSupport);
            apriori.setNumRules(numRules);
            apriori.setMinMetric(minMetric);
            try {
                apriori.buildAssociations(data);
            } catch (Exception e) {
                e.printStackTrace();
            }
            res = apriori.toString();
            System.out.println(res);
        }
    

    2.1 结果如下

    java-weka-apriori-运行结果

    展开全文
  • 关联规则算法最出名的例子就是啤酒和尿布放一起卖。 假如我们去超市买东西,付款后,会拿到一张购物清单。这个清单就是一个Transaction。对关联规则算法来说,每个产品的购买数量是无意义的,不参与计算。 许...

    关联规则算法最出名的例子就是啤酒和尿布放一起卖。


    假如我们去超市买东西,付款后,会拿到一张购物清单。这个清单就是一个Transaction。对关联规则算法来说,每个产品的购买数量是无意义的,不参与计算。


    许许多多的人买东西,生成了N个购物清单,也就是N个Transaction。


    那么,这些Transaction上的货物之间有什么有用的关系呢?这些关系可以用什么方式表达出来呢?这就是关联规则算法要解决的问题。


    下面,我们用一个具体的例子解释这个问题:


    1. 假设有三个Transaction分别是:

    t1 = {'a', 'b', 'c', 'd'}

    t2 = {'a', 'c', 'e'};

    t3 = {'b', 'c', 'f'}

    其中,abcdef都是货物的ID,简写是为了方便理解。


    2. 我们看一下,就知道只要买了'a',就可能会买'c',或者说,只要买了'c'就很可能买了'a',而且,在2个Transaction上都出现了。这个规律可以表达成:

      'c' ==> 'a'(66.67%)

    后面的66.67%叫支持度,也就是'a'和'c'在一起出现的次数,处以c的次数,也就2/3=66.67%。


    3. 这就是关联规则,各种关联规则算法要解决的是在样本数据很大或者样本数量很多的情况下计算关联规则,以及减少内存,提高计算速度。


    4. 那么,apriori算法是如何做的呢?算法流程是这样的:

        4.1 先从所有的transaction遍历出所有货物id,也就{'a', 'b', 'c', 'd', 'e', 'f'}

        4.2 再计算每个货物id在所有transaction上出现次数总和,也就是{'a':2, 'b':2, 'c':3, 'd':1, 'e':1, 'f':1}

        4.3 有经验的同学可以知道上述两个步骤用HashMap能一次性搞定

        4.4 对4.2的结果,将出现次数少于一个最小支持数阈值的货物id删除,如果阈值是1,则剩下的结果就是{'a':2, 'b':2, 'c':3}

        4.5 对4.4的结果,生成一项频繁集,也就是{{'a'}, {'b'}, {'c'}}

        4.6 到这里为止,就得到了apriori算法的核心,频繁集,以后的所有计算都是在频繁集上进行:

            4.6.1 根据一项频繁集,生成二项频繁集,也就是{{'a','b'}, {'a','c'}, {'b','c'}},也就是任意两个一项频繁集的组合。

            4.6.2 计算二项频繁集的货物id同时在所有transaction上的出现次数:{{'a','b'}:1, {'a','c'}:2, {'b','c'}:2}

            4.6.3 根据最小支持数阈值=1,删除4.6.2的低值二项频繁集,其结果就是{{'a','c'}:2, {'b','c'}:2}

            4.6.4 根据二项频繁集合计算关联规则:

                      'c' ==> 'a'(66.67%)

                      'c' ==> 'b'(66.67%)

             4.6.5 根据二项频繁集,计算三项频繁集以及在三项频繁集上的关联规则,其步骤类似4.6.1~4.6.4。

             4.6.6 上述计算步骤,可以写成一个while循环,计算到高次频繁集为空,也就是不在有新规则产生为止。然后输出所有的规则。算法结束。


    5. 几个问题

        5.1 关联规则不能处理连续值属性,所有要将连续值属性转化成nominal属性进行计算。

        5.2. 如果样本的属性值很多,或者transaction总数很多,apriori算法会很慢,因为每一轮计算都需要查询整个数据库。为此,学者们提出很多优化算法,剪切,并行,fp-growth等等。







    转载于:https://my.oschina.net/u/3226063/blog/826146

    展开全文
  • weka实现的apriori算法是在weka.associations包的Apriror类。 在这个类,挖掘关联规则的入口函数是public void buildAssociations(Instances instances),而instances就是数据集,检查数据,设置参数,初始...
  • wekaApriori算法 关联规则挖掘实验

    千次阅读 2015-10-31 18:40:49
    wekaApriori算法 关联规则挖掘实验   一、Apriori算法参数含义 本次共进行了9组实验,使用了weka安装目录data文件夹下的contact-lenses.arff数据。     ToolsàArffViewer,打开contact-lenses,可以...
  • APRIORI算法中使用链表来实现对频繁项集的数据挖掘,在生成k项集时使用FK-1*FK-1的算法,在生成K-项集时直接删除支持度不满足最小阈值的项。
  • 在阐述了关联规则算法Apriori...weka源代码中实现Apriori算法的基础核心类包和算法实现类包中的关键类以及这些类内部的关键函数及变 量,为探索通过weka源代码学习和研究数据挖掘算法及其实现方法提供了很好的帮助。
  • weka apriori算法详解以及参数详解

    千次阅读 2018-01-11 11:13:00
    % scheme -所选的关联规则挖掘方案: Apriori算法 % 算法的参数设置:-I -N 10 -T 0 -C 0.9 -D 0.05 -U 1.0 -M 0.5 -S -1.0 -c -1 ; % 各参数依次表示: % I - 输出项集,若设为false则该值缺省; ...
  • weka apriori 关联规则

    2010-06-24 21:18:47
    详细讲述了weka关联规则apriori算法解析,详细,值得学习
  • wekaApriori算法 关联规则挖掘详解

    万次阅读 2012-02-28 09:50:19
    ...一、Apriori算法参数含义 本次共进行了9组实验,使用了weka安装目录data文件夹下的contact-lenses.arff数据。     ToolsàArffViewer,打开contact-lenses,可以看到实验数据contact-l
  • apriori算法的计算量太大,如果数据集略大一些,会比较慢,非常容易内存溢出。 我们可以算一下复杂度:假设样本数有N个,样本属性为M个,每个样本属性平均有K个nominal值。 1. 计算一项频繁集的时间复杂度是O(N*...
  • 关联规则挖掘Apriori算法的实现 实验目的 1.掌握频繁项目集的生成原理 2.掌握关联规则挖掘的原理 3.掌握在weka中进行关联规则挖掘的具体流程。 实验内容 1.根据给定的事务数据库,支持数阈值2和置信度阈值0.7...
  • wekaApriori算法实现与分析

    千次阅读 2016-11-16 21:00:52
    一、Apriori算法参数含义 本次共进行了9组实验,使用了weka安装目录data文件夹下的contact-lenses.arff数据。     ToolsàArffViewer,打开contact-lenses,可以看到实验数据contact-lens
  • 关联分析:Apriori和FPgrowth算法原理

    千次阅读 2019-04-03 23:41:14
    文章目录关联分析:频繁项集和关联规则Apriori算法原理 关联分析:频繁项集和关联规则 从大规模的数据中发现物品间隐含关系的方法被称为关联分析。关联分析是一种在大规模数据集中寻找有趣关系的任务。 这些任务有...
  • 基于weka对银行客户信息的关联分析及apriori算法实现,包含数据集和设计报告在内。
  • weka进行apriori关联规则挖掘,weka版本为3.6.101、将excel表格中的数据另存为csv格式,若弹出一下对话款,选择否,再另存为一份xlsx格式即可,否则在weka中无法打开。weka默认首行为属性名。2、用weka打开.csv格式...
  • 通过关联规则算法Apriori解读Weka源代码
  • 前段时间在使用数据挖掘工具weka对大量数据进行挖掘,首先通过自己编写的一个小程序将原始数据转换成了arff格式的文档, 但是可能是因为数据量大,weka计算不出来。 也可能是weka为了通用性对输入的数据进行了处理,...
  • 关联规则Apriori算法,项集,频繁项集,关联规则Apriori算法
  • Weka-- Apriori算法实例操作详解

    千次阅读 2015-03-11 16:28:38
    一、Apriori算法参数含义 本次共进行了9组实验,使用了weka安装目录data文件夹下的contact-lenses.arff数据。     ToolsàArffViewer,打开contact-lenses,可以看到实验数据contact-lenses共有24条记录,5...
  • 问题二:关联规则apriori算法无法运行问题 问题描述: 打开上述问题一中的文件,发现关联算法中的Apriori算法界面如下图所示 start按钮灰色无法开始运行Apriori算法 问题解决方法: 这是因为我们是此时的数据...
  • weka Apriori算法实例操作详解

    千次阅读 2016-08-29 20:18:01
    wekaApriori算法 关联规则挖掘实验   一、Apriori算法参数含义 本次共进行了9组实验,使用了weka安装目录data文件夹下的contact-lenses.arff数据。     ToolsàArffViewer,打开contact-...
  • weka中的apriori

    2021-03-09 22:28:23
    完整的实验结果输出及具体分析=== Run information===//实验运行信息Scheme:weka.associations.Apriori-I -N 10 -T 0 -C 0.9 -D 0.05 -U 1.0 -M 0.5 -S -1.0 -c-1Relation:contact-lenses//数据的名称contact-...
  • WekaApriori算法实用与分析

    万次阅读 2013-12-23 13:35:53
    一、Apriori算法参数含义 本次共进行了9组实验,使用了weka安装目录data文件夹下的contact-lenses.arff数据。     ToolsàArffViewer,打开contact-lenses,可以看到实验数据contact-lenses共有24条记录,5个...
  • weka不能使用Apriori/FPGrowth

    千次阅读 2016-11-09 16:55:20
    一开始想用weka跑一组关联规则挖掘看看,但老是点击不了开始(start) 后来发现原因是数据类型设的numeric 改成离散型的,就可以了 在arff文件里把所有的属性的数据类型改过来就好了,如下 @attribute A1 numeric...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 788
精华内容 315
关键字:

weka关联规则apriori算法