精华内容
下载资源
问答
  • weka数据挖掘

    2013-05-04 22:41:38
    weka数据挖掘,用于实现当前最流行的数据挖掘技术的工具
  • weka 数据挖掘 数据集

    2014-03-14 14:02:00
    weka数据挖掘的数据集 很好用,对于数据挖掘的初使用着有很好的启发作业
  • Weka数据挖掘

    千次阅读 2013-09-10 10:02:11
    WEKA的全名是怀卡托智能分析环境(Waikato Environment for Knowledge Analysis),它...同时weka也是新西兰的一种鸟名,而WEKA的主要开发者来自新西兰。  详见 http://www.china-pub.com/computers/common/info.asp
    WEKA的全名是怀卡托智能分析环境(Waikato Environment for Knowledge Analysis),它的源代码可通过http://www.cs.waikato.ac.nz/ml/weka得到。同时weka也是新西兰的一种鸟名,而WEKA的主要开发者来自新西兰。 

    详见 
    http://www.china-pub.com/computers/common/info.asp?id=29304 

    2. 数据格式
     

    跟很多电子表格或数据分析软件一样,WEKA所处理的数据集是一个如图1一样的二维表格。 
    4 
    这里我们要介绍一下WEKA中的术语。表格里的一个横行称作一个实例(Instance),相当于统计学中的一个样本,或者数据库中的一条记录。 竖行称作一个属性(Attrbute),相当于统计学中的一个变量,或者数据库中的一个字段。这样一个表格,或者叫数据集,在WEKA看来,呈现了属性之 间的一种关系(Relation)。图1中一共有14个实例,5个属性,关系名称为“weather”。 
    WEKA存储数据的格式是ARFF(Attribute-Relation File Format)文件,这是一种ASCII文本文件。图1所示的二维表格存储在如下的ARFF文件中。这也就是WEKA自带的“weather.arff” 文件,在WEKA安装目录的“data”子目录下可以找到。 
    代码:
    % ARFF file for the weather data with some numric features 

    @relation weather 

    @attribute outlook {sunny, overcast, rainy} 
    @attribute temperature real 
    @attribute humidity real 
    @attribute windy {TRUE, FALSE} 
    @attribute play {yes, no} 

    @data 

    % 14 instances 

    sunny,85,85,FALSE,no 
    sunny,80,90,TRUE,no 
    overcast,83,86,FALSE,yes 
    rainy,70,96,FALSE,yes 
    rainy,68,80,FALSE,yes 
    rainy,65,70,TRUE,no 
    overcast,64,65,TRUE,yes 
    sunny,72,95,FALSE,no 
    sunny,69,70,FALSE,yes 
    rainy,75,80,FALSE,yes 
    sunny,75,70,TRUE,yes 
    overcast,72,90,TRUE,yes 
    overcast,81,75,FALSE,yes 
    rainy,71,91,TRUE,no 

    需要注意的是,在Windows记事本打开这个文件时,可能会因为回车符定义不一致而导致分行不正常。推荐使用UltraEdit这样的字符编辑软件察看ARFF文件的内容。 

    下面我们来对这个文件的内容进行说明。 
    识别ARFF文件的重要依据是分行,因此不能在这种文件里随意的断行。空行(或全是空格的行)将被忽略。 
    以“%”开始的行是注释,WEKA将忽略这些行。如果你看到的“weather.arff”文件多了或少了些“%”开始的行,是没有影响的。 
    除去注释后,整个ARFF文件可以分为两个部分。第一部分给出了头信息(Head information),包括了对关系的声明和对属性的声明。第二部分给出了数据信息(Data information),即数据集中给出的数据。从“@data”标记开始,后面的就是数据信息了。 

    关系声明 
    关系名称在ARFF文件的第一个有效行来定义,格式为 
    @relation 
    是一个字符串。如果这个字符串包含空格,它必须加上引号(指英文标点的单引号或双引号)。 

    属性声明 
    属性声明用一列以“@attribute”开头的语句表示。数据集中的每一个属性都有它对应的“@attribute”语句,来定义它的属性名称和数据类型。 
    这些声明语句的顺序很重要。首先它表明了该项属性在数据部分的位置。例如,“humidity”是第三个被声明的属性,这说明数据部分那些被逗号 分开的列中,第三列数据 85 90 86 96 ... 是相应的“humidity”值。其次,最后一个声明的属性被称作class属性,在分类或回归任务中,它是默认的目标变量。 
    属性声明的格式为 
    @attribute 
    其中是必须以字母开头的字符串。和关系名称一样,如果这个字符串包含空格,它必须加上引号。 
    WEKA支持的有四种,分别是 
    numeric-------------------------数值型 
    -----分类(nominal)型 
    string----------------------------字符串型 
    date []--------日期和时间型 
    其中 和 将在下面说明。还可以使用两个类型“integer”和“real”,但是WEKA把它们都当作“numeric”看待。注意 “integer”,“real”,“numeric”,“date”,“string”这些关键字是区分大小写的,而 “relation”“attribute ”和“date”则不区分。 

    数值属性 
    数值型属性可以是整数或者实数,但WEKA把它们都当作实数看待。 

    分类属性 
    分类属性由列出一系列可能的类别名称并放在花括号中:{, , , ...} 。数据集中该属性的值只能是其中一种类别。 
    例如如下的属性声明说明“outlook”属性有三种类别:“sunny”,“ overcast”和“rainy”。而数据集中每个实例对应的“outlook”值必是这三者之一。 
    @attribute outlook {sunny, overcast, rainy} 
    如果类别名称带有空格,仍需要将之放入引号中。 

    字符串属性 
    字符串属性中可以包含任意的文本。这种类型的属性在文本挖掘中非常有用。 
    示例: 
    @ATTRIBUTE LCC string 

    日期和时间属性 
    日期和时间属性统一用“date”类型表示,它的格式是 
    @attribute date [] 
    其中是这个属性的名称,是一个字符串,来规定该怎样解析和显示日期或时间的格式,默认的字符串是ISO-8601所给的日期时间组合格式“yyyy-MM-ddTHH:mm:ss”。 
    数据信息部分表达日期的字符串必须符合声明中规定的格式要求(下文有例子)。 

    数据信息 
    数据信息中“@data”标记独占一行,剩下的是各个实例的数据。 

    每个实例占一行。实例的各属性值用逗号“,”隔开。如果某个属性的值是缺失值(missing value),用问号“?”表示,且这个问号不能省略。例如: 
    @data 
    sunny,85,85,FALSE,no 
    ?,78,90,?,yes 


    字符串属性和分类属性的值是区分大小写的。若值中含有空格,必须被引号括起来。例如: 
    @relation LCCvsLCSH 
      @attribute LCC string 
      @attribute LCSH string 
      @data 
      AG5, 'Encyclopedias and dictionaries.;Twentieth century.' 
      AS262, 'Science -- Soviet Union -- History.' 


    日期属性的值必须与属性声明中给定的相一致。例如: 
    @RELATION Timestamps 
      @ATTRIBUTE timestamp DATE "yyyy-MM-dd HH:mm:ss" 
      @DATA 
      "2001-04-03 12:12:12" 
      "2001-05-03 12:59:55"
     

    稀疏数据 
    有的时候数据集中含有大量的0值(比如购物篮分析),这个时候用稀疏格式的数据存贮更加省空间。 
    稀疏格式是针对数据信息中某个实例的表示而言,不需要修改ARFF文件的其它部分。看如下的数据: 
    @data 
      0, X, 0, Y, "class A" 
      0, 0, W, 0, "class B"
     
    用稀疏格式表达的话就是 
    @data 
      {1 X, 3 Y, 4 "class A"} 
      {2 W, 4 "class B"}
     
    每个实例用花括号括起来。实例中每一个非0的属性值用 <空格> 表示。是属性的序号,从0开始计;是属性值。属性值之间仍用逗号隔开。 这里每个实例的数值必须按属性的顺序来写,如 {1 X, 3 Y, 4 "class A"},不能写成{3 Y, 1 X, 4 "class A"}。 
    注意在稀疏格式中没有注明的属性值不是缺失值,而是0值。若要表示缺失值必须显式的用问号表示出来。 

    Relational型属性 
    在WEKA 3.5版中增加了一种属性类型叫做Relational,有了这种类型我们可以像关系型数据库那样处理多个维度了。但是这种类型目前还不见广泛应用,暂不作介绍。 

    --整理自
    http://www.cs.waikato.ac.nz/~ml/weka/arff.html 和http://weka.sourceforge.net/wekadoc/index.php/en:ARFF_%283.5.3%29 

    3.数据准备 

    使用WEKA作数据挖掘,面临的第一个问题往往是我们的数据不是ARFF格式的。幸好,WEKA还提供了对CSV文件的支持,而这种格式是被很多其他软件所支持的。此外,WEKA还提供了通过JDBC访问数据库的功能。 
    在这一节里,我们先以Excel和Matlab为例,说明如何获得CSV文件。然后我们将知道CSV文件如何转化成ARFF文件,毕竟后者才是WEKA支持得最好的文件格式。面对一个ARFF文件,我们仍有一些预处理要做,才能进行挖掘任务。 

    .* -> .csv 
    我们给出一个CSV文件的例子(
    bank-data.csv)。用UltraEdit打开它可以看到,这种格式也是一种逗号分割数据的文本文件,储存了一个二维表格。

    Excel的XLS文件可以让多个二维表格放到不同的工作表(Sheet)中,我们只能把每个工作表存成不同的CSV文件。打开一个XLS文件并切换到需要转换的工作表,另存为CSV类型,点“确定”、“是”忽略提示即可完成操作。 

    在Matlab中的二维表格是一个矩阵,我们通过这条命令把一个矩阵存成CSV格式。 
    csvwrite('filename',matrixname) 
    需要注意的是,Matllab给出的CSV文件往往没有属性名(Excel给出的也有可能没有)。而WEKA必须从CSV文件的第一行读取属性 名,否则就会把第一行的各属性值读成变量名。因此我们对于Matllab给出的CSV文件需要用UltraEdit打开,手工添加一行属性名。注意属性名 的个数要跟数据属性的个数一致,仍用逗号隔开。 

    .csv -> .arff 
    将CSV转换为ARFF最迅捷的办法是使用WEKA所带的命令行工具。 
    运行WEKA的主程序,出现GUI后可以点击下方按钮进入相应的模块。我们点击进入“Simple CLI”模块提供的命令行功能。在新窗口的最下方(上方是不能写字的)输入框写上 
    java weka.core.converters.CSVLoader filename.csv > filename.arff 
    即可完成转换。 
    在WEKA 3.5中提供了一个“Arff Viewer”模块,我们可以用它打开一个CSV文件将进行浏览,然后另存为ARFF文件。 
    进入“Exploer”模块,从上方的按钮中打开CSV文件然后另存为ARFF文件亦可。 

    “Exploer”界面 
    我们应该注意到,“Exploer”还提供了很多功能,实际上可以说这是WEKA使用最多的模块。现在我们先来熟悉它的界面,然后利用它对数据进行预处理。  
    5 
    图2 
    新窗口打开 
    图2显示的是使用3.5版"Exploer"打开"bank-data.csv"的情况。我们根据不同的功能把这个界面分成8个区域。 
    区域1的几个选项卡是用来切换不同的挖掘任务面板。这一节用到的只有“Preprocess”,其他面板的功能将在以后介绍。 
    区域2是一些常用按钮。包括打开数据,保存及编辑功能。我们在这里把"bank-data.csv"另存为"bank-data.arff"。 
    在区域3中“Choose”某个“Filter”,可以实现筛选数据或者对数据进行某种变换。数据预处理主要就利用它来实现。 
    区域4展示了数据集的一些基本情况。 
    区域5中列出了数据集的所有属性。勾选一些属性并“Remove”就可以删除它们,删除后还可以利用区域2的“Undo”按钮找回。区域5上方的一排按钮是用来实现快速勾选的。 
    在区域5中选中某个属性,则区域6中有关于这个属性的摘要。注意对于数值属性和分类属性,摘要的方式是不一样的。图中显示的是对数值属性“income”的摘要。 
    区域7是区域5中选中属性的直方图。若数据集的最后一个属性(我们说过这是分类或回归任务的默认目标变量)是分类变量(这里的“pep”正好 是),直方图中的每个长方形就会按照该变量的比例分成不同颜色的段。要想换个分段的依据,在区域7上方的下拉框中选个不同的分类属性就可以了。下拉框里选 上“No Class”或者一个数值属性会变成黑白的直方图。 
    区域8是状态栏,可以查看Log以判断是否有错。右边的weka鸟在动的话说明WEKA正在执行挖掘任务。右键点击状态栏还可以执行JAVA内存的垃圾回收。 

    预处理 
    bank-data数据各属性的含义如下: 
    id a unique identification number 
    age age of customer in years (numeric) 
    sex MALE / FEMALE 
    region inner_city/rural/suburban/town 
    income income of customer (numeric) 
    married is the customer married (YES/NO) 
    children number of children (numeric) 
    car does the customer own a car (YES/NO) 
    save_acct does the customer have a saving account (YES/NO) 
    current_acct does the customer have a current account (YES/NO) 
    mortgage does the customer have a mortgage (YES/NO) 
    pep did the customer buy a PEP (Personal Equity Plan) after the last mailing (YES/NO) 

    通常对于数据挖掘任务来说,ID这样的信息是无用的,我们将之删除。在区域5勾选属性“id”,并点击“Remove”。将新的数据集保存一次,并用UltraEdit打开这个ARFF文件。我们发现,在属性声明部分,WEKA已经为每个属性选好了合适的类型。 

    我们知道,有些算法,只能处理所有的属性都是分类型的情况。这时候我们就需要对数值型的属性进行离散化。在这个数据集中有3个变量是数值型的,分别是“age”,“income”和“children”。 
    其中“children”只有4个取值:0,1,2,3。这时我们在UltraEdit中直接修改ARFF文件,把 
    @attribute children numeric 
    改为 
    @attribute children {0,1,2,3} 
    就可以了。 
    在“Explorer”中重新打开“bank-data.arff”,看看选中“children”属性后,区域6那里显示的“Type”是不是变成“Nominal”了? 

    “age”和“income”的离散化我们需要借助WEKA中名为“Discretize”的Filter来完成。在区域2中点 “Choose”,出现一棵“Filter树”,逐级找到 “weka.filters.unsupervised.attribute.Discretize”,点击。若无法关闭这个树,在树之外的地方点击 “Explorer”面板即可。 
    现在“Choose”旁边的文本框应该显示“Discretize -B 10 -M -0.1 -R first-last”。 点击这个文本框会弹出新窗口以修改离散化的参数。 
    我们不打算对所有的属性离散化,只是针对对第1个和第4个属性(见区域5属性名左边的数字),故把attributeIndices右边改成 “1,4”。计划把这两个属性都分成3段,于是把“bins”改成“3”。其它框里不用更改,关于它们的意思可以点“More”查看。点“OK”回到 “Explorer”,可以看到“age”和“income”已经被离散化成分类型的属性。若想放弃离散化可以点区域2的“Undo”。 
    如果对“"(-inf-34.333333]"”这样晦涩的标识不满,我们可以用UltraEdit打开保存后的ARFF文件,把所有的“'"'(-inf-34.333333]"''”替换成“0_34”。其它标识做类似地手动替换。 

    经过上述操作得到的数据集我们保存为
    bank-data-final.arff。 

    ----整理自
    http://maya.cs.depaul.edu/~classes/ect584/WEKA/preprocess.html 


    4. 关联规则(购物篮分析) 
    注意:目前,WEKA的关联规则分析功能仅能用来作示范,不适合用来挖掘大型数据集。 

    我们打算对前面的“bank-data”数据作关联规则的分析。用“Explorer”打开“bank-data-final.arff”后,切 换到“Associate”选项卡。默认关联规则分析是用Apriori算法,我们就用这个算法,但是点“Choose”右边的文本框修改默认的参数,弹 出的窗口中点“More”可以看到各参数的说明。 

    背景知识 
    首先我们来温习一下Apriori的有关知识。对于一条关联规则L->R,我们常用支持度(Support)和置信度(Confidence)来衡量它的重要性。规则的支持度是用来估计在一个购物篮中同时观察到L和R的概率P(L,R),而规则的置信度是估计购物栏中出现了L时也出会现R的条件概率P(R|L)。关联规则的目标一般是产生支持度和置信度都较高的规则。 
    有几个类似的度量代替置信度来衡量规则的关联程度,它们分别是 
    Lift(提升度?): P(L,R)/(P(L)P(R)) 
    Lift=1时表示L和R独立。这个数越大,越表明L和R存在在一个购物篮中不是偶然现象。 
    Leverage(不知道怎么翻译):P(L,R)-P(L)P(R) 
    它和Lift的含义差不多。Leverage=0时L和R独立,Leverage越大L和R的关系越密切。 
    Conviction(更不知道译了):P(L)P(!R)/P(L,!R) (!R表示R没有发生) 
    Conviction也是用来衡量L和R的独立性。从它和lift的关系(对R取反,代入Lift公式后求倒数)可以看出,我们也希望这个值越大越好。 
    值得注意的是,用Lift和Leverage作标准时,L和R是对称的,Confidence和Conviction则不然。 

    参数设置 
    现在我们计划挖掘出支持度在10%到100%之间,并且lift值超过1.5且lift值排在前100位的那些关联规则。我们把 “lowerBoundMinSupport”和“upperBoundMinSupport”分别设为0.1和1,“metricType”设为 lift,“minMetric”设为1.5,“numRules”设为100。其他选项保持默认即可。“OK” 之后在“Explorer”中点击“Start”开始运行算法,在右边窗口显示数据集摘要和挖掘结果。 

    下面是挖掘出来的lift排前5的规则。 
    Best rules found: 
    1. age=52_max save_act=YES current_act=YES 113 ==> income=43759_max 61 conf:(0.54) < lift:(4.05)> lev:(0.08) [45] conv:(1.85) 
      2. income=43759_max 80 ==> age=52_max save_act=YES current_act=YES 61 conf:(0.76) < lift:(4.05)> lev:(0.08) [45] conv:(3.25) 
      3. income=43759_max current_act=YES 63 ==> age=52_max save_act=YES 61 conf:(0.97) < lift:(3.85)> lev:(0.08) [45] conv:(15.72) 
      4. age=52_max save_act=YES 151 ==> income=43759_max current_act=YES 61 conf:(0.4) < lift:(3.85)> lev:(0.08) [45] conv:(1.49) 
      5. age=52_max save_act=YES 151 ==> income=43759_max 76 conf:(0.5) < lift:(3.77)> lev:(0.09) [55] conv:(1.72)
     
    对于挖掘出的每条规则,WEKA列出了它们关联程度的四项指标。 

    命令行方式 
    我们也可以利用命令行来完成挖掘任务,在“Simlpe CLI”模块中输入如下格式的命令: 
    java weka.associations.Apriori options -t directory-path"bank-data-final.arff 
    即可完成Apriori算法。注意,“-t”参数后的文件路径中不能含有空格。 
    在前面我们使用的option为 
    -N 100 -T 1 -C 1.5 -D 0.05 -U 1.0 -M 0.1 -S -1.0 命令行中使用这些参数得到的结果和前面利用GUI得到的一样。 
    我们还可以加上“- I”参数,得到不同项数的频繁项集。我用的命令如下: 
    java weka.associations.Apriori -N 100 -T 1 -C 1.5 -D 0.05 -U 1.0 -M 0.1 -S -1.0 -I -t d:"weka"bank-data-final.arff 
    挖掘结果在上方显示,应是
    这个文件的样子。 

    ----整理自
    http://maya.cs.depaul.edu/~classes/ect584/WEKA/associate.html

    5. 分类与回归 

    背景知识 
    WEKA把分类(Classification)和回归(Regression)都放在“Classify”选项卡中,这是有原因的。 
    在这两个任务中,都有一个目标属性(输出变量)。我们希望根据一个样本(WEKA中称作实例)的一组特征(输入变量),对目标进行预测。为了实现 这一目的,我们需要有一个训练数据集,这个数据集中每个实例的输入和输出都是已知的。观察训练集中的实例,可以建立起预测的模型。有了这个模型,我们就可 以新的输出未知的实例进行预测了。衡量模型的好坏就在于预测的准确程度。 
    在WEKA中,待预测的目标(输出)被称作Class属性,这应该是来自分类任务的“类”。一般的,若Class属性是分类型时我们的任务才叫分类,Class属性是数值型时我们的任务叫回归。 

    选择算法 
    这一节中,我们使用C4.5决策树算法对bank-data建立起分类模型。 
    我们来看原来的“
    bank-data.csv” 文件。“ID”属性肯定是不需要的。由于C4.5算法可以处理数值型的属性,我们不用像前面用关联规则那样把每个变量都离散化成分类型。尽管如此,我们还 是把“Children”属性转换成分类型的两个值“YES”和“NO”。另外,我们的训练集仅取原来数据集实例的一半;而从另外一半中抽出若干条作为待 预测的实例,它们的“pep”属性都设为缺失值。经过了这些处理的训练集数据在这里下载;待预测集数据在这里下载。 

    我们用“Explorer”打开训练集“bank.arff”,观察一下它是不是按照前面的要求处理好了。切换到“Classify”选项卡,点 击“Choose”按钮后可以看到很多分类或者回归的算法分门别类的列在一个树型框里。3.5版的WEKA中,树型框下方有一个“Filter...”按 钮,点击可以根据数据集的特性过滤掉不合适的算法。我们数据集的输入属性中有“Binary”型(即只有两个类的分类型)和数值型的属性,而Class变 量是“Binary”的;于是我们勾选“Binary attributes”“Numeric attributes”和“Binary class”。点“OK”后回到树形图,可以发现一些算法名称变红了,说明它们不能用。选择“trees”下的“J48”,这就是我们需要的C4.5算 法,还好它没有变红。 
    点击“Choose”右边的文本框,弹出新窗口为该算法设置各种参数。点“More”查看参数说明,点“Capabilities”是查看算法适用范围。这里我们把参数保持默认。 
    现在来看左中的“Test Option”。我们没有专门设置检验数据集,为了保证生成的模型的准确性而不至于出现过拟合(overfitting)的现象,我们有必要采用10折交 叉验证(10-fold cross validation)来选择和评估模型。若不明白交叉验证的含义可以
    Google一下。 

    建模结果 
    OK,选上“Cross-validation”并在“Folds”框填上“10”。点“Start”按钮开始让算法生成决策树模型。很快,用文 本表示的一棵决策树,以及对这个决策树的误差分析等等结果出现在右边的“Classifier output”中。同时左下的“Results list”出现了一个项目显示刚才的时间和算法名称。如果换一个模型或者换个参数,重新“Start”一次,则“Results list”又会多出一项。 

    我们看到“J48”算法交叉验证的结果之一为 
    Correctly Classified Instances 206 68.6667 % 
    也就是说这个模型的准确度只有69%左右。也许我们需要对原属性进行处理,或者修改算法的参数来提高准确度。但这里我们不管它,继续用这个模型。 

    右键点击“Results list”刚才出现的那一项,弹出菜单中选择“Visualize tree”,新窗口里可以看到图形模式的决策树。建议把这个新窗口最大化,然后点右键,选“Fit to screen”,可以把这个树看清楚些。看完后截图或者关掉:P 

    这里我们解释一下“Confusion Matrix”的含义。 
    === Confusion Matrix === 
      a b <-- classified as 
      74 64 | a = YES 
      30 132 | b = NO
     
    这个矩阵是说,原本“pep”是“YES”的实例,有74个被正确的预测为“YES”,有64个错误的预测成了“NO”;原本“pep”是 “NO”的实例,有30个被错误的预测为“YES”,有132个正确的预测成了“NO”。74+64+30+132 = 300是实例总数,而(74+132)/300 = 0.68667正好是正确分类的实例所占比例。这个矩阵对角线上的数字越大,说明预测得越好。 

    模型应用 
    现在我们要用生成的模型对那些待预测的数据集进行预测了。注意待预测数据集和训练用数据集各个属性的设置必须是一致的。即使你没有待预测数据集的Class属性的值,你也要添加这个属性,可以将该属性在各实例上的值均设成缺失值。 
    在“Test Opion”中选择“Supplied test set”,并且“Set”成你要应用模型的数据集,这里是“bank-new.arff”文件。 
    现在,右键点击“Result list”中刚产生的那一项,选择“Re-evaluate model on current test set”。右边显示结果的区域中会增加一些内容,告诉你该模型应用在这个数据集上表现将如何。如果你的Class属性都是些缺失值,那这些内容是无意义 的,我们关注的是模型在新数据集上的预测值。 
    现在点击右键菜单中的“Visualize classifier errors”,将弹出一个新窗口显示一些有关预测误差的散点图。点击这个新窗口中的“Save”按钮,保存一个Arff文件。打开这个文件可以看到在倒 数第二个位置多了一个属性(predictedpep),这个属性上的值就是模型对每个实例的预测值。 

    使用命令行(推荐) 
    虽然使用图形界面查看结果和设置参数很方便,但是最直接最灵活的建模及应用的办法仍是使用命令行。 
    打开“Simple CLI”模块,像上面那样使用“J48”算法的命令格式为: 
    java weka.classifiers.trees.J48 -C 0.25 -M 2 -t directory-path"bank.arff -d directory-path "bank.model 
    其中参数“ -C 0.25”和“-M 2”是和图形界面中所设的一样的。“-t ”后面跟着的是训练数据集的完整路径(包括目录和文件名),“-d ”后面跟着的是保存模型的完整路径。注意!这里我们可以把模型保存下来。 
    输入上述命令后,所得到树模型和误差分析会在“Simple CLI”上方显示,可以复制下来保存在文本文件里。误差是把模型应用到训练集上给出的。 
    把这个模型应用到“bank-new.arff”所用命令的格式为: 
    java weka.classifiers.trees.J48 -p 9 -l directory-path"bank.model -T directory-path "bank-new.arff 
    其中“-p 9”说的是模型中的待预测属性的真实值存在第9个(也就是“pep”)属性中,这里它们全部未知因此全部用缺失值代替。“-l”后面是模型的完整路径。“-T”后面是待预测数据集的完整路径。 
    输入上述命令后,在“Simple CLI”上方会有这样一些结果: 
    0 YES 0.75 ? 
    1 NO 0.7272727272727273 ? 
    2 YES 0.95 ? 
    3 YES 0.8813559322033898 ? 
    4 NO 0.8421052631578947 ? 
    ...
     
    这里的第一列就是我们提到过的“Instance_number”,第二列就是刚才的“predictedpep”,第四列则是“bank- new.arff”中原来的“pep”值(这里都是“?”缺失值)。第三列对预测结果的置信度(confidence )。比如说对于实例0,我们有75%的把握说它的“pep”的值会是“YES”,对实例4我们有84.2%的把握说它的“pep”值会是“NO”。 
    我们看到,使用命令行至少有两个好处。一个是可以把模型保存下来,这样有新的待预测数据出现时,不用每次重新建模,直接应用保存好的模型即可。另一个是对预测结果给出了置信度,我们可以有选择的采纳预测结果,例如,只考虑那些置信度在85%以上的结果。 

    ----整理自
    http://maya.cs.depaul.edu/~classes/ect584/WEKA/classify.html 



    6. 聚类分析 

    原理与实现 
    聚类分析中的“类”(cluster)和前面分类的“类”(class)是不同的,对cluster更加准确的翻译应该是“簇”。聚类的任务是把 所有的实例分配到若干的簇,使得同一个簇的实例聚集在一个簇中心的周围,它们之间距离的比较近;而不同簇实例之间的距离比较远。对于由数值型属性刻画的实 例来说,这个距离通常指欧氏距离。 
    现在我们对前面的“bank data”作聚类分析,使用最常见的K均值(K-means)算法。下面我们简单描述一下K均值聚类的步骤。 
    K均值算法首先随机的指定K个簇中心。然后:1)将每个实例分配到距它最近的簇中心,得到K个簇;2)计分别计算各簇中所有实例的均值,把它们作为各簇新的簇中心。重复1)和2),直到K个簇中心的位置都固定,簇的分配也固定。 

    上述K均值算法只能处理数值型的属性,遇到分类型的属性时要把它变为若干个取值0和1的属性。WEKA将自动实施这个分类型到数值型的变换,而且 WEKA会自动对数值型的数据作标准化。因此,对于原始数据“bank-data.csv”,我们所做的预处理只是删去属性“id”,保存为ARFF格式 后,修改属性“children”为分类型。这样得到的数据文件为“
    bank.arff”,含600条实例。 

    用“Explorer”打开刚才得到的“bank.arff”,并切换到“Cluster”。点“Choose”按钮选择 “SimpleKMeans”,这是WEKA中实现K均值的算法。点击旁边的文本框,修改“numClusters”为6,说明我们希望把这600条实例 聚成6类,即K=6。下面的“seed”参数是要设置一个随机种子,依此产生一个随机数,用来得到K均值算法中第一次给出的K个簇中心的位置。我们不妨暂 时让它就为10。 
    选中“Cluster Mode”的“Use training set”,点击“Start”按钮,观察右边“Clusterer output”给出的聚类结果。也可以在左下角“Result list”中这次产生的结果上点右键,“View in separate window”在新窗口中浏览结果。 

    结果解释 
    首先我们注意到结果中有这么一行: 
    Within cluster sum of squared errors: 1604.7416693522332 
    这是评价聚类好坏的标准,数值越小说明同一簇实例之间的距离越小。也许你得到的数值会不一样;实际上如果把“seed”参数改一下,得到的这个数值就可能会不一样。我们应该多尝试几个seed,并采纳这个数值最小的那个结果。例如我让“seed”取100,就得到 
    Within cluster sum of squared errors: 1555.6241507629218 
    我该取后面这个。当然再尝试几个seed,这个数值可能会更小。 

    接下来“Cluster centroids:”之后列出了各个簇中心的位置。对于数值型的属性,簇中心就是它的均值(Mean);分类型的就是它的众数(Mode), 也就是说这个属性上取值为众数值的实例最多。对于数值型的属性,还给出了它在各个簇里的标准差(Std Devs)。 

    最后的“Clustered Instances”是各个簇中实例的数目及百分比。 

    为了观察可视化的聚类结果,我们在左下方“Result list”列出的结果上右击,点“Visualize cluster assignments”。弹出的窗口给出了各实例的散点图。最上方的两个框是选择横坐标和纵坐标,第二行的“color”是散点图着色的依据,默认是根 据不同的簇“Cluster”给实例标上不同的颜色。 
    可以在这里点“Save”把聚类结果保存成ARFF文件。在这个新的ARFF文件中,“instance_number”属性表示某实例的编号,“Cluster”属性表示聚类算法给出的该实例所在的簇。 


    ----整理自 
    http://maya.cs.depaul.edu/~classes/ect584/WEKA/k-means.html
    展开全文
  • Weka数据挖掘——聚类

    千次阅读 2016-01-21 20:57:42
    Weka数据挖掘——聚类

    如果你渴望得到某样东西,你得让它自由,如果它回到你身边,它就是属于你的,如果它不回来,你就从未拥有过它。——大仲马《基督山伯爵》

    生活是一面镜子,我们努力追求的第一件事,就是从中辨认出自己。——尼采
    ###目录

    文章目录


    ###1 聚类概念
    关于聚类的一些相关的概念请看这里
    聚类是对物理对象或者抽象对象的集合进行分组的过程,所生成的组称为簇,簇是数据对象的集合。簇内部两个对象之间应该具有较高的相似度,而对于不同簇的两个对象之间应该具有较高的相异度。相异度一般是根据描述对象的两个属性值进行计算,最常采用的度量指标是对象间的距离。

    ###2 聚类算法的介绍
    ####2-1 KMeans(K均值)
    KMensKMensKMens是基于原型的、划分的聚类技术,试图划分用户指定 个数kkk 的簇。
    K-means算法的基本思想是:以空间中k个点为中心进行聚类,对最靠近他们的对象归类。通过迭代的方法,逐次更新各聚类中心的值,直至得到最好的聚类结果。

    算法:

    选择k个点作为初始质心
    repeat 
    	将每个点指派给最近的质心,形成k个簇
    	重新计算每个簇的质心
    until 质心不再发生变化
    

    相似度的计算可以使用欧氏距离或者曼哈顿距离。

    考虑临近度是欧氏距离的数据,通常使用误差平方和SSESSESSE(Sum of the Qquares Error)作为度量聚类质量的目标函数。SSESSESSE的定义如下所示:
    SSE=∑i=1K∑x∈Cidist(ci,x)SSE=\sum_{i=1}^K \sum_{x \in C_i} dist(c_i,x) SSE=i=1KxCidist(ci,x)

    ####2-2 EM(期望最大化)
    EMEMEM(Expectation Maximization)是KMeansKMeansKMeans方法的一个扩展,它不是把对象分配给一个确定的簇,而是根据对象与簇之间的隶属关系发生的概率来分配对象。EM算法是解决数据缺失问题的一种出色的算法。
    EMEMEM算法使用两个步骤交替计算:
    第一步是计算期望(E),利用对隐藏变量的现有估计值,计算其最大似然估计值;
    第二步是最大化(M),最大化在 E 步上求得的最大似然值来计算参数的值。
    然后将M 步上找到的参数估计值被用于下一个 E 步计算中,这个过程不断交替进行。
    参考链接 从最大似然到EM算法浅解
    比较复杂的概率理论知识…… 目前我还没有彻底理解。

    ####2-3 DBSCAN(具有噪声的基于密度的聚类方法)
    DBSCANDBSCANDBSCAN(Density-Based Spatial Clustering of Applications with Noise)是一种基于密度的聚类算法,簇的个数由算法自动确定。将低密度区域中的点视为噪声而忽略,因此DBSCANDBSCANDBSCAN不产生完全聚类。
    常用术语的定义:

    1. 半径(Eps):用户指定的距离
    2. 核心点(Core Point):位于基于密度的簇的内部。点的邻域由距离函数和用户指定的距离Eps共同决定。核心点的定义是,如果该点的给定邻域内的点的个数超过给定的阈值MinPts,MinPts由用户指定。
    3. 边界点(Border Point):边界点不是核心点,但是落在核心点的邻域内。
    4. 噪声点(Noise Point):既不是核心点也不是边界点的点称为噪声点。
      DBSCAN算法描述:
    输入: 包含n个对象的数据库,半径e,最少数目MinPts;
    输出:所有生成的簇,达到密度要求。
    (1)Repeat
    (2)从数据库中抽出一个未处理的点;
    (3)IF抽出的点是核心点 THEN 找出所有从该点密度可达的对象,形成一个簇;
    (4)ELSE 抽出的点是边缘点(非核心对象),跳出本次循环,寻找下一个点;
    (5)UNTIL 所有的点都被处理。
    
    DBSCAN对用户定义的参数很敏感,细微的不同都可能导致差别很大的结果,而参数的选择无规律可循,只能靠经验确定。
    
    

    其伪代码描述如下:

    //输入:数据对象集合D,半径Eps,密度阈值MinPts
    //输出:聚类C
    
    DBSCAN(D, Eps, MinPts){
     //未处理的当前集合
     unprocessSet=null;
     for each unvisited point p in D{
    	mark p as visited; //将p标记为已访问
    	
    	N = getNeighbours (p, Eps);
    	unprocessSet(N);//候选集合构建
    	
    	if sizeOf(N) < MinPts then
    		mark p as Noise; //如果满足sizeOf(N) < MinPts,则将p标记为噪声
    	else
    		C= next cluster; //建立新簇C		
    		ExpandCluster (p, N, C, Eps, MinPts,unprocessSet);
     }
    }
    //其中ExpandCluster算法伪码如下:
    ExpandCluster(p, N, C, Eps, MinPts,unprocessSet){
    	add p to cluster C; //首先将核心点加入C
    	for each point p’ in unprocessSet N{
    		mark p' as visited;//标记为已经访问
    		N’ = getNeighbours (p’, Eps); //对N邻域内的所有点在进行半径检查
    		if sizeOf(N’) >= MinPts then
    			N = N+N’; //如果大于MinPts,就扩展N的数目
    			//扩大候选集
    			unprocessSet(N);
    		//如果当前不属于任何的簇,那么就将这个对象添加到当前的簇中
    		if p’ is not member of any cluster
    			add p’ to cluster C; //将p' 加入簇C
    	}
    }
    

    参考:百度百科:DBSCAN

    ###3 Weka聚类案例
    ####3-1 SimpleKMeans算法
    weka.clusterers.SimpleKMeans
    使用weather.numeric.arrf文件中的数据来测试运行结果如下:

    === Run information ===
    
    Scheme:       weka.clusterers.SimpleKMeans -init 0 -max-candidates 100 -periodic-pruning 10000 -min-density 2.0 -t1 -1.25 -t2 -1.0 -N 2 -A "weka.core.EuclideanDistance -R first-last" -I 500 -num-slots 1 -S 10
    Relation:     weather
    Instances:    14
    Attributes:   5
                  outlook
                  temperature
                  humidity
                  windy
                  play
    Test mode:    evaluate on training data
    
    
    === Clustering model (full training set) ===
    
    
    kMeans
    ======
    
    Number of iterations: 3
    Within cluster sum of squared errors: 16.237456311387238
    
    Initial starting points (random):
    
    Cluster 0: rainy,75,80,FALSE,yes
    Cluster 1: overcast,64,65,TRUE,yes
    
    Missing values globally replaced with mean/mode
    
    Final cluster centroids:
                               Cluster#
    Attribute      Full Data          0          1
                      (14.0)      (9.0)      (5.0)
    ==============================================
    outlook            sunny      sunny   overcast
    temperature      73.5714    75.8889       69.4
    humidity         81.6429    84.1111       77.2
    windy              FALSE      FALSE       TRUE
    play                 yes        yes        yes
    
    
    
    
    Time taken to build model (full training data) : 0 seconds
    
    === Model and evaluation on training set ===
    
    Clustered Instances
    
    0       9 ( 64%)
    1       5 ( 36%)
    
    
    

    聚类结果以表格的形式显示,行对应属性名,列对应簇中心。如果是数值属性则显示平均值,如果是标称属性,则显示簇所在列对应的属性标签。

    Attribute Full Data 0 1
    - (14.0) (9.0) (5.0)
    outlook sunny sunny overcast
    temperature 73.5714 75.8889 69.4
    humidity 81.6429 84.1111 77.2
    windy FALSE FALSE TRUE
    play yes yes yes

    ####3-2 EM算法
    与上面的不同的是,这里的表头并没有显示实例的数量,只是在表头的括号内显示其先验概率。表中单元格显示数值属性正态分布的参数或者是标称属性的频率计数。小数,揭示了EM算法的“Soft”的特性,任何实例都可以在若干个簇之间分割。在输出的最后,显示了模型的对数似然值,这是相对于训练数据。

    运行结果如下:

    === Run information ===
    
    Scheme:       weka.clusterers.EM -I 100 -N 2 -X 10 -max -1 -ll-cv 1.0E-6 -ll-iter 1.0E-6 -M 1.0E-6 -K 10 -num-slots 1 -S 100
    Relation:     weather
    Instances:    14
    Attributes:   5
                  outlook
                  temperature
                  humidity
                  windy
                  play
    Test mode:    evaluate on training data
    
    
    === Clustering model (full training set) ===
    
    
    EM
    ==
    
    Number of clusters: 2
    Number of iterations performed: 7
    
    
                  Cluster
    Attribute           0       1
                   (0.35)  (0.65)
    ==============================
    outlook
      sunny         3.8732  3.1268
      overcast      1.7746  4.2254
      rainy         2.1889  4.8111
      [total]       7.8368 12.1632
    temperature
      mean         76.9173 71.8054
      std. dev.     5.8302  5.8566
    
    humidity
      mean         90.1132 77.1719
      std. dev.     3.8066  9.1962
    
    windy
      TRUE            3.14    4.86
      FALSE         3.6967  6.3033
      [total]       6.8368 11.1632
    play
      yes           2.1227  8.8773
      no            4.7141  2.2859
      [total]       6.8368 11.1632
    
    
    Time taken to build model (full training data) : 0 seconds
    
    === Model and evaluation on training set ===
    
    Clustered Instances
    
    0       4 ( 29%)
    1      10 ( 71%)
    //对数似然值
    Log likelihood: -9.13037
    
    

    ####3-3 DBSCAN(具有噪声的基于密度的聚类方法)
    DBSCAN使用欧式距离度量,以确定哪些实例属于同一个簇。不同于划分的方法,DBSCAN可以自动的确定簇的数量,发现任意形状的簇,并引入离群的概念。在用户指定的最小距离 ε\varepsilonε 和 簇的最小值minPts的约束下,完成聚簇。某些不属于任何簇的实例,称为离群值。
    OPTICS算法是DBSCAN算法在层次聚类方面的扩展。OPTICS规定了实例的顺序,这些实例进行二维可视化,揭示簇的层次结构,排序过程根据距离度量,以及在列表中彼此相邻的位置,按照顺序排列彼此最接近的实例。

    OPTICS算法最后的生成结果是有顺序的可以自由选择可达距离的聚簇方法。

    /OPTICS算法额外存储了每个对象的核心距离和可达距离。
    基于OPTICS产生的排序信息来提取类簇。
    算法描述如下:
    算法:OPTICS
    输入:样本集D, 邻域半径E, 给定点在E领域内成为核心对象的最小领域点数MinPts
    输出:具有可达距离信息的样本点输出排序
    方法:
     1. 创建两个队列,有序队列和结果队列。(有序队列用来存储核心对象及其该核心对象的直接可达对象,并按可达距离升序排列;结果队列用来存储样本点的输出次序);
     
     2. 如果所有样本集D中所有点都处理完毕,则算法结束。否则,选择一个未处理(即不在结果队列中)且为核心对象的样本点,找到其所有直接密度可达样本点,如果该样本点不存在于结果队列中,则将其放入有序队列中,并按可达距离排序;
     3. 如果有序队列为空,则跳至步骤2,否则,从有序队列中取出第一个样本点(即可达距离最小的样本点)进行拓展,并将取出的样本点保存至结果队列中,如果它不存在结果队列当中的话.
        3.1 判断该拓展点是否是核心对象,如果不是,回到步骤3,否则找到该拓展点所有的直接密度可达点;
        3.2 判断该直接密度可达样本点是否已经存在结果队列,是则不处理,否则下一步;
        3.3 如果有序队列中已经存在该直接密度可达点,如果此时新的可达距离小于旧的可达距离,则用新可达距离取代旧可达距离,有序队列重新排序;
        3.4 如果有序队列中不存在该直接密度可达样本点,则插入该点,并对有序队列
       重新排序;
    4. 算法结束,输出结果队列中的有序样本点。
    
    

    OPTICS的WEKA执行结果

    === Run information ===
    
    Scheme:       weka.clusterers.OPTICS -E 0.2 -M 5 -A "weka.core.EuclideanDistance -R first-last" -db-output .
    Relation:     iris
    Instances:    150
    Attributes:   5
                  sepallength
                  sepalwidth
                  petallength
                  petalwidth
    Ignored:
                  class
    Test mode:    evaluate on training data
    
    
    === Clustering model (full training set) ===
    
    OPTICS clustering results
    ============================================================================================
    
    Clustered DataObjects: 150
    Number of attributes: 4
    Epsilon: 0.2; minPoints: 5
    Write results to file: no
    Distance-type: 
    Number of generated clusters: 0
    Elapsed time: .02
    
    (  0.) 5.1,3.5,1.4,0.2                           -->  c_dist: 0.05         r_dist: UNDEFINED   
    ( 17.) 5.1,3.5,1.4,0.3                           -->  c_dist: 0.061        r_dist: 0.05
    ( 39.) 5.1,3.4,1.5,0.2                           -->  c_dist: 0.05         r_dist: 0.05
    (  4.) 5,3.6,1.4,0.2                             -->  c_dist: 0.071        r_dist: 0.05
    ( 27.) 5.2,3.5,1.5,0.2                           -->  c_dist: 0.053        r_dist: 0.05
    ( 28.) 5.2,3.4,1.4,0.2                           -->  c_dist: 0.058        r_dist: 0.05
    (  7.) 5,3.4,1.5,0.2                             -->  c_dist: 0.058        r_dist: 0.05
    ( 40.) 5,3.5,1.3,0.3                             -->  c_dist: 0.068        r_dist: 0.053
    ( 49.) 5,3.3,1.4,0.2                             -->  c_dist: 0.069        r_dist: 0.053
    ( 11.) 4.8,3.4,1.6,0.2                           -->  c_dist: 0.077        r_dist: 0.058
    ( 35.) 5,3.2,1.2,0.2                             -->  c_dist: 0.083        r_dist: 0.069
    ( 26.) 5,3.4,1.6,0.4                             -->  c_dist: 0.085        r_dist: 0.073
    ( 20.) 5.4,3.4,1.7,0.2                           -->  c_dist: 0.09         r_dist: 0.075
    ( 24.) 4.8,3.4,1.9,0.2                           -->  c_dist: 0.107        r_dist: 0.077
    (  6.) 4.6,3.4,1.4,0.3                           -->  c_dist: 0.103        r_dist: 0.077
    ( 34.) 4.9,3.1,1.5,0.1                           -->  c_dist: 0.053        r_dist: 0.083
    ( 12.) 4.8,3,1.4,0.1                             -->  c_dist: 0.053        r_dist: 0.053
    ( 37.) 4.9,3.1,1.5,0.1                           -->  c_dist: 0.053        r_dist: 0.053
    (  9.) 4.9,3.1,1.5,0.1                           -->  c_dist: 0.053        r_dist: 0.053
    ( 30.) 4.8,3.1,1.6,0.2                           -->  c_dist: 0.053        r_dist: 0.053
    ( 29.) 4.7,3.2,1.6,0.2                           -->  c_dist: 0.053        r_dist: 0.053
    (  2.) 4.7,3.2,1.3,0.2                           -->  c_dist: 0.071        r_dist: 0.053
    (  3.) 4.6,3.1,1.5,0.2                           -->  c_dist: 0.06         r_dist: 0.053
    ( 47.) 4.6,3.2,1.4,0.2                           -->  c_dist: 0.058        r_dist: 0.053
    (  1.) 4.9,3,1.4,0.2                             -->  c_dist: 0.06         r_dist: 0.053
    ( 42.) 4.4,3.2,1.3,0.2                           -->  c_dist: 0.083        r_dist: 0.058
    ( 25.) 5,3,1.6,0.2                               -->  c_dist: 0.067        r_dist: 0.06
    ( 45.) 4.8,3,1.4,0.3                             -->  c_dist: 0.083        r_dist: 0.06
    ( 38.) 4.4,3,1.3,0.2                             -->  c_dist: 0.083        r_dist: 0.077
    ( 13.) 4.3,3,1.1,0.1                             -->  c_dist: 0.123        r_dist: 0.083
    (  8.) 4.4,2.9,1.4,0.2                           -->  c_dist: 0.126        r_dist: 0.083
    ( 23.) 5.1,3.3,1.7,0.5                           -->  c_dist: 0.128        r_dist: 0.085
    ( 48.) 5.3,3.7,1.5,0.2                           -->  c_dist: 0.088        r_dist: 0.088
    ( 10.) 5.4,3.7,1.5,0.2                           -->  c_dist: 0.1          r_dist: 0.088
    ( 19.) 5.1,3.8,1.5,0.3                           -->  c_dist: 0.081        r_dist: 0.088
    ( 21.) 5.1,3.7,1.5,0.4                           -->  c_dist: 0.095        r_dist: 0.081
    ( 44.) 5.1,3.8,1.9,0.4                           -->  c_dist: 0.099        r_dist: 0.081
    ( 46.) 5.1,3.8,1.6,0.2                           -->  c_dist: 0.095        r_dist: 0.081
    ( 36.) 5.5,3.5,1.3,0.2                           -->  c_dist: 0.095        r_dist: 0.09
    ( 31.) 5.4,3.4,1.5,0.4                           -->  c_dist: 0.103        r_dist: 0.09
    ( 43.) 5,3.5,1.6,0.6                             -->  c_dist: 0.132        r_dist: 0.093
    (  5.) 5.4,3.9,1.7,0.4                           -->  c_dist: 0.108        r_dist: 0.099
    ( 18.) 5.7,3.8,1.7,0.3                           -->  c_dist: 0.129        r_dist: 0.108
    ( 16.) 5.4,3.9,1.3,0.4                           -->  c_dist: 0.123        r_dist: 0.108
    ( 22.) 4.6,3.6,1,0.2                             -->  c_dist: 0.143        r_dist: 0.115
    ( 14.) 5.8,4,1.2,0.2                             -->  c_dist: 0.168        r_dist: 0.129
    ( 32.) 5.2,4.1,1.5,0.1                           -->  c_dist: 0.164        r_dist: 0.136
    ( 33.) 5.5,4.2,1.4,0.2                           -->  c_dist: 0.154        r_dist: 0.154
    ( 15.) 5.7,4.4,1.5,0.4                           -->  c_dist: UNDEFINED    r_dist: 0.154
    (100.) 6.3,3.3,6,2.5                             -->  c_dist: 0.153        r_dist: UNDEFINED   
    (115.) 6.4,3.2,5.3,2.3                           -->  c_dist: 0.119        r_dist: 0.153
    (136.) 6.3,3.4,5.6,2.4                           -->  c_dist: 0.127        r_dist: 0.119
    (140.) 6.7,3.1,5.6,2.4                           -->  c_dist: 0.095        r_dist: 0.119
    (120.) 6.9,3.2,5.7,2.3                           -->  c_dist: 0.108        r_dist: 0.095
    (143.) 6.8,3.2,5.9,2.3                           -->  c_dist: 0.103        r_dist: 0.095
    (145.) 6.7,3,5.2,2.3                             -->  c_dist: 0.114        r_dist: 0.095
    (144.) 6.7,3.3,5.7,2.5                           -->  c_dist: 0.122        r_dist: 0.095
    (124.) 6.7,3.3,5.7,2.1                           -->  c_dist: 0.13         r_dist: 0.103
    (139.) 6.9,3.1,5.4,2.1                           -->  c_dist: 0.11         r_dist: 0.108
    (102.) 7.1,3,5.9,2.1                             -->  c_dist: 0.144        r_dist: 0.11
    (112.) 6.8,3,5.5,2.1                             -->  c_dist: 0.106        r_dist: 0.11
    (104.) 6.5,3,5.8,2.2                             -->  c_dist: 0.114        r_dist: 0.106
    (147.) 6.5,3,5.2,2                               -->  c_dist: 0.11         r_dist: 0.106
    (141.) 6.9,3.1,5.1,2.3                           -->  c_dist: 0.11         r_dist: 0.11
    (110.) 6.5,3.2,5.1,2                             -->  c_dist: 0.132        r_dist: 0.11
    (116.) 6.5,3,5.5,1.8                             -->  c_dist: 0.11         r_dist: 0.11
    (103.) 6.3,2.9,5.6,1.8                           -->  c_dist: 0.128        r_dist: 0.11
    ( 77.) 6.7,3,5,1.7                               -->  c_dist: 0.133        r_dist: 0.11
    (137.) 6.4,3.1,5.5,1.8                           -->  c_dist: 0.119        r_dist: 0.11
    (128.) 6.4,2.8,5.6,2.1                           -->  c_dist: 0.119        r_dist: 0.114
    (132.) 6.4,2.8,5.6,2.2                           -->  c_dist: 0.141        r_dist: 0.114
    (111.) 6.4,2.7,5.3,1.9                           -->  c_dist: 0.11         r_dist: 0.119
    (123.) 6.3,2.7,4.9,1.8                           -->  c_dist: 0.123        r_dist: 0.11
    (146.) 6.3,2.5,5,1.9                             -->  c_dist: 0.163        r_dist: 0.11
    (126.) 6.2,2.8,4.8,1.8                           -->  c_dist: 0.117        r_dist: 0.117
    (127.) 6.1,3,4.9,1.8                             -->  c_dist: 0.102        r_dist: 0.117
    (138.) 6,3,4.8,1.8                               -->  c_dist: 0.1          r_dist: 0.102
    (149.) 5.9,3,5.1,1.8                             -->  c_dist: 0.128        r_dist: 0.1
    ( 70.) 5.9,3.2,4.8,1.8                           -->  c_dist: 0.131        r_dist: 0.1
    (148.) 6.2,3.4,5.4,2.3                           -->  c_dist: 0.175        r_dist: 0.119
    ( 83.) 6,2.7,5.1,1.6                             -->  c_dist: 0.129        r_dist: 0.12
    (133.) 6.3,2.8,5.1,1.5                           -->  c_dist: 0.13         r_dist: 0.129
    (134.) 6.1,2.6,5.6,1.4                           -->  c_dist: 0.193        r_dist: 0.129
    ( 54.) 6.5,2.8,4.6,1.5                           -->  c_dist: 0.103        r_dist: 0.13
    ( 58.) 6.6,2.9,4.6,1.3                           -->  c_dist: 0.097        r_dist: 0.103
    ( 74.) 6.4,2.9,4.3,1.3                           -->  c_dist: 0.106        r_dist: 0.097
    ( 75.) 6.6,3,4.4,1.4                             -->  c_dist: 0.083        r_dist: 0.097
    ( 65.) 6.7,3.1,4.4,1.4                           -->  c_dist: 0.103        r_dist: 0.083
    ( 86.) 6.7,3.1,4.7,1.5                           -->  c_dist: 0.099        r_dist: 0.083
    ( 76.) 6.8,2.8,4.8,1.4                           -->  c_dist: 0.136        r_dist: 0.097
    ( 52.) 6.9,3.1,4.9,1.5                           -->  c_dist: 0.11         r_dist: 0.099
    ( 51.) 6.4,3.2,4.5,1.5                           -->  c_dist: 0.11         r_dist: 0.099
    ( 50.) 7,3.2,4.7,1.4                             -->  c_dist: 0.148        r_dist: 0.102
    ( 97.) 6.2,2.9,4.3,1.3                           -->  c_dist: 0.084        r_dist: 0.106
    ( 63.) 6.1,2.9,4.7,1.4                           -->  c_dist: 0.093        r_dist: 0.084
    ( 71.) 6.1,2.8,4,1.3                             -->  c_dist: 0.112        r_dist: 0.084
    ( 91.) 6.1,3,4.6,1.4                             -->  c_dist: 0.097        r_dist: 0.084
    ( 78.) 6,2.9,4.5,1.5                             -->  c_dist: 0.106        r_dist: 0.093
    ( 73.) 6.1,2.8,4.7,1.2                           -->  c_dist: 0.123        r_dist: 0.093
    ( 61.) 5.9,3,4.2,1.5                             -->  c_dist: 0.108        r_dist: 0.097
    ( 66.) 5.6,3,4.5,1.5                             -->  c_dist: 0.11         r_dist: 0.108
    ( 96.) 5.7,2.9,4.2,1.3                           -->  c_dist: 0.066        r_dist: 0.108
    ( 55.) 5.7,2.8,4.5,1.3                           -->  c_dist: 0.106        r_dist: 0.066
    ( 88.) 5.6,3,4.1,1.3                             -->  c_dist: 0.094        r_dist: 0.066
    ( 95.) 5.7,3,4.2,1.2                             -->  c_dist: 0.106        r_dist: 0.066
    ( 99.) 5.7,2.8,4.1,1.3                           -->  c_dist: 0.073        r_dist: 0.066
    ( 82.) 5.8,2.7,3.9,1.2                           -->  c_dist: 0.09         r_dist: 0.073
    ( 94.) 5.6,2.7,4.2,1.3                           -->  c_dist: 0.086        r_dist: 0.073
    ( 90.) 5.5,2.6,4.4,1.2                           -->  c_dist: 0.107        r_dist: 0.086
    ( 92.) 5.8,2.6,4,1.2                             -->  c_dist: 0.095        r_dist: 0.088
    ( 67.) 5.8,2.7,4.1,1                             -->  c_dist: 0.114        r_dist: 0.09
    ( 89.) 5.5,2.5,4,1.3                             -->  c_dist: 0.094        r_dist: 0.094
    ( 53.) 5.5,2.3,4,1.3                             -->  c_dist: 0.141        r_dist: 0.094
    ( 69.) 5.6,2.5,3.9,1.1                           -->  c_dist: 0.089        r_dist: 0.094
    ( 80.) 5.5,2.4,3.8,1.1                           -->  c_dist: 0.099        r_dist: 0.089
    ( 81.) 5.5,2.4,3.7,1                             -->  c_dist: 0.141        r_dist: 0.089
    ( 79.) 5.7,2.6,3.5,1                             -->  c_dist: 0.119        r_dist: 0.094
    ( 64.) 5.6,2.9,3.6,1.3                           -->  c_dist: 0.12         r_dist: 0.094
    ( 84.) 5.4,3,4.5,1.5                             -->  c_dist: 0.144        r_dist: 0.11
    ( 56.) 6.3,3.3,4.7,1.6                           -->  c_dist: 0.146        r_dist: 0.11
    ( 59.) 5.2,2.7,3.9,1.4                           -->  c_dist: 0.154        r_dist: 0.126
    ( 72.) 6.3,2.5,4.9,1.5                           -->  c_dist: 0.145        r_dist: 0.13
    ( 85.) 6,3.4,4.5,1.6                             -->  c_dist: 0.181        r_dist: 0.131
    (142.) 5.8,2.7,5.1,1.9                           -->  c_dist: 0.135        r_dist: 0.135
    (101.) 5.8,2.7,5.1,1.9                           -->  c_dist: 0.135        r_dist: 0.135
    (113.) 5.7,2.5,5,2                               -->  c_dist: 0.172        r_dist: 0.135
    (121.) 5.6,2.8,4.9,2                             -->  c_dist: 0.148        r_dist: 0.135
    ( 68.) 6.2,2.2,4.5,1.5                           -->  c_dist: UNDEFINED    r_dist: 0.145
    ( 87.) 6.3,2.3,4.4,1.3                           -->  c_dist: 0.17         r_dist: 0.145
    (130.) 7.4,2.8,6.1,1.9                           -->  c_dist: 0.155        r_dist: 0.148
    (108.) 6.7,2.5,5.8,1.8                           -->  c_dist: UNDEFINED    r_dist: 0.151
    (119.) 6,2.2,5,1.5                               -->  c_dist: UNDEFINED    r_dist: 0.151
    (125.) 7.2,3.2,6,1.8                             -->  c_dist: 0.181        r_dist: 0.154
    (105.) 7.6,3,6.6,2.1                             -->  c_dist: 0.164        r_dist: 0.155
    (107.) 7.3,2.9,6.3,1.8                           -->  c_dist: 0.158        r_dist: 0.155
    (122.) 7.7,2.8,6.7,2                             -->  c_dist: 0.16         r_dist: 0.155
    (129.) 7.2,3,5.8,1.6                             -->  c_dist: 0.184        r_dist: 0.158
    ( 93.) 5,2.3,3.3,1                               -->  c_dist: 0.16         r_dist: 0.16
    ( 57.) 4.9,2.4,3.3,1                             -->  c_dist: 0.18         r_dist: 0.16
    ( 60.) 5,2,3.5,1                                 -->  c_dist: UNDEFINED    r_dist: 0.16
    ( 98.) 5.1,2.5,3,1.1                             -->  c_dist: 0.18         r_dist: 0.16
    (118.) 7.7,2.6,6.9,2.3                           -->  c_dist: UNDEFINED    r_dist: 0.16
    (135.) 7.7,3,6.1,2.3                             -->  c_dist: UNDEFINED    r_dist: 0.164
    ( 62.) 6,2.2,4,1                                 -->  c_dist: 0.173        r_dist: 0.17
    (114.) 5.8,2.8,5.1,2.4                           -->  c_dist: UNDEFINED    r_dist: 0.179
    (109.) 7.2,3.6,6.1,2.5                           -->  c_dist: UNDEFINED    r_dist: 0.199
    (106.) 4.9,2.5,4.5,1.7                           -->  c_dist: UNDEFINED    r_dist: 0.2
    (117.) 7.7,3.8,6.7,2.2                           -->  c_dist: UNDEFINED    r_dist: UNDEFINED   
    (131.) 7.9,3.8,6.4,2                             -->  c_dist: UNDEFINED    r_dist: UNDEFINED   
    ( 41.) 4.5,2.3,1.3,0.3                           -->  c_dist: UNDEFINED    r_dist: UNDEFINED   
    
    
    
    Time taken to build model (full training data) : 0.17 seconds
    
    === Model and evaluation on training set ===
    
    Clustered Instances
    
    
    Unclustered instances : 150
    
    

    可以比DBSCAN传递出更多的层次化聚类的信息。

    展开全文
  • 初试weka数据挖掘

    2021-03-02 03:50:43
    Weka的全名是怀卡托智能分析环境(WaikatoEnvironmentforKnowledgeAnalysis),是一款免费的,非商业化的,基于Java环境下开源的机器学习以及数据挖掘软件,它和它的源代码可在其官方网站下载。有趣的是,该软件的...
  • Weka数据挖掘——关联

    千次阅读 2016-01-23 11:06:32
    Weka数据挖掘——关联

    挫折感很大、觉得很难熬的时候,可以闭上眼睛,想像自己已经是十年之后的自己,置身一段距离之外,转头去看正在遭遇的那些事。 练习这样做,心情可能会平静些,知道眼前这一切,都会过去。——蔡康永
    别太嚣张,对自己没好处。——李秘书
    你今天泼给我的冷水,我定要烧开了给你泼回去。——宋晓峰
    小人别得地,得地就起屁。 ——刘能

    ###目录

    文章目录


    ###1 关联规则概述
    关联规则挖掘是数据挖掘的热点之一。关联规则反映一个对象与其他对象之间的相互依赖性,如果多个对象之间存在一定的关系,那么一个对象就能够通过其他对象来进行预测。
    关联规则可以采用与分类规则相同的方式产生。由于得到的关联规则的数量庞大,通常需要通过使用覆盖率和准确率进行修剪,覆盖率也称为支持度,指的是应用规则之后预测正确的实例数量。准确率也称为置信度,表示为支持度数值应用规则后的数量比例。
    相关术语:
    支持度: P(A∩B)P(A\cap B)P(AB),即A和B这两个项集在事务集D中同时出现的概率。
    置信度: P(B∣A)P(B\lvert A)P(BA),即在出现项集A的事务集D中,项集B也同时出现的概率。
    频繁项集:指经常出现在一块的物品的集合。 关联规则暗示两种物品之间存在很强的关系。(这里我们事先定义阀值,超过该阀值,证明两者之间存在很强的关系).

    ###2 关联算法的介绍
    ####2-1 Apriori算法
    算法介绍
    Apriori算法利用了两个重要的性质,用于压缩搜索的空间。
    【1】若X为频繁项目集,则X的所有子集都是频繁项目集。
    【2】若X为非频繁项目集,则X的所有超集均为非频繁项目集。
    Apriori算法的处理流程为:宽度优先搜索整个项集空间,从k=0开始,迭代产生长度为k+1的候选项集的集合Ck+1。候选项集是其所有子集都是频繁项集的项集(初始化C1由I0中所有的项构成),在第k层产生所有长度为k+1的项集。

    由两步完成:

    第一步,Fk自连接。将Fk中具有相同(k-1)-前缀的项集连接成长度为k的候选项集。
    第二步是剪枝,如果项集的所有长度为k的子集都在Fk中,该项集才能作为候选项集被加入Ck+1中。为了计算所有长度为k的候选项集的支持度,在数据库水平表示方式下,需要扫描数据库一遍。在每次扫描中,对数据库中的每条交易记录,为其中所包含的所有候选k-项集的支持度计数加1。所有频繁的k-项集被加入Fk中。

    此过程直至Ck+1等于空集时结束。

    
    算法  Apriori
    Input:          Transaction DataBase D,Minimum support threshold minsup。
    Output:      Frequent pattern L
    (1) L1=search_frequent_1-itemsets( D );///生成频繁一项集
    (2) for(k=2;Lk-1≠φ;k++) do
    (3) begin
    (4)    Ck=apriori-gen(Lk-1);//生成候选k项集
    (5)    for all transactions t D do /// 扫描数据库中的每一个事务t
    (6)    begin
    (7)      Ct=subset(Ck,t);//识别属于t的所有候选项集
    (8)      for all candidates c Ct do
    (9)        c.count++;
    (10)    end
    (11)    Lk ={c Ck|c.count≥minsup}  //根据支持度来提取频繁k项集
    (12) end
    (13) Answer L=∪kLk;
    Procedure Search_frequent_1-itemsets( D )
    (1) begin
    (2)  for all transactions t D do
    (3)  begin
    (4)    for each item ik t do
    (5)      ik.count++;
    (6)  end
    (7)  L1 ={ i I | i.count≥minsup}
    (8)  return L1;
    (9) end
    Procedure apriori_gen(Lk)
    (1) begin
    (2)   for each itemset l1 Lk do
    (3)     for each itemset l2 Lk do
    (4)     begin
    (5)       if ( l1[1]=l2[1]) ( l1[2]=l2[2]) … ( l1[k-1]=l2[k-1]) ( l1[k]<l2[k]) then
    (6)       begin
    (7)          c= l1 l2;//连接步
    (8)          if Is_include_infrenquent_subset(c,Lk) then
    (9)             delete c; //剪枝步
    (10)         else add c to Ck+1 ;
    (11)       end
    (12)      end
    (13)    return Ck+1 ;
    (14) end
    Procedure Is_include_infrenquent_subset(c,Lk)
    (1)begin
    (2)  for each k-subset s of c
    (3)     if s Lk then
    (4)       return TURE;
    (5)  return FALSE ;
    (6)end
    
    

    在主程序中,第一步首先扫描整个交易数据库D,统计每个项目(item)的支持数,计算其支持度,将支持度大于等于最小支持度minsup的项目构成的集合放入到L1 中;从第2步到第11步,用k-1频繁项集构成的Lk-1生成候选集的集合Ck,以便从中生成Lk,其中apriori_gen函数(第4步)用来从Lk-1中生成Ck,然后对数据库进行扫描(第5步),对于数据库中的每一个交易,subset函数用来发现此交易包含的所有候选集(第7步),并为这些候选集的计数器加1(第8-9步)。最后满足minsup的候选集被放入到Lk中。
    apriori_gen 过程完成两种操作:并(join)和剪枝(prune)。在并运算步骤中,Lk-1 与Lk-1 进行并运算生成潜在的候选集(2-7步),条件l1[k-1]<l2[k-1]保证不会有重复的候选集生成(第5步)。在剪枝步骤中(8-10步),利用性质2.1,删除那些存在子集不是频繁项目集的候选集,测试子集是否为频繁项目集由过程Is_include_infrenquent_subset完成。

    ####2-2 FP-Growth算法
    FP-Growth(频繁模式增长)算法是韩家炜老师在2000年提出的关联分析算法,它采取如下分治策略:将提供频繁项集的数据库压缩到一棵频繁模式树(FP-Tree),但仍保留项集关联信息;该算法和Apriori算法最大的不同有两点:第一,不产生候选集,第二,只需要两次遍历数据库,大大提高了效率。

    算法伪代码

    算法:FP-增长。使用FP-树,通过模式段增长,挖掘频繁模式。
    
    输入:事务数据库D;最小支持度阈值min_sup。
    
    输出:频繁模式的完全集。
    
    1. 按以下步骤构造FP-树:
    
    (a) 扫描事务数据库D 一次。收集频繁项的集合F 和它们的支持度。对F 按支持度降序排序,结果为频繁项表L。
    
    (b) 创建FP-树的根结点,以“null”标记它。对于D 中每个事务Trans,执行:选择 Trans 中的频繁项,并按L 中的次序排序。设排序后的频繁项表为[p | P],其中,p 是第一个元素,而P 是剩余元素的表。调用insert_tree([p | P], T)。该过程执行情况如下。如果T 有子女N 使得N.item-name = p.item-name,则N 的计数增加1;否则创建一个新结点N,将其计数设置为1,链接到它的父结点T,并且通过结点链结构将其链接到具有相同item-name 的结点。如果P 非空,递归地调用insert_tree(P, N)。
    
    procedure FP_growth(Tree, a)
    if Tree 含单个路径P then{
             for 路径P中结点的每个组合(记作b)
             产生模式b U a,其支持度support = b 中结点的最小支持度;
    } else {
             for each a i 在Tree的头部(按照支持度由低到高顺序进行扫描){
                      产生一个模式b = ai U a,其支持度support = ai .support;
                      构造b的条件模式基,然后构造b的条件FP-树Treeb;
                      if Treeb 不为空 then
                                调用 FP_growth (Treeb, b);
               }
    }
    FP-growth是整个算法的核心,再多啰嗦几句。
    FP-growth函数的输入:tree是指原始的FPTree或者是某个模式的条件FPTree,a是指模式的后缀(在第一次调用时a=NULL,在之后的递归调用中a是模式后缀)
    FP-growth函数的输出:在递归调用过程中输出所有的模式及其支持度(比如{I1,I2,I3}的支持度为2)。每一次调用FP_growth输出结果的模式中一定包含FP_growth函数输入的模式后缀。
    

    参考这里
    ###3 关联算法Weka实现
    ####3-1 Apriori关联规则挖掘
    对天气的标称数据进行Apriori关联规则挖掘。

    === Run information ===
    
    Scheme:       weka.associations.Apriori -N 10 -T 0 -C 0.9 -D 0.05 -U 1.0 -M 0.1 -S -1.0 -c -1
    Relation:     weather.symbolic
    Instances:    14
    Attributes:   5
                  outlook
                  temperature
                  humidity
                  windy
                  play
    === Associator model (full training set) ===
    
    
    Apriori
    =======
    
    Minimum support: 0.15 (2 instances)
    Minimum metric <confidence>: 0.9
    Number of cycles performed: 17
    
    Generated sets of large itemsets:
    Size of set of large itemsets L(1): 12
    Size of set of large itemsets L(2): 47
    Size of set of large itemsets L(3): 39
    Size of set of large itemsets L(4): 6
    
    Best rules found:
    
     1. outlook=overcast 4 ==> play=yes 4    <conf:(1)> lift:(1.56) lev:(0.1) [1] conv:(1.43)
     2. temperature=cool 4 ==> humidity=normal 4    <conf:(1)> lift:(2) lev:(0.14) [2] conv:(2)
     3. humidity=normal windy=FALSE 4 ==> play=yes 4    <conf:(1)> lift:(1.56) lev:(0.1) [1] conv:(1.43)
     4. outlook=sunny play=no 3 ==> humidity=high 3    <conf:(1)> lift:(2) lev:(0.11) [1] conv:(1.5)
     5. outlook=sunny humidity=high 3 ==> play=no 3    <conf:(1)> lift:(2.8) lev:(0.14) [1] conv:(1.93)
     6. outlook=rainy play=yes 3 ==> windy=FALSE 3    <conf:(1)> lift:(1.75) lev:(0.09) [1] conv:(1.29)
     7. outlook=rainy windy=FALSE 3 ==> play=yes 3    <conf:(1)> lift:(1.56) lev:(0.08) [1] conv:(1.07)
     8. temperature=cool play=yes 3 ==> humidity=normal 3    <conf:(1)> lift:(2) lev:(0.11) [1] conv:(1.5)
     9. outlook=sunny temperature=hot 2 ==> humidity=high 2    <conf:(1)> lift:(2) lev:(0.07) [1] conv:(1)
    10. temperature=hot play=no 2 ==> outlook=sunny 2    <conf:(1)> lift:(2.8) lev:(0.09) [1] conv:(1.29)
    
    
    
    展开全文
  • weka数据挖掘软件

    2009-03-18 19:54:02
    weka数据挖掘软件,不带jre,方向下载
  • weka 数据挖掘软件

    2009-03-16 19:23:47
    weka 数据挖掘软件,开源软件,安装完成即可使用,不需要注册码,永远支持开源
  • weka数据挖掘技术手册

    2010-10-21 23:07:26
    weka数据挖掘技术手册,内容详细,是编程人员难得的一本书!
  • weka数据挖掘之预处理

    千次阅读 2016-11-24 20:58:58
    weka数据挖掘之预处理数据挖掘是在大量的、潜在有用的数据中挖掘出有用模式的过程,因此,源数据的质量直接影响到挖掘的效果,高质量的数据是有效挖掘的前提。但是,肯定是,不是所有的数据都是那么理想。由于无法在...

    weka数据挖掘之预处理

    数据挖掘是在大量的、潜在有用的数据中挖掘出有用模式的过程,因此,源数据的质量直接影响到挖掘的效果,高质量的数据是有效挖掘的前提。但是,肯定是,不是所有的数据都是那么理想。

    由于无法在数据的源头进行控制质量,所以只能通过两个方面设法避免数据质量的问题:
    (1)数据质量问题的检测和纠正。
    (2)使用能容忍低质量数据的算法。
    第一种方式发生在数据挖掘前,这个过程成为预处理。
    第二种方式需要提高算法的健壮性。
    Weka专门提供若干过滤器进行预处理,还在explorer界面中提供选择属性标签页专门处理属性的自动选择问题。
    数据预处理技术设计的策略和技术非常广泛,主要包括以下技术。

    1. 聚集
      聚集就是将两个或多个对象合并为单个对象。一般来说,定量数据通过求和活求平均值的方式进行聚集,定性数据通常通过汇总进行聚集。

           *定量数据:就是数值,比如年龄,身高,体重。可以进行平均值等计算的。定量数据说明的是现象的数量特征,是必须用数值来表现的。分为离散数据(Discrete data)和连续数据 (Continuous numerical data)。           
           定性数据(Qualitative data):定性是性质,只是计数资料。性 别,男或女,但在录入时可能会给定性变量的值进行赋值,如男为0, 女为1,这时的数代表的就是定性资料。不能进行计算。包括分类数据 和顺序数据,是一组表示事物性质、规定事物类别的文字表述型数据, 不 能将其量化,只能将其定性。定性数据说明的是事物的品质特征,是 不能用数值表示的,通常表现为类别。*
      

      聚集通过数据规约来减少数据量,所导致的较小数据集只需要较小内存和处理时间的开销。另外,聚集使用高层数据视图,起到了范围和度量转换的作用。
      缺点:有可能导致有趣细节的丢失。

    2. 抽样

      如果处理全部数据的开销太大,数据预处理可以使用抽样,只选择数据对象的子集进行分析。使用抽样可以压缩数据量。
      抽样是一个统计过程,好的抽样方案就是确保以很高的概率得到有代表性的样本,即:样本近似地具有原数据相同的性质。
      抽样的方式有多种,如简单随机抽样,分层抽样等。简单随机抽样又分为有放回抽样和无放回抽样两种形式,数据样式不同时,采取不同的抽样方法。

    3. 维度规约

      维度是指数据集中属性的数目。维度规约是指创建新属性,通过数据编码或数据变换,将一些旧属性合并在一起以降低数据集的维度。
      维度规约可以删除不想关的属性并降低噪声,维度降低会使很多数据挖掘的算法变得更好,还能消除维灾难带来的负面影响。
      维灾难
      分类问题中的维灾难
      聚类问题中的维灾难

    4. 属性选择
      除了维度规约外,降低维度的另一种方法是仅只使用属性的一个子集。表面看来似乎这中方法可能失去信息,但很多情况下,数据集存在冗余活不现关的属性。
      属性选择是指从数据集中选择最具有代表性的属性子集,删除冗余活不想管的属性,从而提高数据处理的效率,使模型更容易理解。
      属性选择方法:嵌入、过滤和包装。

    5. 属性创建

    6. 离散化和二元化
    7. 变量变换
    展开全文
  • DBLP数据集用weka数据挖掘 xml转csv格式文件写在前面xml转csv格式文件数据预处理weka数据挖掘 写在前面 之前做了中国科学院大学的一门研讨课《数据挖掘技术与应用》,老师讲的非常好,这门课的几个大项目真的让我学...
  • NB java weka 数据挖掘 机器学习 模式识别 朴素贝叶斯
  • Weka数据挖掘——选择属性

    万次阅读 2016-01-23 21:19:08
    Weka数据挖掘——选择属性。 选择属性属性选择是通过搜索数据中所有可能的属性组合,以找到预测效果最好的属性子集。手工选择属性既繁琐又容易出错,为了帮助用户事项选择属性自动化。Weka中提供了选择属性面板。要...
  • weka数据挖掘相关资料,关联规则算法,还有中文机器学习教程,我还有一些关于weka的资料,似乎太大了,传不上,有需要的朋友可以发邮件给我,why213229@163.com
  • 其次,针对学术界典型的开放数据挖掘工具 WEKA,进行数据挖掘测试,主要包括预处理、分类、聚类、属性选择、关联规则及可视化等,并对挖掘结果进行统计分析,指出 WEKA 系统存在的缺陷及发展前景。为了弥补 WEKA ...
  • Weka 数据挖掘工具

    2013-06-01 10:26:14
    这是一款开源免费数据挖掘工具,比较流行。 64位,安装前,请确认本机上装有JVM1.7.
  • Weka数据挖掘视频培训课程概况:该教程利用Weka进行数据分析和挖掘的方法,内容包括Weka数据挖掘软件的下载安装、基础知识、分类处理、高级应用技巧。利用Weka进行数据预处理、分类预测、回归分析、聚类分析、关联...
  • Weka数据挖掘_K-means与Apriror结合获得的的强关联算法 The author: Tim DONG From:Staffordshire University Email:d033889g@student.staffs.ac.uk 背景 本节使用Weka环境中的各种算法。预测汽车属性对人们购买...
  • weka资料\1 有没有weka相关的qq群.doc ........\assignment1.pdf ........\BayesianNetClassifiers.pdf... ........\数据挖掘技术简介.doc ........\WEKA ExplorerGuide-3.5 ........\weka使用说明中文版 weka资料
  • weka数据挖掘软件下载

    2009-03-18 18:31:45
    weka数据挖掘软件,带jre,放心下载
  • weka数据挖掘分析

    千次阅读 2017-05-16 08:07:36
    基于Weka 数据聚类分析银行用户的购买力 通过分析对银行储户信息的分析,进行cluster分类,最终找到合适的消费 人群。 实验基本原理及目的 聚类分析中的“类”(cluster)和前面分类的“类”(class)是不同的,对...
  • 使用Weka软件开展医疗领域的应用研究,为相关研究人员提供参考

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,212
精华内容 484
关键字:

weka数据挖掘