精华内容
下载资源
问答
  • [转]机器学习工具:scikit-learn/Weka

    千次阅读 2015-03-12 18:28:06
    当然可以利用matplotlib绘制学习曲线,需要导入相应模块如下: from sklearn.learning_curveimport learning_curve,validation_curve 核心代码如下,具体参见Scikit-Learn的官方文档: rain_sizes, train_scores,...


    开源机器学习工具scikit-learn入门


    Scikit-Learn是基于python的机器学习模块,基于BSD开源许可证。这个项目最早由DavidCournapeau 在2007 年发起的,目前也是由社区自愿者进行维护。

    Scikit-Learn的官方网站是http://scikit-learn.org/stable/,在上面可以找到相关的Scikit-Learn的资源,模块下载,文档,例程等等。

    Scikit-Learn的安装需要numpy,scipy,matplotlib等模块,windows用户可以到

    http://www.lfd.uci.edu/~gohlke/pythonlibs直接下载编译好的安装包以及依赖,也可以到这个网站下载http://sourceforge.jp/projects/sfnet_scikit-learn/

     

    scikit-learn的基本功能主要被分为六个部分,分类,回归,聚类,数据降维,模型选择,数据预处理,具体可以参考官方网站上的文档。

    对于具体的机器学习问题,通常可以分为三个步骤,数据准备与预处理,模型选择与训练,模型验证与参数调优,这里以逻辑回归模型为例说明。

    scikit-learn支持多种格式的数据,包括经典的iris数据,LibSVM格式数据等等。为了方便起见,推荐使用LibSVM格式的数据,详细见LibSVM的官网。

    from sklearn.datasets importload_svmlight_file,导入这个模块就可以加载LibSVM模块的数据,

    t_X,t_y=load_svmlight_file("filename")

    机器学习模型也要导入相应的模块,逻辑回归模型在下面的模块中。

    from sklearn.linear_modelimport LogisticRegression

    regressionFunc =LogisticRegression(C=10, penalty='l2', tol=0.0001)

    train_sco=regressionFunc.fit(train_X,train_y).score(train_X,train_y)

    test_sco=regressionFunc.score(test_X,test_y)

    就可以完成模型的训练和测试了。

    为了选择更好地模型可以进行交叉实验,或者使用贪心算法进行参数调优。

    导入如下模块就可以,

    CV:

    from sklearn importcross_validation

    X_train_m, X_test_m,y_train_m, y_test_m = cross_validation.train_test_split(t_X,t_y, test_size=0.5,random_state=seed_i)

    regressionFunc_2.fit(X_train_m,y_train_m)

    sco=regressionFunc_2.score(X_test_m,y_test_m, sample_weight=None)

     

    GridSearch:

    from sklearn.grid_searchimport GridSearchCV

    tuned_parameters =[{'penalty': ['l1'], 'tol': [1e-3, 1e-4],

                         'C': [1, 10, 100, 1000]},

                        {'penalty': ['l2'], 'tol':[1e-3, 1e-4],

                         'C': [1, 10, 100, 1000]}]

    clf =GridSearchCV(LogisticRegression(), tuned_parameters, cv=5, scoring=['precision','recall'])

    print(clf.best_estimator_)

     

    当然可以利用matplotlib绘制学习曲线,需要导入相应模块如下:

    from sklearn.learning_curveimport learning_curve,validation_curve

    核心代码如下,具体参见Scikit-Learn的官方文档:

    rain_sizes, train_scores,test_scores = learning_curve(

            estimator, X, y, cv=cv, n_jobs=n_jobs,train_sizes=train_sizes)

    train_scores, test_scores =validation_curve(

            estimator, X, y, param_name,param_range,

            cv, scoring, n_jobs)

     

    当然,Scikit-Learn中的机器学习模型非常丰富,包括SVM,决策树,GBDT,KNN等等,可以根据问题的类型选择合适的模型,更多内容请参阅官方文档。



    文章来源:http://blog.csdn.net/xuanyuansen/article/details/42710741








    目录 
    1. 简介
    2. 数据格式
    3.数据准备
    4. 关联规则(购物篮分析)
    5. 分类与回归
    6. 聚类分析

    1. 简介 

    WEKA的全名是怀卡托智能分析环境(Waikato Environment for Knowledge Analysis),它的源代码可通过http://www.cs.waikato.ac.nz/ml/weka得到。同时weka也是新西兰的一种鸟名,而WEKA的主要开发者来自新西兰。

    WEKA作为一个公开的数据挖掘工作平台,集合了大量能承担数据挖掘任务的机器学习算法,包括对数据进行预处理,分类,回归、聚类、关联规则以及在新的交互式界面上的可视化。
    如果想自己实现数据挖掘算法的话,可以看一看weka的接口文档。在weka中集成自己的算法甚至借鉴它的方法自己实现可视化工具并不是件很困难的事情。 

    20058月,在第11ACM SIGKDD国际会议上,怀卡托大学的Weka小组荣获了数据挖掘和知识探索领域的最高服务奖,Weka系统得到了广泛的认可,被誉为数据挖掘和机器学习历史上的里程碑,是现今最完备的数据挖掘工具之一(已有11年的发展历史)。Weka的每月下载次数已超过万次。

    --整理自http://www.china-pub.com/computers/common/info.asp?id=29304

    2. 数据格式 

    巧妇难为无米之炊。首先我们来看看WEKA所用的数据应是什么样的格式。 
    跟很多电子表格或数据分析软件一样,WEKA所处理的数据集是图1那样的一个二维的表格。 

    图1 新窗口打开 
    这里我们要介绍一下WEKA中的术语。表格里的一个横行称作一个实例(Instance),相当于统计学中的一个样本,或者数据库中的一条记录。竖行称作一个属性(Attrbute),相当于统计学中的一个变量,或者数据库中的一个字段。这样一个表格,或者叫数据集,在WEKA看来,呈现了属性之间的一种关系(Relation)。图1中一共有14个实例,5个属性,关系名称为“weather”。

    WEKA存储数据的格式是ARFF(Attribute-Relation File Format)文件,这是一种ASCII文本文件。图1所示的二维表格存储在如下的ARFF文件中。这也就是WEKA自带的“weather.arff”文件,在WEKA安装目录的“data”子目录下可以找到。


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

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

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

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

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

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

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

    日期和时间属性 
    日期和时间属性统一用“date”类型表示,它的格式是 
    @attribute <name> date [<date-format>] 
    其中<name>是这个属性的名称,<date-format>是一个字符串,来规定该怎样解析和显示日期或时间的格式,默认的字符串是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的属性值用<index> <空格> <value>表示。<index>是属性的序号,从0开始计;<value>是属性值。属性值之间仍用逗号隔开。这里每个实例的数值必须按属性的顺序来写,如 {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使用最多的模块。现在我们先来熟悉它的界面,然后利用它对数据进行预处理。 

    图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.0
     [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.0 [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.0 [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.0 [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”,可以把这个树看清楚些。看完后截图或者关掉

    这里我们解释一下“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










    开源机器学习工具scikit-learn入门


    Scikit-Learn是基于python的机器学习模块,基于BSD开源许可证。这个项目最早由DavidCournapeau 在2007 年发起的,目前也是由社区自愿者进行维护。

    Scikit-Learn的官方网站是http://scikit-learn.org/stable/,在上面可以找到相关的Scikit-Learn的资源,模块下载,文档,例程等等。

    Scikit-Learn的安装需要numpy,scipy,matplotlib等模块,windows用户可以到

    http://www.lfd.uci.edu/~gohlke/pythonlibs直接下载编译好的安装包以及依赖,也可以到这个网站下载http://sourceforge.jp/projects/sfnet_scikit-learn/

     

    scikit-learn的基本功能主要被分为六个部分,分类,回归,聚类,数据降维,模型选择,数据预处理,具体可以参考官方网站上的文档。

    对于具体的机器学习问题,通常可以分为三个步骤,数据准备与预处理,模型选择与训练,模型验证与参数调优,这里以逻辑回归模型为例说明。

    scikit-learn支持多种格式的数据,包括经典的iris数据,LibSVM格式数据等等。为了方便起见,推荐使用LibSVM格式的数据,详细见LibSVM的官网。

    from sklearn.datasets importload_svmlight_file,导入这个模块就可以加载LibSVM模块的数据,

    t_X,t_y=load_svmlight_file("filename")

    机器学习模型也要导入相应的模块,逻辑回归模型在下面的模块中。

    from sklearn.linear_modelimport LogisticRegression

    regressionFunc =LogisticRegression(C=10, penalty='l2', tol=0.0001)

    train_sco=regressionFunc.fit(train_X,train_y).score(train_X,train_y)

    test_sco=regressionFunc.score(test_X,test_y)

    就可以完成模型的训练和测试了。

    为了选择更好地模型可以进行交叉实验,或者使用贪心算法进行参数调优。

    导入如下模块就可以,

    CV:

    from sklearn importcross_validation

    X_train_m, X_test_m,y_train_m, y_test_m = cross_validation.train_test_split(t_X,t_y, test_size=0.5,random_state=seed_i)

    regressionFunc_2.fit(X_train_m,y_train_m)

    sco=regressionFunc_2.score(X_test_m,y_test_m, sample_weight=None)

     

    GridSearch:

    from sklearn.grid_searchimport GridSearchCV

    tuned_parameters =[{'penalty': ['l1'], 'tol': [1e-3, 1e-4],

                         'C': [1, 10, 100, 1000]},

                        {'penalty': ['l2'], 'tol':[1e-3, 1e-4],

                         'C': [1, 10, 100, 1000]}]

    clf =GridSearchCV(LogisticRegression(), tuned_parameters, cv=5, scoring=['precision','recall'])

    print(clf.best_estimator_)

     

    当然可以利用matplotlib绘制学习曲线,需要导入相应模块如下:

    from sklearn.learning_curveimport learning_curve,validation_curve

    核心代码如下,具体参见Scikit-Learn的官方文档:

    rain_sizes, train_scores,test_scores = learning_curve(

            estimator, X, y, cv=cv, n_jobs=n_jobs,train_sizes=train_sizes)

    train_scores, test_scores =validation_curve(

            estimator, X, y, param_name,param_range,

            cv, scoring, n_jobs)

     

    当然,Scikit-Learn中的机器学习模型非常丰富,包括SVM,决策树,GBDT,KNN等等,可以根据问题的类型选择合适的模型,更多内容请参阅官方文档。



    文章来源:http://blog.csdn.net/xuanyuansen/article/details/42710741


    展开全文
  • 神经网络的概念和基本推导,Weka中实现神经网络和参数的基本含义

    神经网络是一种非常重要的机器学习模型,人们从生物学中大脑神经元连接方式得到启发,提出了神经网络的概念,它从信息处理角度对人脑神经元网络进行抽象, 建立某种简单模型,按不同的连接方式组成不同的网络。
    最近几年深度学习大热,尤其是阿尔法围棋(AlphaGo)战胜李世乭后,神经网络和深度学习被推到了风口浪尖的。AlphaGo主要工作原理是“深度学习”。“深度学习”是指多层的人工神经网络和训练它的方法。一层神经网络会把大量矩阵数字作为输入,通过非线性激活方法取权重,再产生另一个数据集合作为输出。这就像生物神经大脑的工作机理一样,通过合适的矩阵数量,多层组织链接一起,形成神经网络“大脑”进行精准复杂的处理,就像人们识别物体标注图片一样。
    人工神经网络模型主要考虑网络连接的拓扑结构、神经元的特征、学习规则等。目前,已有近40种神经网络模型,其中有反传网络、感知器、自组织映射、Hopfield网络、波耳兹曼机、适应谐振理论等。根据连接的拓扑结构,神经网络模型可以分为:
    (1)前向网络 网络中各个神经元接受前一级的输入,并输出到下一级,网络中没有反馈,可以用一个有向无环路图表示。这种网络实现信号从输入空间到输出空间的变换,它的信息处理能力来自于简单非线性函数的多次复合。网络结构简单,易于实现。反传网络是一种典型的前向网络。

    (2)反馈网络 网络内神经元间有反馈,可以用一个无向的完备图表示。这种神经网络的信息处理是状态的变换,可以用动力学系统理论处理。系统的稳定性与联想记忆功能有密切关系。Hopfield网络、波耳兹曼机均属于这种类型。
    Ng的课程里神经网络讲的比较少,这次主要听了加州理工学院的公开课:机器学习与数据挖掘,地址是:
    http://open.163.com/movie/2012/2/I/D/M8FH262HJ_M8FU27PID.html
    我将总结老师讲解的神经网络概念、反向传播等知识进行总结,如有错误之处,请批评指正。

    • 问题提出

    简单的多层感知器不能够进行复杂的分类工作。
    这里写图片描述
    对于第一个图中的两类,简单线性感知器并不能正确的分类,但是我们可以构建第二第三两个基本感知器,将两个感知器进行某种方式的联结,合成一个更加强大的感知器。
    这里写图片描述
    第一个感知器因为有一个不变的输入1.5>1,因此必须X1,X2都是负的才能使得输出为负,这就实现了or运算,同理第二个感知器实现了AND运算。
    这里写图片描述
    我们把基本感知器进行组合,就可以得到复杂的感知器,理论上它可以模拟任何曲面。如图,输入X0,X1,X2,通过or、and感知器进行运算,可以得到复杂的输出f,这就是多层感知器的原理。图中是前馈网络,所谓前馈,就是输出只能向后传递,不能对之前的结果产生作用。图中一共有三层感知器,分别是输入层,隐含层和输出层,每一层后面的数字代表权重,也是我们要求的量。
    这里写图片描述
    如上图所示,通过使用16层感知器,我们可以得到一个非常接近圆的区域,这就形象的表示了为何理论上神经网络可以拟合任何复杂函数。理论上讲虽然越多的感知器可以带来更好地逼近效果,但是也会带来两个问题,那就是降低泛化能力和带来优化上的困难。

    • 神经网络

    这里写图片描述
    上图就是一个典型神经网络的结构,每一层都是非线性的,图中一共有三层。非线性是由感知器的激励函数产生的,比如常用的tanh函数:
    这里写图片描述
    从以上分析我们可以知道,我们求取的就是连接神经元之间的权重,首先我们对权重进行符号化表示:
    这里写图片描述
    输入之所以从0开始是因为每一层都会有一项常数,即X0。
    不难看出,右边层的输入其实就是前一层的输出。那么我们可以得到表达式:
    这里写图片描述
    其中S就是信号,对于输入的变量,每一层经过计算产生输出,层层计算直到输出层。那么如何构建出这个神经网络呢?关键就在于W的计算,我们需要计算出所有的权重,并保证权重是最优的。这是一个计算量非常大的工作,必须引入高效的计算方式才能解决。

    • 反向传播算法

    我们可以利用随机梯度下降求取最佳的权重,但是仍然不能避免巨大的计算量,所以我们应该分析层与层之间的关系,利用这些关系简化计算。根据前两篇博客的内容,我们首先表达出误差项:
    这里写图片描述
    接下俩就是求取梯度:
    这里写图片描述
    对于一个神经元连接来说:
    这里写图片描述
    我们可以发现,W权重其实是X和S之间的桥梁,也就是X通过权重作用于信号S上,不受其他变量的影响。那么利用求导的链式法则:
    这里写图片描述
    我们可以将这种关系进行分解,不难看出,S和W之间的求导关系其实就是X,接下来我们要求的就是第二项,我们暂时令它为δ。
    因为最后一层结果就是输出,因此先分析最后一层应该是最简单的,那么对于最后一层,我们可以得到:
    这里写图片描述
    其中:
    这里写图片描述
    又有如下公式:
    这里写图片描述
    观察整个层与层之间的关系,我们不难发现,每一层的输出作为下一层的输入,这种关系层层传递,那么我们可以表示出相邻两层之间的关系:
    这里写图片描述
    利用求导的链式法则:
    这里写图片描述
    因此我们可以得到化简后的结果:
    这里写图片描述
    这样我们就得到了δ层与层之间的递推关系,也就是说,我们知道最后一层的δ,就可以倒着推出所有的δ,这就避免了每次一个一个计算W,可以迭代进行整个过程,因此BP算法的整个过程可以表述如下:
    这里写图片描述

    这里需要注意的是,初始化权重W不能全部为0,因为这样相当于层与层之间没有任何关联,每次更新迭代并不会有任何效果。这就像你站在山顶,如果没有外部力量推一把,你永远不会滚下山,到达最低的地方。因此,初始化权重应该随机赋值才能保证效果。事实上随机思想还可以避免陷入到非常明显的局部最优解,这对算法来说非常有效。

    • Weka中实现神经网络

    首先要知道的是,每次学习之前,输入的数据被自动分成training set、validation set 及test set 三部分,training set是训练样本数据,validation set是验证样本数据,test set是测试样本数据,这样这三个数据集是没有重叠的。在训练时,用training训练,每训练一次,系统自动会将validation set中的样本数据输入神经网络进行验证,在validation set输入后会得出一个误差(不是网络的训练误差,而是验证样本数据输入后得到的输出误差,可能是均方误差),而此前对validation set会设置一个步数,比如默认是6echo,则系统判断这个误差是否在连续6次检验后不下降,如果不下降或者甚至上升,说明training set训练的误差已经不再减小,没有更好的效果了,这时再训练就没必要了,就停止训练,不然可能陷入过学习。
    Weka中提供了多层感知器,MultilayerPerceptron,它使用的激励函数是sigmod函数,看一下它主要的可用参数:
    这里写图片描述
    这里写图片描述

    下面逐个解释每个参数的作用:
    ① -L 学习速率
    学习速率,也就是梯度下降的速度。
    学习速率的选取很重要 ,大了可能导致系统不稳定,小了会导致训练周期过长、收敛慢,达不到要求的误差。一般倾向于选取较小的学习速率以保持系统稳定,通过观察误差下降曲线来判断。下降较快说明学习率比较合适,若有较大振荡则说明学习率偏大。同时,由于网络规模大小的不同,学习率选择应当针对其进行调整。采用变学习速率的方案,令学习速率随学习进展而逐步减少,可收到良好的效果。
    ② -M 动量
    BP神经网络在批处理训练时会陷入局部最小,也就是说误差能基本不变化其返回的信号对权值调整很小但是总误差能又大于训练结果设定的总误差能条件。这个时候加入一个动量因子有助于其反馈的误差信号使神经元的权值重新振荡起来。从权重更新的公式上看:
    这里写图片描述
    最后一项的α就是动量的系数。引入动量可以加快神经网络收敛。
    ③ -N 迭代次数
    由于神经网络计算并不能保证在各种参数配置下迭代结果收敛,当迭代结果不收敛时,允许最大的迭代次数。
    ④ -V
    Validation set的百分比,训练将持续直到其观测到在validation set上的误差已经一直在变差或者不变,或者训练的时间已经到了 。
    如果validation set设置的是0那么网络将一直训练直到达到迭代的次数
    ⑤ -E
    用于终止validation testing。这个值用于决定在训练终止前在一行内的validation set error可以变差(或者不变)多少次 。
    ⑥ -H 每层的神经元数
    通用符 ‘a’ = (attribs + classes) / 2, ‘i’ = attribs, ‘o’ = classes , ‘t’ = attribs + classes
    ⑦-R 重置
    将允许网络用一个更低的学习速率复位。如果网络偏离了方向其将会自动的用更低的学习速率复位并且重新训练。若没有加这个参数,偏离方向后训练将返回失败信息。
    ⑧ -D延迟
    这个参数可以导致学习的速率的降低。其将初始的学习速率除以迭代次数(epoch number)去决定当前的学习速率。这对于停止神经网络背离目标输出有帮助,也提高了general performance。

    其他参数比较简单,涉及到的都是数据挖掘基本知识,不再赘述。
    下面是代码示例:

    class NeuralNetworkModel  {
        public NeuralNetworkModel(Instances data) throws Exception{
            String[] options = {"-L",0.1,"-M",0.1,"-N",1000,"-H",4}
            MultilayerPerceptron model = new MultilayerPerceptron();
            modeloptions = options;
            model.setOptions(options);
            model.buildClassifier(data);
        }
    }
    

    如上创建的是一个具有一个隐含层的网络,如果想创建两个隐含层的网络,每一层都指定若干个神经元,参数应该写成:
    setHiddenLayers(“4,5”) 或者 “… -H 4,5”
    代表两个隐含层,第一层4个神经元,第二层5个神经元。

    需要注意的是,神经网络一个非常难以确定的是隐含层层数和每层神经元数的选择,一般都按照经验进行选取,对于线性问题一般可以采用感知器或自适应网络来解决,而不采用非线性网络,因为单层不能发挥出非线性激活函数的特长。对于非线性问题,一般采用两层或两层以上的隐含层,但是误差精度的提高实际上也可以通过增加隐含层中的神经元数目获得,其训练效果也比增加层数更容易观察和调整,所以一般情况下,应优先考虑增加隐含层中的神经元数。对于数量,一般按照(属性数目+类别数目)/2来选取,并留一点余量。
    对于每个参数影响有多大,可以看下面这张图:
    这里写图片描述

    展开全文
  • 当然可以利用matplotlib绘制学习曲线,需要导入相应模块如下: from sklearn.learning_curveimport learning_curve,validation_curve 核心代码如下,具体参见Scikit-Learn的官方文档: rain_sizes, ...

    开源机器学习工具scikit-learn入门


    Scikit-Learn是基于Python机器学习模块,基于BSD开源许可证。这个项目最早由DavidCournapeau 在2007 年发起的,目前也是由社区自愿者进行维护。

    Scikit-Learn的官方网站是http://scikit-learn.org/stable/,在上面可以找到相关的Scikit-Learn的资源,模块下载,文档,例程等等。

    Scikit-Learn的安装需要numpy,scipy,matplotlib等模块,windows用户可以到

    http://www.lfd.uci.edu/~gohlke/pythonlibs直接下载编译好的安装包以及依赖,也可以到这个网站下载http://sourceforge.jp/projects/sfnet_scikit-learn/

     

    scikit-learn的基本功能主要被分为六个部分,分类,回归,聚类,数据降维,模型选择,数据预处理,具体可以参考官方网站上的文档。

    对于具体的机器学习问题,通常可以分为三个步骤,数据准备与预处理,模型选择与训练,模型验证与参数调优,这里以逻辑回归模型为例说明。

    scikit-learn支持多种格式的数据,包括经典的iris数据,LibSVM格式数据等等。为了方便起见,推荐使用LibSVM格式的数据,详细见LibSVM的官网。

    from sklearn.datasets importload_svmlight_file,导入这个模块就可以加载LibSVM模块的数据,

    t_X,t_y=load_svmlight_file("filename")

    机器学习模型也要导入相应的模块,逻辑回归模型在下面的模块中。

    from sklearn.linear_modelimport LogisticRegression

    regressionFunc =LogisticRegression(C=10, penalty='l2', tol=0.0001)

    train_sco=regressionFunc.fit(train_X,train_y).score(train_X,train_y)

    test_sco=regressionFunc.score(test_X,test_y)

    就可以完成模型的训练和测试了。

    为了选择更好地模型可以进行交叉实验,或者使用贪心算法进行参数调优。

    导入如下模块就可以,

    CV:

    from sklearn importcross_validation

    X_train_m, X_test_m,y_train_m, y_test_m = cross_validation.train_test_split(t_X,t_y, test_size=0.5,random_state=seed_i)

    regressionFunc_2.fit(X_train_m,y_train_m)

    sco=regressionFunc_2.score(X_test_m,y_test_m, sample_weight=None)

     

    GridSearch:

    from sklearn.grid_searchimport GridSearchCV

    tuned_parameters =[{'penalty': ['l1'], 'tol': [1e-3, 1e-4],

                         'C': [1, 10, 100, 1000]},

                        {'penalty': ['l2'], 'tol':[1e-3, 1e-4],

                         'C': [1, 10, 100, 1000]}]

    clf =GridSearchCV(LogisticRegression(), tuned_parameters, cv=5, scoring=['precision','recall'])

    print(clf.best_estimator_)

     

    当然可以利用matplotlib绘制学习曲线,需要导入相应模块如下:

    from sklearn.learning_curveimport learning_curve,validation_curve

    核心代码如下,具体参见Scikit-Learn的官方文档:

    rain_sizes, train_scores,test_scores = learning_curve(

            estimator, X, y, cv=cv, n_jobs=n_jobs,train_sizes=train_sizes)

    train_scores, test_scores =validation_curve(

            estimator, X, y, param_name,param_range,

            cv, scoring, n_jobs)

     

    当然,Scikit-Learn中的机器学习模型非常丰富,包括SVM,决策树,GBDT,KNN等等,可以根据问题的类型选择合适的模型,更多内容请参阅官方文档。



    文章来源:http://blog.csdn.net/xuanyuansen/article/details/42710741








    目录 
    1. 简介
    2. 数据格式
    3.数据准备
    4. 关联规则(购物篮分析)
    5. 分类与回归
    6. 聚类分析

    1. 简介 

    WEKA的全名是怀卡托智能分析环境(Waikato Environment for Knowledge Analysis),它的源代码可通过http://www.cs.waikato.ac.nz/ml/weka得到。同时weka也是新西兰的一种鸟名,而WEKA的主要开发者来自新西兰。

    WEKA作为一个公开的数据挖掘工作平台,集合了大量能承担数据挖掘任务的机器学习算法,包括对数据进行预处理,分类,回归、聚类、关联规则以及在新的交互式界面上的可视化。
    如果想自己实现数据挖掘算法的话,可以看一看weka的接口文档。在weka中集成自己的算法甚至借鉴它的方法自己实现可视化工具并不是件很困难的事情。 

    20058月,在第11ACM SIGKDD国际会议上,怀卡托大学的Weka小组荣获了数据挖掘和知识探索领域的最高服务奖,Weka系统得到了广泛的认可,被誉为数据挖掘和机器学习历史上的里程碑,是现今最完备的数据挖掘工具之一(已有11年的发展历史)。Weka的每月下载次数已超过万次。

    --整理自http://www.china-pub.com/computers/common/info.asp?id=29304

    2. 数据格式 

    巧妇难为无米之炊。首先我们来看看WEKA所用的数据应是什么样的格式。 
    跟很多电子表格或数据分析软件一样,WEKA所处理的数据集是图1那样的一个二维的表格。 

    图1 新窗口打开 
    这里我们要介绍一下WEKA中的术语。表格里的一个横行称作一个实例(Instance),相当于统计学中的一个样本,或者数据库中的一条记录。竖行称作一个属性(Attrbute),相当于统计学中的一个变量,或者数据库中的一个字段。这样一个表格,或者叫数据集,在WEKA看来,呈现了属性之间的一种关系(Relation)。图1中一共有14个实例,5个属性,关系名称为“weather”。

    WEKA存储数据的格式是ARFF(Attribute-Relation File Format)文件,这是一种ASCII文本文件。图1所示的二维表格存储在如下的ARFF文件中。这也就是WEKA自带的“weather.arff”文件,在WEKA安装目录的“data”子目录下可以找到。


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

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

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

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

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

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

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

    日期和时间属性 
    日期和时间属性统一用“date”类型表示,它的格式是 
    @attribute <name> date [<date-format>] 
    其中<name>是这个属性的名称,<date-format>是一个字符串,来规定该怎样解析和显示日期或时间的格式,默认的字符串是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的属性值用<index> <空格> <value>表示。<index>是属性的序号,从0开始计;<value>是属性值。属性值之间仍用逗号隔开。这里每个实例的数值必须按属性的顺序来写,如 {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使用最多的模块。现在我们先来熟悉它的界面,然后利用它对数据进行预处理。 

    图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.0
     [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.0 [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.0 [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.0 [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”,可以把这个树看清楚些。看完后截图或者关掉

    这里我们解释一下“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










    开源机器学习工具scikit-learn入门


    Scikit-Learn是基于python的机器学习模块,基于BSD开源许可证。这个项目最早由DavidCournapeau 在2007 年发起的,目前也是由社区自愿者进行维护。

    Scikit-Learn的官方网站是http://scikit-learn.org/stable/,在上面可以找到相关的Scikit-Learn的资源,模块下载,文档,例程等等。

    Scikit-Learn的安装需要numpy,scipy,matplotlib等模块,windows用户可以到

    http://www.lfd.uci.edu/~gohlke/pythonlibs直接下载编译好的安装包以及依赖,也可以到这个网站下载http://sourceforge.jp/projects/sfnet_scikit-learn/

     

    scikit-learn的基本功能主要被分为六个部分,分类,回归,聚类,数据降维,模型选择,数据预处理,具体可以参考官方网站上的文档。

    对于具体的机器学习问题,通常可以分为三个步骤,数据准备与预处理,模型选择与训练,模型验证与参数调优,这里以逻辑回归模型为例说明。

    scikit-learn支持多种格式的数据,包括经典的iris数据,LibSVM格式数据等等。为了方便起见,推荐使用LibSVM格式的数据,详细见LibSVM的官网。

    from sklearn.datasets importload_svmlight_file,导入这个模块就可以加载LibSVM模块的数据,

    t_X,t_y=load_svmlight_file("filename")

    机器学习模型也要导入相应的模块,逻辑回归模型在下面的模块中。

    from sklearn.linear_modelimport LogisticRegression

    regressionFunc =LogisticRegression(C=10, penalty='l2', tol=0.0001)

    train_sco=regressionFunc.fit(train_X,train_y).score(train_X,train_y)

    test_sco=regressionFunc.score(test_X,test_y)

    就可以完成模型的训练和测试了。

    为了选择更好地模型可以进行交叉实验,或者使用贪心算法进行参数调优。

    导入如下模块就可以,

    CV:

    from sklearn importcross_validation

    X_train_m, X_test_m,y_train_m, y_test_m = cross_validation.train_test_split(t_X,t_y, test_size=0.5,random_state=seed_i)

    regressionFunc_2.fit(X_train_m,y_train_m)

    sco=regressionFunc_2.score(X_test_m,y_test_m, sample_weight=None)

     

    GridSearch:

    from sklearn.grid_searchimport GridSearchCV

    tuned_parameters =[{'penalty': ['l1'], 'tol': [1e-3, 1e-4],

                         'C': [1, 10, 100, 1000]},

                        {'penalty': ['l2'], 'tol':[1e-3, 1e-4],

                         'C': [1, 10, 100, 1000]}]

    clf =GridSearchCV(LogisticRegression(), tuned_parameters, cv=5, scoring=['precision','recall'])

    print(clf.best_estimator_)

     

    当然可以利用matplotlib绘制学习曲线,需要导入相应模块如下:

    from sklearn.learning_curveimport learning_curve,validation_curve

    核心代码如下,具体参见Scikit-Learn的官方文档:

    rain_sizes, train_scores,test_scores = learning_curve(

            estimator, X, y, cv=cv, n_jobs=n_jobs,train_sizes=train_sizes)

    train_scores, test_scores =validation_curve(

            estimator, X, y, param_name,param_range,

            cv, scoring, n_jobs)

     

    当然,Scikit-Learn中的机器学习模型非常丰富,包括SVM,决策树,GBDT,KNN等等,可以根据问题的类型选择合适的模型,更多内容请参阅官方文档。



    文章来源:http://blog.csdn.net/xuanyuansen/article/details/42710741

    展开全文
  •  Weka的Explorer(探索者)界面,是Weka的主要图形化用户界面,其全部功能都可通过菜单选择或表单填写进行访问。本博客将详细介绍Weka探索者界面的图形化用户界面、预处理界面、分类界面、聚类界面、关联界面、选择...

     

     

     

     

      不多说,直接上干货!

     

     

      Weka的Explorer(探索者)界面,是Weka的主要图形化用户界面,其全部功能都可通过菜单选择或表单填写进行访问。本博客将详细介绍Weka探索者界面的图形化用户界面、预处理界面、分类界面、聚类界面、关联界面、选择属性界面和可视化界面等内容。

     

     

     

     

     

     

    一、Weka的Explorer(探索者)界面里的图形化界面

      启动Weka GUI选择器窗口之后,用鼠标单击窗口右部最上面的Explorer按钮,启动探索者界面,这时,由于没有加载数据集,除预处理面板外,其他面板都变灰而不可用, 可以使用Open file、Open URL、Open DB或者Generate按钮加载或产生数据集,加载数据集之后,其他面板才可以使用。

     


      我这里以打开文件为例进行说明。单击左上部的Open file按钮,通过弹出的打开文件对话框,选择打开data子目录下的iris.arfT文件,加载数据集后的探索者界面如下图所示。

     

     

     

     

      区域1的几个选项卡是用来切换不同的挖掘任务面板。这一节用到的只有“Preprocess”,其他面板的功能将在以后介绍。 
      区域2是一些常用按钮。包括打开数据,保存及编辑功能。

      区域3中“Choose”某个“Filter”,可以实现筛选数据或者对数据进行某种变换。数据预处理主要就利用它来实现。 
      区域4展示了数据集的一些基本情况。 
      区域5中列出了数据集的所有属性。勾选一些属性并“Remove”就可以删除它们,删除后还可以利用区域2的“Undo”按钮找回。区域5上方的一排按钮是用来实现快速勾选的。
      区域6中选中某个属性,则区域6中有关于这个属性的摘要。注意对于数值属性和分类属性,摘要的方式是不一样的。图中显示的是对数值属性“income”的摘要。 
      区域7是区域5中选中属性的直方图。若数据集的最后一个属性(我们说过这是分类或回归任务的默认目标变量)是分类变量(这里的“pep”正好是),直方图中的每个长方形就会按照该变量的比例分成不同颜色的段。要想换个分段的依据,在区域7上方的下拉框中选个不同的分类属性就可以了。下拉框里选上“No Class”或者一个数值属性会变成黑白的直方图。
      区域8是状态栏,可以查看Log以判断是否有错。右边的weka鸟在动的话说明WEKA正在执行挖掘任务。右键点击状态栏还可以执行Java内存的垃圾回收。

     

     

     

     

     

     1、标签页介绍

      下图图所示界面的顶部有六个不同的标签页,代表六个不同的面板,分别对应Weka 听支持的多种数据挖掘方式。如果刚开始打开探索者界面,那么只有第一个预处理标签页可用,其余的标签文字全部变为灰色而不可用,这是因为必须先打开一个数据集,根据应用需要,或许还需要对数据进行预处理,才能使用其他面板。
      这六个标签页的介绍如下。

    (1) PreprocesS(预处理)。选择数据集,并以不同方式对其进行修改。
    (2) Classify(分类)。训练用于分类或回归的学习方案,并对其进行评估。
    (3) Cluster(聚类)。学习数据集聚类方案。
    (4) Associate(关联)。学习数据关联规则,并对其进行评估。
    (5) Select attributes(选择属性)。选择数据集中最相关的部分属性。
    (6) Visualize(可视化)。查看不同二维数据散点图,并与其进行互动。
      每个标签页都可完成不同工作,单击标签页上部文字即可实现标签切换。窗口底部包括状态(Status)栏、日志(Log)按钮和一只Weka鸟,这些都是一直保持可见,不论用户切换到哪一个标签页。

     

     

     

     

    2、状态栏

      状态栏位于窗口的最下部,显示ih用户了解现在正在进行到哪一步的状态信息。例如,如果探索者正在忙于加载数据文件,状态栏会显示相应的状态信息。

      除了显示状态之外,还可以右击来显示内存信总,以及运行垃圾回收器以清理内存。 在状态栏的任意位罝右击,会弹出一个上下文菜单,菜单只包括两个菜单项——Memory information(内存信信息)和Run garbage collector(运行垃圾回收器),第一个菜单项显示Weka 当前可用的内存空间:第二个菜单项启动Java垃圾回收器,搜寻不再使用的内存并释放以回收部分内存空间,提供给新的任务使用。需要指出的是,垃圾回收器是一个不间断运行的后台任务,如果不强制进行垃圾回收,Java虚拟机也会在适当时候自动启动垃圾回收。
      日志按钮位于状态栏的右面,单击该按钮会打开可以滚动的日志文本框,显示在此次 运行期间内Weka进行的全部活动以及每项活动的时间戳。不管是使用图形用户界面、命令行还是Simple CLI,日志都会包含分类、聚类、M性选择等操作的完整的设置字符串。 因此,用户可以进行复制和粘贴。顺便提醒大家,学习日志里记录的命令,可以深层次地了解Weka的内部运行机制。
      曰志按钮的右边,可以#到称Weka状态图标的鸟。如果没有处理过程在运行,小鸟会坐下来打个盹。“X”符号旁边的数字显示目前有多少个正在进行处理的进程,当系 统空闲时,该数字为零,数字会随着正在进行处理进程数的增加而增加。当启动处理进程 时,小鸟会站起来不停走动。如果小鸟长时间站着不动,说明Weka出现运行错误,此时用户需要关闭并重新启动探索者界面。

     

     

     

     

     

    3、 图像输出

       Weka中显示的大部分图形,不论是通过 GraphVisualizer (图可视化器)或是TreeVisualizer(树可视化器)显示的,都可以保存为图像文件以备将来使用。保存方法是,按下Alt键和 Shift键的同时,在要保存的图形上单击,就可启动保存文件对话框。支持的的图像文件格式有 BMP、 JPEG、 PNG和 Postscript的 EPS,用户可以选择图像文件格式还可以修改输出图像文件的尺寸。


     

    4、手把手教你用

       4.1、启动Weka

      从Windows左下角的“开始”菜单,依次选择“所有程序”,再找到Weka3.7.8菜单,启动它,如下图所示。

     

      然后,单击窗口右部最上边的Explorer按钮启动Weka 探索者,如下图所示。

     

     

       现在,除了Preprocess标签页可用外,其余标签页都是不可用的。

     

     

       2、了解标签页

      单击上图的Open file按钮,该按钮位于窗口的左上部。启动“打开”文件窗口,导航到Weka安装目录下的data子目录,选择iris.arff文件,我这里是选择在

    D:\SoftWare\Weka-3-7\data。单击打开按钮,打开该文件,如下图所示。

     

      打开文件(或称为加载数据)后的Weka探索者,界面如下如所示,可以看到,加载数据后,六个标签页都变为可用状态。

     

      大家,可以自行去切换标签页,初步了解各个标签页的功能,为后续的学习打下基础。

     

     

     

       3、了解状态栏

      不论切换到哪个标签页,都可以在探索者窗口下部的状态栏查看到状态信息。在状态栏任意位置右击,在弹出的上下文菜单中选择第一项Memory information(内存信息),状态栏显示用斜杠分隔的内存信息,格式为:空闲内存/全部内存/最大内存,单位字节。如下图所示。

     

     

      如果选择上下文菜单中的第二项Run garbage collector,状态栏会显示ok信息,表示已经启动了垃圾回收器。

      

      单击状态栏右边的Log按钮,可以查看到当前日志。

     

     

     

     

     

       4、保存图像文件

      单击如下图所示的界面右边的Visualize All(全部可视化)按钮,打开如下图所示的全部可视化窗口。

     

     

      同时,按下Alt键  + Shift键,并在上图所示任选一图标,在图标的任意位置单击,启动保存文件对话框。输入名称为test,选择文件类型为jpg(或其他格式),保存按钮,就可以保存为图像文件了,如下图所示。(比如,我这里选择用最左上方的那一幅图)

     

      还可以定制图像文件的长、宽尺寸,单位为像素。选中use custom dimensions(使用自定义尺寸)复选框就可以设置图像尺寸,如果选择keep aspect ratio(保持宽高比)复选框,则在修改图像长(或宽)的同时,会按比例自动缩放宽(或长)。

     

     

     

     

       成功!

     

     

     

     

    二、预处理

      预处理面板可以从文件、URL或数据库中加载数据集,并且根据应用要求或领域知识过滤掉不需要进行处理或不符合要求的数据。

     

       1、加载数据

      预处理标签页的前四个按钮可以让用户将数据加载到Weka系统。

      Open file按钮启动打开文件对话框,用户可以浏览本地文件系统,打开本地数据文件;

      Open URL按钮要求 用户提供一个统一资源定位符地址,Weka使用HTTP协议从网络位罝下载数据文件;

      Open DB按钮用于从数据库中读取数据,支持所有能够用JDBC驱动程序读取的数据库, 使用SQL语句或存储过程读取数据集。

      请注意,必须根据自己的计算机环境配置,相应修 改weka/experiment/DatabaseUtils.props配置文件后才能访问数据库,具体参见下面我写的这篇博客;

      Generate按钮用于让用户使用不同的DataGenerators(数据生成器)以生成人工 数据,适合用于分类功能的人工数据可以由决策列表RDG1、径向基函数网络 RandomRBF、贝叶斯网络BayesNet、LED24等算法产生,人工回归数据也可以根据数学表达式生成,用于聚类的人工数据可以使用现成的生成算法产生。

     

     

      如果使用Open file按钮,可以读取多种数据格式的文件,包括Weka ARFF格式、 C4.5数据格式、CSV格式、JSON实例文件格式、libsvm数据文件格式、Matlib ASCII文件格式、svm轻量级数据文件格式、XRFF格式,以及序列化实例的格式。

      其中,ARFF 格式文件的后缀为.arff, C4.5文件的后缀为.data或.names, CSV格式文件的后缀为.csv, JSON实例文件格式的后缀为json,libsvm数据文件格式的后缀为.libsvm, Matlib ASCII文件格式的后缀为.m,svm轻量级数据文件格式的后缀为.dat,XRFF格式的后缀为.xrff, 序列化实例对象文件的后缀为.bsi。

      注意到有的格式后缀还加上.gz,这是对应文件的压缩 形式。

     

     


      另外,使用Save(保存)按钮,可以将已加载的数据保存为Weka支持的所有文件格式。该功能特别适合转换文件格式,以及学习Weka文件格式的细节。

     

     


      由于有多种数据格式,为了从不同种类的数据源中导入数据,Weka提供实用工具类进行转换,这种工具称为转换器(converters),位于weka.core.converters包中。按照功能的不同,转换器分为加载器和保存器,前者的Java类名以Loader结束,后者以Saver结束。

      加载数据后,预处理面板会在Currem relation(当前关系)子面板显示当前数据集的一些总结信息。Relation(关系)栏显示关系名称,该名称由加载的文件给定,也可通过过滤器来更改名称;Attributes(属性)栏显示数据集中的属性(或特征)个数:Instances(实例)枚显示数 据集中的实例(或数据点/记录)个数:Sum of weights(权重和)栏显示全部实例的权重之和。 例如,当加载iris数据姐后,当前关系子而板显示关系名称为iris,属性个数为5,实例个数为150,权重和为150,当前关系子面板如下图所示。

     



      Weka根据文件后缀调用不同的转换器来加载数据集。如果Weka无法加载数据,就会尝试以ARFF格式解释数据,如果失败,就会弹出如下图的提示对话框,提示 Weka无法自动决定使用哪一个文件加载器,需要用户自己来选择。

                    加载数据失败图


      然后,单击上图中的“确定”按钮后,会弹出如下图所示的通用对象编辑器对话框, 让用户选定能打幵数据文件的对应转换器。默认转换器为CSVLoader,该转换器专门用于加载后缀为.csv的文件。如果用户己经确定数据文件格式是CSV格式,那么可以输入曰期格式、字段分割符等信息。如果对窗口里的各项输入不了解,可以单击More按钮査看使用说明。

     

           图    通用对象编辑器

     

      如果用户已经知道数据文件格式不是CSV格式,可以单击通用对象编辑器对话框上部的Choose按钮选择其他的转换器,如下图所示。

             图     选择转换器图

     

      其中,第一个选项是ArffLoader,选择该选项并成功的可能性很小,因为默认使用它来加载数据集,没有成功才会弹出加载数据失败的窗口。

      第二个选项是C45Loader,C4.5 格式的数据集对应两种文件,一种文件提供字段名,另一种文件提供实际数据。

      第三个选项是默认的CSVLoader,这足一种以逗号分隔各属性的文件格式,前面已经介绍了这种数据转换器。

      第四个选项DatabascLoader是从数据库,而不是文件中读取数据集。然而,使用SQLViewer工具来访问数据库,是吏为人性化而方便的方案。 SerializedInstancesLoader选项用于重新加载以前作为Java序列化对象保存的数据集。任何 Java对象都可以采用这种格式予以保存并重新加载。由于序列化对象本身就是Java格式,使用它可能比加载ARFF文件的速度更快,这是因为加载ARFF文件时必须对其进行分析和检查,从而花费更多的时间。如果需要多次加载大数据集时,很值得以这种数据格式进行保存。

      值得一提的是,TextDirectoryLoader加载器的功能是导入一个目录,目录中包含若干以文本挖掘为目的的纯文本文件。导入目录应该有特定的结构——一组子目录,每个子目录包含一个或多个扩展名为.txt的文本文件,每个文本文件都会成为数据集中的一个实例,其中,一个字符串型属性保存该文件的内容,一个标称型的类别属性保存文件所在的子目录名称。该数据集可以通过使用StringToWordVector过滤器进一步加工为词典,为后面的文本挖掘做准备。

     

     

     

       2、属性处理

       在当前关系子面板的下方,可以看到Attributes(属性)子面板,该子面板上部有四个按钮,中部是一个三列多行的表哥,下部有一个Remove按钮。如下图所示。

     

     

      表格有三列表头,包括No.(序号)列、复选框列和Name(名字)列。

      其中,序号列用于标识指定数据集中的属性序号;

      复选框列用于选择厲性,并对其进行操作;

      名字列显示属性名称,与数据文件的属性声明一致。
      表格里每行表示一个属性,单击某一行的复选框选中该行,再单击一次则取消选中。 表格上面的四个按钮也可以用于改变选中状态;ALL按钮使全部复选框都选中,即选中全部属性;None按钮使全部复选框都取消选中,即不选中任何属性; Invert按钮反选,即取消选中己经选中的复选框,选中没有选中的复选框;Pattern按钮使用Perl5正则表达式指 定要选中的属性,例如,.*_id选择满足属性名称以_id结束的全部屈性。
      一旦己经选中所需的属性,就可以单击属性列表下面的Remove按钮将它们去除,本功能用于去除无关属性。请注意,本功能仅去除内存中的数据集,不会更改数据文件的内容。另外,属性去除之后还可以单击Undo按钮进行撤消,Undo按钮位于预处理面板的上部
      如果选中某一个属性,例如,下图选中名称为sepallength的屈性,该行的颜色就会变为蓝色,并且窗口右边的Selected attribute(己选择属性)子面板将显示选中属性的一些信息。

     

      iris.arff里的,以下是选择数值型属性的统计显示结果

     

     

     

     

     

       weather.nominal.arff里的,以下是选择标称型属性的统计显示结果

     

     

       其中,Name栏显示属性的名称,与属性列表中选中属性的名称相同;

           Type栏显示属性的类型,最常见的就是标称型和数值型;

           Missing(缺失)栏显示数据集中该属性不存在或未指定的实例的数量及百分比;

           Distinct(不同)栏显示该属性取不同值的数量;

         Unique(唯一)栏显示没有任何其他实例拥有该属性值的数量及百分比。

       已选择属性子面板的下部有一个统计表格,显示该属性值的更多信息,根据属性类型的不同,表格会有所差别。 

       由上面的iris.arff里的,以下是选择数值型属性的统计显示结果 和 weather.nominal.arff里的,以下是选择标称型属性的统计显示结果。得出,

      如果属性是数值类型,表格显示数据分布的四种统计描述---Minimum(最小值)、Maximum(最大值)、Mean(平均值)和StdDev(Standard Deviation,标准偏差);

      如果属性是标称型,列表显示包含属性的全部可能的No.(编号)、Label(标签)表示属性值名称、Count(数量)表示拥有该属性值的实例数量、Weight(权重)表示拥有该属性值的实例权重。

      在统计表格之下会显示一个彩色直方图,如图所示,直方图之上有一个下拉列表框,用于选择类别属性。

     

     

     

     

     

    3、过滤器

      预处理面板允许定义并执行以各种方式转换数据的过滤器,过滤器也称为筛选器。在Filter标签之下有一个Choose(选择)按钮,单击该按钮可以选择一个过滤器,如下图所示,按钮的右侧是过滤器输入框,用于设置所选择的过滤器参数。

     

     

     

      一旦选定过滤器后,其名称和参数都会显示在过滤器输入框内。在框内单击会弹出一个通用对象编辑器对话框,如下图所示。比如我这里选择Weka下的filters下的unsupervised下的attribute下的Remove

      则,得到一个通用对象编辑器对话框用于设置过滤器选项。如果大家用不同的过滤器,则不一样哈!

      好的,About框简要说明所选择过滤器的功能;单击右侧的More按钮,弹出一个显示更多信息的窗口,显示该过滤器的简介和不同选项的功能,如下图所示。

     

       

       单击Capabilities按钮,弹出一个信息窗口,列出所选择对象能够过处理的类别类型和属性类型,如下图所示。

     

     

     

     

      该对话框的中部,attributeIndices文本框用于让用户输入属性的索引(或下标),invertSelection下拉列表框只有ture和false两个选项,提示是否反选。对话框下端有四个按钮,前两个按钮-----Open按钮和Save按钮,用于保存对象选项设置,以备将来使用;Cancel按钮用于取消所做的修改,回退到原来的状态;Ok按钮用于已经正确完成设置后,返回探索者窗口。

      

     

       用鼠标右击(或用Alt  +  Shift  + 单击)过滤器输入框,就会弹出一个菜单,该带单有四个选项:Show properties(显示属性)、Copy configuration to clipboard(复制设置到剪贴板)、Enter configuration(输入设置)和Edit configuration(编辑设置)。

     

     

     

      如果选择Show properties,就会弹出一个通用对象编辑器对话框,允许用户修改设置,其功能与单击过滤器输入框一样,如下所示

     

       如果选择Copy configuration to clipboard,则将当前的设置字符串复制到剪贴板,以便用于Weka以外的系统中,当用户设置了很长而复杂的选项设置字符串并且想将来复用时,该功能非常方便,如下所示

     

     

     

      

      如果选择Enter configuration菜单项,则弹出一个输入dui对话框,让用户直接输入设置字符串,格式为类名称后接类能够支持的选项,如下图所示。

     

     

     

      一旦选择并配置好一个过滤器之后,就可以将其应用到数据集。单击位于预处理面板中Filter子面板右端的Apply按钮应用过滤,预处理面板会显示转换后的数据信息。如果对结果不满意,可以单击Undo按钮撤销转换,还可以单击Edit按钮在数据集编辑器里手动修改数据。如果满意修改后的结果,可以单击Preprocess标签页右上角的Save按钮,将当前关系以文件格式进行保存,以供将来使用。
      使用直方图上部的下拉列表框,可以设置类别属性。根据是否设置类别属性,有些过滤器的行为会有所不同。特别地,有监督过滤器要求设置类别属性;一些无监督属性过滤器会忽略类别属性,即使已经设置了类别属性。请注意,如果不想设置类别属性,可以将类别属性设为None。

     

     

     

     

      4、过滤器算法介绍

      在Weka中实现的过滤算法,这些过滤算法都可以用于探索者、知识流和实验者界面。
      所有的过滤器都是将输入数据集进行某种程度的转换,转换为适合数据挖掘的形式。 选杼某个过滤器之后,过滤器的名字及默认参数会出现在Choose按钮旁的输入框内,通过单击该框可以在通用对象编辑器中设置其属性。过滤器以及参数都会以命令行的方式显现在输入框,仔细观察和研宄这些过滤器和参数设设置,是学习如何直接使用Weka命令的好方法。
      Weka过滤器分为无监督weka过滤器和有监督weka过滤器两种过滤器经常应用于训练集,然后再应用于测试集。如果过滤器是有监督的,例如,使用带类别值的离散化过滤器是有监督的,如果将训练得到的良好间隔施加到测试集中,可能会使结果出现偏倚。因此,使用有监督的过滤器时,必须非常小心,以确保评估结果的公平性。然而,由于无须经过训 练,无监督过滤器就不会出现这个问题。
      Weka将无监督和有监督两种过滤方法分幵处理,每种类型又细分为属性过滤器和实例过滤器,前者作用于数据集中的属性,后者作用于数据集中的实例。要了解某个过滤器的更多使用信息,请在Weka探索者中选择该过滤器,并查看对应的对象编辑器,以了解该过滤器的功能和选项。


      Weka实现的过滤器的更详细介绍请大家在自己机器上逐一去看吧。本博客将按照过滤器的类型和功能顺序进行介绍。

      因为,Weka将无监督和有监督两种过滤方法分幵处理,每种类型又细分为属性过滤器和实例过滤器,前者作用于数据集中的属性,后者作用于数据集中的实例!!!

     

    无监督属性过滤器

    • 1) 添加和删除属性
    • 2) 改变值
    • 3) 转换
    • 4) 字符串转换
    • 5) 时间序列
    • 6) 随机化

     

     

    无监督实例过滤器

    • 1) 随机化和子抽样
    • 2) 稀疏实例

     

     

    有监督属性过滤器

    • Discretize过滤器
    • NominalToBinary过滤器
    • ClassOrder过滤器
    • AttributeSelection过滤器
    • AddClassification过滤器
    • PartitionMembership过滤器

     

     

    有监督实例过滤器

    Weka提供四个有监督的实例过滤器。

    • ClassBalancer过滤器调整数据集中的实例,使得每个类别都有相同的总权重。所有实例的权重总和将维持不变。
    • Resample过滤器与同名的无监督实例过滤器类似,但它保持在子样本的类别分布。另外,它可以配置是否使用均匀的分类偏倚,抽样可以设置为有放回(默认)或无放回模式。
    • SpreadSubsample过滤器也产生一个随机子样本,但可以控制最稀少和最常见的类别之间的频率差异。例如,可以指定至多2∶1类别频率差异。也可以通过明确指定某个类别的最大计数值,来限制实例的数量。
    • 与无监督的实例过滤器RemoveFolds相似,StratifiedRemoveFolds过滤器为数据集输出指定交叉验证的折,不同之处在于此时的折是分层的

     

     

     


      1.无监督属性过滤器
      1)添加和删除属性
      Add过滤器在一个给定的位置插入一个属性,对于所有实例该属性值声明为缺失。使用通用对象编辑器来指定属性名称,指定的属性名称会出现在属性列表中,标称属性还可以指定可能值:日期属性还可以指定日期格式。Copy过滤器复制现有属性,这样就可以在实验时保护这些属性,以免属性值为过滤器所覆盖。使用表达式可以一起复制多个属性, 例如,“1-3”复制前三个属性,“first-3,5,9-last”复制属性“1、2、3、5、9、10、11、 12、…”。选择可以进行反转,即反选,反选选中除了选定属性以外的所有属性。很多过滤器都拥有表达式和反选功能。

      AddID过滤器在用户指定索引的属性列表中插入一个数字标识符属性。标识符属性常用于跟踪某个实例,尤其是在己经通过某种方式处理过数据集之后,例如,通过其他过滤器进行过转换,或者随机化重排实例的顺序之后,标识符便于跟踪。
      Remove过滤器删除数据集中指定范围的属性,与之类似的有RemoveType过波器和 RemoveUseless过滤器,RemoveType过滤器删除指定类型(标称、数值、字符串、日期、 或关系)的所有属性,RemoveUseless过滤器删除常量属性以及几乎与所有实例的值都不相 同的标称属性。用户可以通过规定不相同值的数量占全部值总数的百分比来设定可以容忍的变化度,决定是否删除一个属性。需要注意的是,如果在预处理面板己经设置了类别属性(默认情况下,最后一个属性就是类别属性),一些无监督属性过滤器的行为不同。例如,RemoveType和RemoveUseless过滤器都会跳过类别属性。
      InterquartileRange过滤器添加新属性,以指示实例的值是否可以视为离群值或极端值。离群值和极端值定义为基r属性值的第25个和第75个四分位数之间的差。如果用户指定的极端值系数和四分位距的乘积值高于第75个四分位数,或低于第25个四分位数, 该值就标记为极端值(也有超出上述范围标记为离群值但不是极端值的情况)。可以设置该 过滤器,如果某个实例的任意M性值认为是离群值或极端值,或产生离群极端的指标,可以标记该实例为离群值或极端值0也可以将所有极端值标记为离群值,并输出与中位数偏 离多少个四分位数的属性。该过滤器忽略类别属性。
      AddCluster过滤器先将一种聚类算法应用于数据,然后再进行过滤。用户通过对象编辑器选择聚类算法,其设置方式与过滤器一样。AddCluster对象编辑器通过自己界面的 Choose按钮来选择聚类器,用户单击按钮右边方框开启另外一个对象编辑器窗口,在新窗口中设賈聚类器的参数,必须填写完整后才能返回AddCluster对象编辑器。一旦用户选定一个聚类器,AddCluster会为每个实例指定一个簇号,作为实例的新属性。对象编辑器还允许用户在聚类时忽略某些属性,如前面所述的Copy过滤器那样指定。 ClusterMembership过滤器在过滤器对象编辑器指定所使用的聚类器,生成族隶属度值,以形成新的属性。如果设罝了类别属性,在聚类过程中会忽略。
      AddExpression过滤器通过将一个数学函数应用于数值型属性而生成一个新属性。表达式可包括属性引用和常量,四则运算符+、-、*、/和^,函数log、abs、cos、exp、 sqrt、floor、ceil、rint、tan、sin以及左右括号。属性可通过索引加前缀a确定,例如a7指第七个属性。表达式范例如下:
      a1^2*a5/log(a7*4.0)
      MathExpression过滤器与AddExpression过滤器类似,它根据给定的表达式修改数值 属性,能够用于多个属性。该过滤器只是在原地修改现有属性,并不创建新属性。正因为 如此,该表达式不能引用其他属性的值。所有的适用于AddExpression过滤器操作符都可用,还可以求正在处理属性的最小值、最大值、平均值、和、平方和,以及标准偏差。此 外,可以使用的包含运算符和函数的简if-then-else的表达式。
      NumericTransfomi过滤器通过对选中的数值属性调用Java函数,可以执行任意的转换。该函数可以接受任意double数值作为参数,返回值double类型。例如, java.lang.Math包的sqrt()函数就符合这一标准。 NumericTransform过滤器有一个参数是实现该函数Java类的全限定名称,还有一个参数是转换方法的名称。

      Normalize过滤器将数据集中的全部数值属性规范化为[0,1]区间。规范化值可以采用用户提供的常数进一步进行缩放和转换。Center和Standardize过滤器能将数值属性转换为具有零均值,后者还能转换为具有单位方差的数值属性。如果设罝了类别属性,上述三个过滤器都会跳过,不对类别属性进行处理。               RandomSubset过滤器随机选择属性的一个子集, 并包括在输出中。可以用绝对数值或百分比指定抽取的范围,输出的新数据集总是把类别属性作为最后一个属性。
      ParUtionedMultiFilter过滤器是一种特殊的过滤器,在输入数据集中一组对应的顺范围内应用一组过滤器。只允许使用能操作属性的过滤器,用户提供和配罝每个过滤器,定义过滤器工作的属性范围。removeUnused选项可以删除不在任何范围内属性。将各个过滤器的输出组装成一个新的数据集。Reorder过滤器改变数据中属性的顺序,通过提供属性索引列表,指定新顺序。另外,通过省略或复制属性索引,可以删除属性或添加多个副本。


      2)改变值
      SwapVaktes过滤器交换同一个标称属性的两个值的位置。值的顺序不影响学习,但如 果选择了类别属性,顺序的改变会影响到混淆矩阵的布局。                 MergeTwoVlues过滤器将一 个标称属性的两个值合并为一个单独的类别,新值的名称是原有两个值的字符串连接,每 —个原有值的每次出现都更换为新值,新值的索引比原有值的索引小。例如,如果合并天 气数据集中outlook属性的前两个值,其中有五个sunny、四个overcast、五个rainy实例, 新的outlook屈性就包含sunny_overcast和rainy值,将有九个sunny_overcast实例和原有 的五个rainy实例。

      处理缺失值的一个方法是在实施学习方案前,全局替换缺失值。ReplaceMissingValues 过滤器用均值取代每个数值厲性的缺失值,用出现最多的众数取代标称属性的缺失值。如果设置了类别属性,默认不替换该属性的缺失值,但可以使用ignoreClass选项进行修改。
      NumericCleaner过滤器用默认值取代数值属性中值太小,或太大,或过于接近某个特定值。也可以为每一种情况指定不同的默认值,供选择情况包括的认定为太大或太小的阈值,以及过于接近定义容差值(tolerance value)。
      如果属性标签缺失,可以使用AddValues过滤器为该属性添加给定标签列表。标签能以升序的方式进行排序。如果没有提供标签,则只能选择排序功能。
      AddValues过滤器对照用户提供的列表,并在标称属性中添加其中不存在的值,可以 选择对标签进行排序。ClassAssigner过滤器用于设置或取消数据集的类别属性。用户提供 新的类别属性的索引,索引为0值则取消当前类别属性。
      

      3)转换
      许多过滤器将属性从一种形式转换为另一种形式。Discretize过滤器使用等宽或等频分箱将指定范围的数值属性离敗化。对于等宽分箱方法,可以指定箱数,或使用留一法交叉验证自动选择使似然值最大化。也可以创建多个二元属性,替换一个多元属性。对于等频离散化,可以改变每个分隔期望的实例数置。PKIDiscretize过滤器使用等频分箱离散化数 值属性,箱的数目设置为等于非缺失值数量的平方根。默认情况下,上述两个过滤器都跳过类别属性。
      Makelndicator过滤器将标称属性转换为二元指示符属性,可以用于将多个类别的数据集转换成多个两个类别的数据集。它用二元属性替换所选择的标称属性,其中,如果某个特定的原始值存在,该实例的值为1,否则为0。新厲性默认声明为数值型,但如果需要,也可以声明为标称型。

      对于一些学习方案,如支持向量机,多元标称属性必须被转换成二元属性。 NominalToBinary过滤器能将数据集中的所有指定的多元标称属性转换为二元属性,使用 一种简单的“每值一个”(one-per-value)编码,将每个属性替换为k个二元属性的k个值。 默认情况下,新属性将是数值型,己经是二元属性的将保持不变。NumericToBinary过滤器将除了类别属性外的所有数值属性转换成标称二元属性。如果数值属性的值恰好为0, 新属性值也为0 , 如果属性值缺失,新属性值也缺失,否则,新属性的值将为1。上述过滤器都跳过类别属性。 NumericToNominal过滤器通过简单地増加每一个不同数值到标称值列表,将数值属性转换为标称诚性。该过滤器在导入“.csv”文件之后非常有用,Weka的 CSV导入机制对所有的可解析为数字的数据列都相应创建为数值型属性,但有时将整型属 性的值解释为离散的标称型有可能更为恰当。
      FirstOrder过滤器对一定范围的数值属性应用一阶差分算子。算法为:将N个数值型 属性替换为N-1个数值型属性,其值是原来实例中连续性值之差,即新属性值等于后一个属性值减去前一个属性值。例如,如果原来的属性值分别为3、2、1,则新的属性值将是-1、-1。
      KernelFilter过滤器将数据转换为核矩阵。它输出一个新数据集,包含的实例数量和原 来的一样,新数据集的每个值都是用核函数评估一对原始实例的结果。默认情况下,预处理使用Center过滤器,将所有的值都转换为将中心平移至0,尽管没有重新缩放为单位方差。然而,用户也可以指定用不同的过滤器。
      PrincipalComponents过滤器在数据集上进行主成分转换。将多元标称属性转换为二元属性,用均值替换缺失值,默认将数据标准化。主成分数量通常根据用户指定的捜盖比例的方差确定,俏也可以明确指定主成分数量。


      4) 字符串转换
      字符串属性值的数目不定。StringToNominal过滤器用一组值将其转换为标称型。用户要确保所有要出现的字符串值都会在第一批数据中出现。NominalToString过滤器转换的方向相反。
      StringToWordVector过滤器将字符串属性值转换生成表示单词出现频率的数值属性。 单词集合就是新的属性集,由字符串属性值的完整集合确定。新属性可以采用用户指定的前缀来命名,这样通过名称容易区分来源不同的字符串属性。
      ChangeDateFormat过滤器更改用于解析日期属性的格式化字符串,可以指定Java的SimpleDateFormat类所支持的任意格式。


      5) 时间序列
      Weka提供两种处理时间序列的过滤器。TimeSeriesTranslate过滤器将当前实例的属性值替换为以前(或未来)的实例的等效属性值。TimeSeriesDelta过滤器将当前实例的属性值替换为以前(或未来)的实例的等效属性值与当前值之间的差值。对于时移差值未知的实例,要么删除实例,要么使用缺失值。
      

      6) 随机化
      —些属性过滤器有意降低数据的质萤。AddNoise过滤器按照指定的一定比例更改标称属性的值。可以保留缺失值,也可以让缺失值和其他值一起变化。Obfuscate过滤器对关系属性、全部属性名称,以及所有标称型和字符串型属性值进行重命名,对数据集进行模糊处理,目的主要是为了交换敏感数据集。RandomProjection过滤器通过使用列为单位长度的随机矩阵,将数据投影到一个低维子空间,以此来降低数据维数。投影不包括类别属性。


      2. 无监督实例过滤器
      1)随机化和子采样
      Randomize过滤器用于将数据集中实例顺序进行随机重排。产生的数据子集的方式有很多种。Resample过滤器产生一个有放回或无放回数据集的随机子样本。RemoveFolds过滤器将数据集分割为给定的交叉验证折数,并指定输出第几折。如果提供一个随机数种子,在提取子集前,先对数据重新排序。                ReservoirSample过滤器使用水库抽样算法从数据集中抽取一个随机样本(无放回)。当在知识流界面或命令行界面使用时,可以增量读取数据集,因此可以抽样超出主内存容量的数据集。

         RemovePercentage过滤器删除数据集中的给定亩分比的实例。RemoveRange过滤器删除数据集里给定范围的实例。RemoveWithValues过滤器删除符合条件的实例,如标称属性具有一定值的,或者数值属性人于或小于特定阈值的。默认情况下,会删除所有满足条件 的实例。也可以反向匹配,保留所有满足条件的实例,删除其余实例。
         RemoveFrequentValues过滤器用于删除那些满足某个标称型属性值最经常或最不经常使用的对应的实例。用户可以指定频度多大或多小的具体值。
         SubsetByExpression过滤器选择那些满足用户提供的逻辑表达式的所有实例。表达式可以是数学运算符和函数,如那塑可用于AddExpression和MathExpression过滤器的运算 符和函数,以及应用于属性值的逻辑运算符(与或非)。例如以下表达式:
      (CLASS is 'mammal') and (ATT14 > 2)
      选择那些CLASS属性值为mammal并且第14个属性的值大于2的实例。
      通过将分类方法应用到数据集,然后使用RemoveMisdassified过滤器删除错误分类的实例,可以删除离群值。通常上述过程需要重复多遍,直到充分清洗数据,也可以指定最 大的迭代次数。除了评估训练数据,还可以使用交叉验证,对数值类别也可以指定的错误阈值。

      2)稀疏实例
      NonSparseToSparse过滤器将全部输入实例转换为稀疏格式。SparseToNonSparsc过滤器将输入的所有稀疏实例转换为非稀疏格式。


      3. 有监督属性过滤器
      Discretize过滤器将数据集中一定范围内的数值屈性离散化为标称属性,用户指定属性的范围以及强制属性进行二元离散化。要求类别属性为标称属性,默认的离散化方法楚 Fayyad & Irani的MDL(最小描述长度)判据,也可以使用Kononenko方法。
      NominalToBinary过滤器也有一个有监督版本,将全部标称属性转换成二元的数值属性。在有监督版本中,类别属性是标称型还是数值型,决定如何进行转换。如果是标称型,使用每个值一个属性的方法,将k个值的属性转换成k个二元属性。如果是数值型, 考虑类别平均值与每个属性值的关联,创建k-1个新的二元属性。两种情况都不改变类别 本身。

      ClassOrder过滤器更改类别顺序。用户指定新顺序是否按随机顺序,或按类别频率进行升序或降序排列。该过滤器不能与FilteredClassifier元学习方案联合使用。 AttributeSelection过滤器用于自动属性选择,并提供与探索者界面中Select attributes子面板相同的功能。
      AddClassification过滤器使用指定分类器为数据集添加分类、分类分布和错误标志。 分类器可以通过对数据木身进行训练而得到,也可以通过序列化模型得到。


      4.有监督实例过滤器
      Weka提供三个有监督的实例过滤器。
      Resample过滤器与同名的无监督实例过滤器类似,但它保持在子样本的类别分布。另外,它可以配罝是否使用均匀的分类偏倚,抽样可以设置为有放回(默认)或无放回模式。
      SpreadSubsample过滤器也产生一个随机子样本,但时以控制最稀少和最常见的类别之 间的频率差异。例如,可以指定至多2: 1类别频率差异,也可以通过明确指定某个类别 的敁大计数值,限制实例的数量。
      与无监督的实例过滤器RemoveFolds相似,StratifiedRemoveFolds过滤器为数据集输出指定交叉验证的折,不同之处在于本次的折是分层的。

     

     

     


    5、手把手教你用Weka里的过滤器

    • 1. 使用数据集编辑器
    • 2. 删除属性
    • 3. 添加属性
    • 4. 离散化


      1.使用数据集编辑器
      Weka可以查看和编辑整个数据集。
      首先加载weather.nominal.arff文件,单击预处理而板上端的Edit按钮,弹出一个名称 为Viewer(阅读器)的对话框,列出全部天气数据。该窗口以二维表的形式展现数据,用于 查看和编辑整个数据集,如下图所示。

            图     数据集编辑器对话框


      数据表顶部显示当前数据集的关系名称。表头列出数据集各属性的序号、名称和数据类型。数据集编辑器的第一列是序号,标识实例的编号。

      窗口右下部有三个按钮,Undo按钮撤销所做的修改,不关闭窗口;OK按钮提交所做的修改,关闭窗口;Cancel按钮放弃所做的修改,关闭窗口。

     

     

      2、删除属性

      Weka使用过滤器来系统性地更改数据集,因此过滤器属于预处理工具。

      假如要求去除weather.nominal.arff数据集的第二个属性,即temperature属性。删除属性是具体步骤如下。

      首先,使用探索者界面加载weather.nominal.arff文件。在预处理面板中单击Choose按钮,打开一个分层菜单,如下图所示。

                   图      过滤器分层菜单图

      适合本例要求的过滤器称为Remove,全称是weka.filters.unsupervised.attribme.Remove。从名称上可以看出,过滤器组织成层次结构,根为weka,往下继续分为 imsupervised(无监督)和suervised(有监督)两种类型,无监督要求设置类别属性,有监督不要求设置类别属性。继续往下分为attribute(属性)和instance(实例)两种类型,前者主要处理有关属性的过滤,后者处理有关实例的过滤。
      在分层菜单中按照weka\ filters \ unsupervised \attribute路径,找到Remove条目,单击选择该过滤器。这时,Choose按钮右边的文本输入框应该显示Remove字符串。单击该文本框,打开通用对象编辑器对话框以设置参数。

     


      在attributelndices文本框内输入“2”,如下图所示。单击OK按钮关闭通用对象编辑器对话框。

     

      这时,Choose按钮右边的文本框应该显示“Remove -R 2”,含义是从数据集中去除第二个属性。单击该文本框右边的Applly按钮使过滤器生效据。

     

     

      应该看到原来的5个属性现在变为4个,temperature属性己经被去除。要特别说明的是,本操作只影响内存中的数据,不会影响数据集文件中的内容。

     

     

      当然,变更后的数据集也可以通过单击Save 按钮并输入文件名另存为ARFF格式或其他格式的新文件。如果要撤消过滤操作,请单击 Undo按钮,撤消操作也只会影响内存中的数。

     

     

      如果仅需要去除属性,还有更简单并且效果一样的方法。只要在Attributes子面板内选择要去除的属性,然后单击属性列表下面的Remove按钮即可。

     

     

      

     

     

      3、添加属性

      启动探索者界面并加载weaather.nominal.arff数据集。假如要求在数据集倒数第二个属性位置添加一个用户定义的字段,具体操作步骤如下:

      在预处理面板上单击Choose按钮,选择AddUserFields过滤器。然后单击Choose按钮旁的方框,在通用对象编辑器设置AddUserFields过滤器。

     

     

     

       然后单击Choose按钮旁的方框,在通用对象编辑器中设置AddUserFields过滤器的选项。

     

     

     

      单击New按钮,然后设置Attribute name(属性名称)为mode,设置Attribute type(属性类型)为nominal,不设置Date format(日期格式)和Attribute value(属性值)两个字段,如下图所示。

     

     

     

       单击OK按钮结束选项设置,并在预处理面板上单击Apply按钮应用过滤器。这时,应该看到Attributes子面板的属性表格中看到多出来一个mode属性

     

     

     

      如果单击Edit按钮打开viewer窗口,可以看到新增的属性并没有值,因此,下一步是添加标称属性值。

     

     

     

      再次,单击Choose按钮,选择AddValues过滤器,按照下图所示设置标称属性的标签。

     

     

     

     

     

     

       再次单击Edit按钮打开Viewer对话框,如下图所示。可以看到,这次的最后一个属性已经有了标称属性标签,可以随意设置一些值,然后单击OK按钮关闭对话框。

     

     

     

     

     

     

     

       注意:我们新增属性的位置,不符合要求的倒数第二个属性位置。最后一个属性一般是类别属性,需要把第五个属性与第六个属性对换一下,则,该怎么对换呢?得用到Recorder过滤器,参数为"-R 1,2,3,4,6,5”。

     

      我们只需,输入1,2,3,4,6,5即可。然后点击OK

     

      再点击Apply 

     

       再点击Edit按钮打开Viewer对话框去看看

     

     

     

     

      4.离散化

      如果数据集包含数值属性,但所的学习方案只能处理标称型属性的分类问题,先将数值属性进行离散化是必要的,这样就能使学习方案增加处理数值属性的能力,通常能获 得较好的效果。

      有两种类型的离散化技术------无监督离散化和有监督离散化,无监督离散化不需要也不关注类别属性值,有监督离散化在创建间隔时考虑实例的分类属性值。离散化数值属性的直观方法是将值域分隔为多个预先设定的间隔区间。显然,如果分隔级别过大,将会混淆学习阶段可能有用的差别;如果分级算法不妥,则会将很多不同类别的实例混合在一起影响学习。Weka 无监督离散化数值属性的 Java 类是 weka.filters.unsupervised.attribute.Discretize,它实现了等宽(默认)和等频两种离散化方法。

      等宽离散化(或称为等宽分箱)经常造成实例分布不均匀,有的间隔区域内(箱内)包含很多个实例,但有的却很少甚至没有。这样会降低属性辅助构建较好决策结果的能力。通常也允许不同大小的间隔区域存在,从而使每个区间内的训练实例数量相等,这样的效果会好一些,该方法称为等频离散化(或称为等频分箱),其方法是:根据数轴上实例样木的分布将属性区间分隔为预先设定数量的区间。如果观察结果区间的直方图,会发现其形状平直。等频分箱与朴素贝叶斯学习方案一起应用时效果较好。但是,等频分箱也没有注意实例的类别属性,仍有可能导致不好的区间划分。例如,如果一个区域内的全部实例都属于—个类别,而下一个区域内除了第一个实例外都属于前一个类别,其余的实例都属于另一 个类别,那么,显然将第一个实例包含到前一个区域更为合理。

     

     

     

     无监督离散化

      下面以实例说明这两种方法的差异。首先,在data目录中查找到玻璃数据集glass.arf文件,并将它加载至探索者界面,在预处理面板中杳看RI属性直方图,如下图所示。

     

     

     

     

         实施无监督离散化过滤器,分别使用等宽等频两种离散化方法,即首先保持Discretize的全部选项默认值不变,然后将useEqualFrequency选项的值更改为True。得到离散化后对应的RI属性直方图分别如下图所示。

     

     

     

     

     

     

     

     

     

     

      以下是等频离散化后的RI属性(将useEqualFrequency选项的值更改为True)

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

      

     

       以下是等宽离散化后的RI属性(将useEqualFrequency选项的值更改为true,再次开启就可以了)

     

     

     

       

          等宽离散化后的RI属性                        等频离散化后的RI属性 

     

      等宽离散化数值属性从最小值到最大值之间平均分为十份,因此每一份所包含的实例数量就各不相等;而等频离散化按数值属性的大小顺序将全部实例平均分为十份,每份所包含是实例数量为21~22。

       大家,也许会形成一个错觉,等频离散化后形成的直方图似乎都会等高。但是,如果等频离散化Ba属性,再检查结果,会发现这些直方图严重地偏向一端,也就是根本不等频。

     

      这是为什么呢?仔细观察第一个直方图的标签,其值为(-inf-0.03】,即区间大于负无穷且小于等于0.03。使用数据集编辑器打开离散化前的原始数据集,单击第八列表头,使数据集按照Ba属性进行排序,可以看到,有176个实例的Ba属性值都等于0.0。由于这些值都完全相同,没有办法将它们分开。这就是为什么,上图严重地偏向一端的根本原因。

     

     

      总结:一般情况下,等频离散化后直方图大致等高。但如果有很多实例的值都完全相同,则等频离散化也没法做到“等频”。

     

     

    有监督离散化

       有监督的离散化竭力去构建一种间隔,虽然各个间隔之间的分类分布各不相同,但间隔内的分布保持一致。Weka有监督的离散化数值属性的java类的全路径名称为weka.filters.supervised.Discretize。首先,定位到data目录下的鸢尾花数据集,加载iris.arff文件,施加有监督的离散化方案,观察得到的直方图如下图所示。

     

                       有监督离散化后的直方图

      

      那么,上图中哪一个经过离散化后的属性最具有预测能力?
      显然,只有petallength(花瓣长)和petalwidth(花瓣宽)最具竞争力,因为它们的每种分类都已经接近为同一种颜色。

      再经仔细对比发现在前者中,有1个virginica实例错分到versicolor中,有6个实例versicolor错分到virginica中,因此共有7个错分的实例;

      而后者,只有5个virginica实例错分到versicolor中,有1个versicolor实例错分到virginica 中,因此共有6个错分的实例。

      从而得出结论:离散化后的petalwidth属性最具有预测能力。

      通常将离散化后的属性编码为标称属性,每一个范围给定一个值。然而,因为范围是 有序的,离散化后的属性实际上是一个有序标量。
    除了创建多元属性外,有监督和无监督两种离散化过滤器都能创建二元属性,只要将选项makeBinary设置为True即可。下图就是有监督的离散化方案创建二元属性后得到。

     

     

     

     

     

     

     

                         有监督二元离散化后的直方图

     

     

     

     

     

    分类

      分类就是得到一个分类函数或分类模型(即分类器),通过分类器将未知类别的数据对象映射到某一个给定的类别。

      数据分类可以分为两步。第一步建立模型,通过分析属性描述的数据集,来建立反映其特性的模型。该步骤也称为有监督的学习,基于训练集而导出模型,训练集是已知类别标签的数据对象。第二步使用模型对数据对象进行分类。首先评估模型的分类准确度或其他指标,如果可以接受,才使用它来对未知类别标签的对象进行分类。

      预测的目的是从历史数据记录中自动推导出对给定数据的推广描述,从而能够对事先未知类别的数据进行预测。分类和回归是两类主要的预测问题,分类是预测离散的值,回归的预测连续值。

      Weka提供分类面板来构建分类器。如下图所示。

     

     

     

     

     

      在分类面板的最上部是Classifier(分类器)子面板,子面板内有一个Choose按钮和一个文本框。按钮用于选择Weka提供的分类器;文本框用于显示当前选择的分类器的名称和选项。单击文本框会弹出一个通用对象编辑器对话框,与过滤器的对象编辑器对话框的功 能一样,可以用来设置当前分类器的选项。右击(或用Alt + ShifH单击)分类器文本输入框,就会弹出一个菜单,选择菜单项可以让用户修改设置,或将当前设置的字符串复制到剪贴板,或直接输入设置字符串,使用方法与过滤器的相似。

     

     

     

      在分类面板的左部有Test options(测试选项)子面板。该子面板是为了设置测试模式, 将设置的选项应用到当前选择的分类器中。测试模式分为以下四种。

      (1) Use training set(使用训练集)。直接将训练集实例用于测试,评估分类器预测类别的性能。
      (2) Supplied test set(提供测试集)。从一个文件中加载一组实例,评估分类器预测类别的性能。单击Set按钮会弹出一个对话框,允许用户选择进行测试的文件。
      (3) Cross-validation(交叉验证)。通过交叉验证评价分类器,在提示为Folds的文本框中输入交叉验证的折数。
      (4) Percentage split(按比例分割)。在数据集中,取出特定百分比的数据用于训练,其 余的数据用于测试,评价分类器预测分类的性能。取出的数据量取决于用户在“%”文本 框中输入的值。

     

     

     


      无论使用哪种测试模式作为评估方法,输出模型始终从全部训练数据构建而得。更多的测试选项可以通过单击More options按钮进行设置,如下图所示。

            图    更多测试选项

     

     

    更多的测试选项解释如下
      (1) Output model(输出模型)。输出通过完整训练集得到的分类模型,以便能够浏览、 可视化等。默认选择此选项。

      (2) Output per-class stats(输出每个类别的统计信息)。输出每个分类的査准率/查全率以 及True/False的统计信息。默认选择此选项。 
      (3) Output entropy evaluation measures(输出熵评估度量)。输出中包括熵评估度量。默认不选择此选项。

      (4) Output confusion matrix(输出混渚矩阵)。输出中包含分类器预测得到的混淆矩阵。 各默认选择此选项。 
      (5) Store predictions for visualization(存储预测以便可视化)。保存分类器的预测结果,以便用于可视化。默认选择此选项。

      (6) Output predictions(输出预测)。输出预测的评估数据。请注意,在交叉验证的情况 下,实例序号不对应于其在数据集中的位置。
      (7) Output additional attributes(输出额外的属性)。如果伴随预测还需要输出额外的属性 (如,跟踪错误分类的1D属性),可以在这里指定该属性的索引。Weka通常支持指定范 围,first和last也是有效的索引,例如:“first-3,6,8,12-last”。
      (8) Cost-sensitive evaluation(成本敏感评估成本矩阵用于评估错误率。Set按钮允许 用户指定所使用的成本矩阵。
      (9) Random seed for XVal / % Split(XVal / %分割的随机种子)。为了评估目的而划分数 据之前,指定将数据进行随机化处理的随机种子。
      (10) Preserve order for % Split(保持顺序按百分比分割)。将数据划分为训练集和测试集 之前禁止随机化,即保持原来的顺序。
      (11) Output source code(输出源代码)。如果分类器能够输出所构建模型的Java源代 码,可以在这里指定类名D可以在Classifier output(分类器输出)区域打印代码。

      在Weka中,进行训练后的分类器用于预测某个单一的类别属性,这就是预测的目标。一些分类器只能学习标称型类别的分类(分类问题),一些分类器只能学习数值型类别的分类(回归问题),还有一些分类器能学习两者。
      默认情况下,数据集的最后一个属性是类别属性。如果想训练分类器来预测其他属性,单击Test options子面板下面的下拉列表框,选择其他属性作为类别属性。

     


    2、分类器训练
      设置好分类器、测试选项和分类属性后,单击Start按钮就启动学习过程。在Weka忙于训练分类器的同时,小鸟会站起来左右走动。用户随时可以单击Stop按钮终止训练过程。
      训练结束后,右侧的分类器输出区域会显示训练和测试结果的文字描述,如下图所示。同时,在Result list(结果列表)中会出现一个新条目,后文再谈结果列表,先仔细分析分类器输出的文字描述。

     

     

     

     

     

     

    3、分类器输出

      拖动Classifier output区域右侧的滚动条,可以浏览全部结果文本。在文本区域中按住Alt键和Shift键的同时单击,会弹出一个对话框,可以以各种不同的格式(目前支持BMP、JPEG、PNG和EPS)保存所显示的输出。当然,也可以调整探索者界面的大小,得到更大的显示面积。

      输出分为以下几个部分。
      (1) Run information(运行信息):提供处理过程所涉及的信息列表,如学习方案及选项(Scheme)、关系名(Relation)、实例(Instances)、属性(Attributes)和测试模式(Test mode)。
      (2) Classifier model(full training set)(分类器模型(完整的训练集)):完整训练数据生成的分类模型的文字表述。本例选择J48决策树构建分类模型,因此以文字方式描述决策树。如果选择其他分类器模型,则显示相应的文字表述。

      (3) 根据所选择的测试模式,显示不同文字。例如,如果选择十折交叉验证,显示Stratified cross-validation;如果选择使用训练集,显示Classifier model (full training set),等等。由于评估内容较多,将结果分解显示如下。

      ①Summary(总结)。一个统计列表,根据所选抒的测试模式,总结分类器在预测实例真实分类的准确度,其中:
        • Comictly Classified Instances(正确分类的实例):显示正确分类的实例的绝对数里和百分比。
        • Incorrectly Classified Instances(错误分类的实例):显示错误分类的实例的绝对数和百分比。
        • Kappa statistic(kappa 统计):显示示kappa 统计量,[0,1]范围的小数。kappa 统计指标用于评判分类器的分类结果与随机分类的差异度。k=1表明分类器完全与随机分类相异,K=0表明分类器与随机分类相同(即分类器没有效果),K= -1表明分类 器比随机分类还要差。一般来说,Kappa统汁指标的结果是与分类器的AUC指 标以及准确率成正相关的,所以该伉越接近1越好。
        • Mean absolute errror(平均绝对误差):品示平均绝对误差,[0,1]范围的小数。
        • Root mean squared error(均方根设差}:显示均方根误差,[0,1]范围的小数。
        • Relative absolute enor(相对绝对误差):显示相对绝对误整,百分数。
        • Root relative squared error(相对均方根误差):显示相对均方根误差,百分数。
        • Coverage of cases (0.95 levelX)(案例的覆盖度):显示案例的覆盖度,该值是分类器使用分类规则对全部实例的薄盖度,百分数越高说明该规则越有效。
        • Mean rel. region size (0.95 level)(平均相对区域大小):显示平均相对区域大小, 百分数。
        • Total Number of Instances(实例总数):品示实例总数。
      ②Dctai丨ed Accuracy By Class(按类别的详细准确性)。按每个类别分解的更详细的分类器的预测精确度。结果以表格形式输出,其中,表格列的含义如下,
        • TP Rate(离阳性率):显示真阳性率,[0J]范IS的小数。
        • FP Rate(假阳性率):51示假阳性率.队丨]范围的小数。另外,常使用TN相FN 分别代衣具阴性率和假阴性率。
     

     

     

     

     

     

    4、分类算法介绍

      分类和回归是数据挖掘和机器学习中极为重要的技术,其中分类是指利用已知的观测数据构建一个分类模型,常常称为分类器,来预测未知类别的对象的所属类别。分类和回归的不同点在于,分类的预测输出是离散型类别值,而回归的预测输出是连续型数值。因此,Weka将分类和回归都归为同一类算法。
      本博客介绍常用的分类算法,包括线性回归、决策树、决策规则、支持向量机,将贝叶斯网络和神经网络放到后面博客书写。由于Weka实现的分类算法数量众多,特点各异,无法在较短篇幅中讲清楚,大家可根据自己的需要查阅附录介绍和相关资料。

     

     

    1. 线形回归

      线性回归(linear regression)是利用数理统计中的回归分析,来确定多个变量之间相互依赖的定量关系的一种统计分析方法,应用十分广泛。具体来说,它利用称为线性回归方程的最小二乘函数对一个或多个自变量(常表示为x)和一个标量型因变量(常表示为y)之间的关系进行建模,这种函数是一个或多个称为回归系数的模型参数的线性组合。只涉及一个自变量的称为简单线性回归,涉及多个自变量的称为多元线性回归。
      线性回归的主要目标是用于预测。线性回归使用观测数据集的y值和x值来拟合一个预测模型,构建这样一个模型后,如果给出一个新的x值,但没有给出对应的y值,这时就可以用预测模型来预测y值。

     

     

     

     

     

     

     2. 决策树

      决策树(decision tree)是一种预测模型,它包括决策节点、分支和叶节点三个部分。其中,决策节点代表一个测试,通常代表待分类样本的某个属性,在该属性上的不同测试结果代表一个分支,分支表示某个决策节点的不同取值。每个叶节点存放某个类别标签,表示一种可能的分类结果,括号内的数字表示到达该叶节点的实例数。
      使用训练集用决策树算法进行训练,经过训练之后,学习方案只需要保存类似于如下图的树形结构,而不像最近邻学习等消极学习算法那样,不保存模型,只有在需要分类时才去查找与测试样本最为相近的训练样本。决策树对未知样本的分类过程是,自决策树根节点开始,自上向下沿某个分支向下搜索,直到到达叶节点,叶节点的类别标签就是该未知样本的类别。

      对于下图所示的决策树,假如有一个新的未知样本,属性值如下:

     

     

     

     

     

     

     

     

     

     3. 基于规则的分类器

     

     

     

     

     

     

    4. 基于实例的算法

      基于决策树的分类框架包括两个步骤:第一步是归纳步,由训练数据构建分类模型;第二步是演绎步,将模型应用于测试样本。前文所述的决策树和基于规则的分类器都是先对训练数据进行学习,得到分类模型,然后对未知数据进行分类,这类方法通常称为积极学习器(eager learner)。与之相反的策略是推迟对训练数据的建模,直到需要对未知样本进行分类时才进行建模,采用这种策略的分类器称为消极学习器(lazy learner)。消极学习器的典型代表是最近邻方法,其途径是找出与测试样本相对接近的所有训练样本,这些训练样本称为最近邻(Nearest Neighbor,NN),然后使用最近邻的类别标签来确定测试样本的类别。

     

     

     

     

     5. 支持向量机

      支持向量机(Support Vector Machine,SVM)分类器是一种有监督学习的方法,广泛地应用于统计分类以及回归分析。SVM的特点是能够同时最小化经验误差与最大化几何边缘。因此,支持向量机也被称为最大边缘分类器。
      支持向量机技术具有坚实的统计学理论基础,并在实践上有诸多成功示例。SVM可以很好地用于高维数据,避免维数灾难。它有一个独特的特点,就是使用训练实例的一个子集来表示决策边界,该子集称为支持向量,这就是其名称的来历。

     

     

     

     

     

     

     

     

    6. 集成学习

      集成学习(ensemble learning)就是通过聚集多个分类器的预测结果来提高分类准确率。集成方法由训练数据构建一组基分类器(base classifier),然后通过每个基分类器的预测的投票来进行分类。一般来说,集成分类器的性能要好于任意的单个分类器,因为集体决策在全面可靠性和准确度上优于个体决策。

     

     

     

     

     

     

     

     

    5 分类模型评估

      1. 定性评估标准
      一般来说,分类模型有如下评估标准。
      (1) 预测的准确率:模型正确地预测新的或先前没见过的样本的类别标签能力。
      (2) 速度:产生和使用模型的计算开销。
      (3) 强壮性:对于有噪声或具有缺失值的样本,模型能正确预测的能力。
      (4) 可伸缩性:给定很大的数据集,能有效地构造模型的能力。
      (5) 可解释性:学习模型提供的理解和解释的层次。

     

      预测的准确率常用于比较和评估分类器的性能,它将每个类别看成同等重要,因此可能不适合用来分析不平衡数据集。在不平衡数据集中,稀有类别比多数类别更有意义。也就是说,需要考虑错误决策、错误分类的代价问题。例如,在银行贷款决策中,贷款给违规者的代价远远比由于拒绝贷款给不违规者而造成生意损失的代价大得多;在诊断问题中,将实际没有问题的机器误诊为有问题而产生的代价比因没有诊断出问题而导致机器损坏而产生的代价小得多。

     

     

     

     

     

     

     

     

    手把手教你使用Weka的分类器(完整) 

    • 1. 使用C4. 5分类器
    • 2. 使用分类器预测未知数据
    • 3. 使用决策规则
    • 4. 使用线性回归
    • 5. 使用用户分类器
    • 6. 使用支持向量机
    • 7. 使用元学习器
    • 8. 深入研究离散化
    • 9. 初识最近邻分类器
    • 10. 分类噪声与最近邻学习
    • 11. 研究改变训练集大小的影响

     

     

     

     

    1、使用C4.5分类器(名称为J48)

      本例使用C4.5分类器对天气数据集进行分类

      首先加载天气数据集,操作步骤为:启动探索者窗口,在预处理面板中单击Open file按钮,选择并打开data目录中的weather.nominal.arff文件,然后,单击Classify标签页切换到Classify面板。

     

     

     

       从上面的学习中,我们可以自动,构建决策树的C4.5算法在Weka中是作为一个分类器来实现,名称为J48。单击Classfiy面板上部的Choose按钮,会出现一个对话框,显示不同类型的分类器。单击tress条目以展开其子条目,然后单击J48选择该分类器。与过滤器一样,分类器也按层次进行组织,J48的全名为weka.classifiers.tress.J48。

     

     

     

      在Choose按钮旁边的文本框内,可以看到当前分类器及选项:J48 -C 0.25 -M 2。这是此分类器默认的参数设置。对于J48分类器,很少需要为获得良好的性能而更改这些参数。

     

     

       为了便于说明,使用训练数据进行性能评估,训练数据在预处理面板就已经完成加载。使用训练数据进行评估并不是一个好方法,是因为它导致盲目乐观的性能估计。从分类面板中Test options(测试选项)部分,选择Use training set(使用训练集)选项,以确定测试策略。做好上述的准备之后,可以单击Start(开始)按钮,启动分类器的构建和评估,使用当前选择的学习算法----J48,通过训练集构建J48分类器模型。然后,使用构建的模型对训练数据的所有实例进行分类以评估性能,并输出性能统计信息,如下图所示。

     

    === Run information ===
    
    Scheme:       weka.classifiers.trees.J48 -C 0.25 -M 2
    Relation:     weather.symbolic
    Instances:    14
    Attributes:   5
                  outlook
                  temperature
                  humidity
                  windy
                  play
    Test mode:    evaluate on training data
    
    === Classifier model (full training set) ===
    
    J48 pruned tree
    ------------------
    
    outlook = sunny
    |   humidity = high: no (3.0)
    |   humidity = normal: yes (2.0)
    outlook = overcast: yes (4.0)
    outlook = rainy
    |   windy = TRUE: no (2.0)
    |   windy = FALSE: yes (3.0)
    
    Number of Leaves  :     5
    
    Size of the tree :     8
    
    
    Time taken to build model: 0.03 seconds
    
    === Evaluation on training set ===
    
    Time taken to test model on training data: 0.02 seconds
    
    === Summary ===
    
    Correctly Classified Instances          14              100      %
    Incorrectly Classified Instances         0                0      %
    Kappa statistic                          1     
    Mean absolute error                      0     
    Root mean squared error                  0     
    Relative absolute error                  0      %
    Root relative squared error              0      %
    Coverage of cases (0.95 level)         100      %
    Mean rel. region size (0.95 level)      50      %
    Total Number of Instances               14     
    
    === Detailed Accuracy By Class ===
    
                     TP Rate  FP Rate  Precision  Recall   F-Measure  MCC      ROC Area  PRC Area  Class
                     1.000    0.000    1.000      1.000    1.000      1.000    1.000     1.000     yes
                     1.000    0.000    1.000      1.000    1.000      1.000    1.000     1.000     no
    Weighted Avg.    1.000    0.000    1.000      1.000    1.000      1.000    1.000     1.000     
    
    === Confusion Matrix ===
    
     a b   <-- classified as
     9 0 | a = yes
     0 5 | b = no

     

     

     

     

       训练和测试结果会以文本方式显示在窗口右侧的Classifier Output(分类器输出)框中。大家可以拖动右边的滚动条以检查这些文字信息。首先看决策树的描述部分,其信息重新摘录如下图所示。

     

    J48 pruned tree
    ------------------
    
    outlook = sunny
    |   humidity = high: no (3.0)
    |   humidity = normal: yes (2.0)
    outlook = overcast: yes (4.0)
    outlook = rainy
    |   windy = TRUE: no (2.0)
    |   windy = FALSE: yes (3.0)
    
    Number of Leaves  :     5
    
    Size of the tree :     8

       上述文字表述构建的J48(就是决策树的) 剪枝决策树,包括决策支点、分支和叶节点,决策节点用一个测试表示,分支用 “|” 加上缩进表示,叶节点后面有一个括号,括号内的数字代表到达该叶节点的实例数量。当然,采用文字对模型进行表述十分笨拙且难以理解,因此Weka也能生成等效的图形表示。

     

       按照上述的方法,如果更改数据集或调整选项,每次单击Start按钮,都会构建和评估一个新的分类器模型,在如下图所示窗口的左下角的Result List(结果列表)面板上就会相应添加一条新条目。

     

        可以按照如下方法得到图形化表示的决策树。右击刚刚被添加到结果列表中的"tree.J48”条目,并在弹出菜单中选择 Visualize tree(可视化树)菜单项,会弹出一个如下图所示的决策树窗口。

     

     

       该决策树视图可以自动缩放和平移,可以通过选择鼠标右击空白处带出的上下文菜单中的菜单项,实现自动缩放;可以通过拖动鼠标实现视图平移。

     

     

     

     

     

     

     

       大家要知道。如下两幅图表示的信息,是一致的。其中,叶节点中用括号引起的数字表示到达该节点的实例数量。另外,决策树的文字描述图还包含两条额外信息 :Number of Leaves(叶子数量)表示叶子节点的数量,Size of the tree(树大小)表示树中全部节点的数量。

     

     

       

       决策树的文字描述图                        构建的决策树

     

      这段文字描述了正确分类的测试实例有多少条,占多大比例。它表示使用数据进行测试模型的准确性。本例中,准确性高达100%,表示完全正确,不用惊奇,这是把训练集 用于测试的条件下经常发生的事。
      分类器输出的最后一项是一个如下所示的混淆矩阵:

      矩阵中的每一个元素是实例的计数值。行表示真实类别,列表示预测类别。大家可以看到,全部9个真实类别为yes的实例都己预测为yes,全部5个真实类别为no的实例都己预测为no。只有主对角线上的数值很大,而非主对角线上的数值都为0时,表明预测完全正确。

      以上是使用训练集作为J48算法测试策略得到的训练结果,当然,还可以选择使用其他的测试策略。单击Start按钮启动所选学习算法的运行,使用预处理面板中加戟的数据集和所选择 的测试策略。例如,如果使用十折交叉验证,需要运行10次学习算法,以构建和评估10 个分类器。要注意的是,打印到分类器输出区域的分类器模型是由完整的训练集构建的, 这可能是最后一次运行学习算法得到的结果。

     

     

     

     


      现在加载iris数据集,还是使用J48分类器进行学习。首先选择使用Use training set 测试选项,再做一个选择使用Cross-validation 10折测试选项,分别训练并评估J48分类器,运行结果如下表所示。

     

       

      先来使用Use training set 测试选项,训练并评估J48分类器

    === Run information ===
    
    Scheme:       weka.classifiers.rules.ZeroR 
    Relation:     iris
    Instances:    150
    Attributes:   5
                  sepallength
                  sepalwidth
                  petallength
                  petalwidth
                  class
    Test mode:    evaluate on training data
    
    === Classifier model (full training set) ===
    
    ZeroR predicts class value: Iris-setosa
    
    Time taken to build model: 0.11 seconds
    
    === Evaluation on training set ===
    
    Time taken to test model on training data: 0.05 seconds
    
    === Summary ===
    
    Correctly Classified Instances          50               33.3333 %
    Incorrectly Classified Instances       100               66.6667 %
    Kappa statistic                          0     
    Mean absolute error                      0.4444
    Root mean squared error                  0.4714
    Relative absolute error                100      %
    Root relative squared error            100      %
    Coverage of cases (0.95 level)         100      %
    Mean rel. region size (0.95 level)     100      %
    Total Number of Instances              150     
    
    === Detailed Accuracy By Class ===
    
                     TP Rate  FP Rate  Precision  Recall   F-Measure  MCC      ROC Area  PRC Area  Class
                     1.000    1.000    0.333      0.333    0.333      0.000    0.500     0.333     Iris-setosa
                     0.000    0.000    0.000      0.000    0.000      0.000    0.500     0.333     Iris-versicolor
                     0.000    0.000    0.000      0.000    0.000      0.000    0.500     0.333     Iris-virginica
    Weighted Avg.    0.333    0.333    0.111      0.333    0.167      0.000    0.500     0.333     
    
    === Confusion Matrix ===
    
      a  b  c   <-- classified as
     50  0  0 |  a = Iris-setosa
     50  0  0 |  b = Iris-versicolor
     50  0  0 |  c = Iris-virginica

     

     

     

     

        再来,使用Cross-validation 10折测试选项,来训练并评估J48分类器

     

    === Run information ===
    
    Scheme:       weka.classifiers.rules.ZeroR 
    Relation:     iris
    Instances:    150
    Attributes:   5
                  sepallength
                  sepalwidth
                  petallength
                  petalwidth
                  class
    Test mode:    10-fold cross-validation
    
    === Classifier model (full training set) ===
    
    ZeroR predicts class value: Iris-setosa
    
    Time taken to build model: 0 seconds
    
    === Stratified cross-validation ===
    === Summary ===
    
    Correctly Classified Instances          50               33.3333 %
    Incorrectly Classified Instances       100               66.6667 %
    Kappa statistic                          0     
    Mean absolute error                      0.4444
    Root mean squared error                  0.4714
    Relative absolute error                100      %
    Root relative squared error            100      %
    Coverage of cases (0.95 level)         100      %
    Mean rel. region size (0.95 level)     100      %
    Total Number of Instances              150     
    
    === Detailed Accuracy By Class ===
    
                     TP Rate  FP Rate  Precision  Recall   F-Measure  MCC      ROC Area  PRC Area  Class
                     1.000    1.000    0.333      0.333    0.333      0.000    0.500     0.333     Iris-setosa
                     0.000    0.000    0.000      0.000    0.000      0.000    0.500     0.333     Iris-versicolor
                     0.000    0.000    0.000      0.000    0.000      0.000    0.500     0.333     Iris-virginica
    Weighted Avg.    0.333    0.333    0.111      0.333    0.167      0.000    0.500     0.333     
    
    === Confusion Matrix ===
    
      a  b  c   <-- classified as
     50  0  0 |  a = Iris-setosa
     50  0  0 |  b = Iris-versicolor
     50  0  0 |  c = Iris-virginica

     

     

      从上表的数据可以看到,使用训练集的正确分类所占的比例较高,达到98%。但由于是直接将训练集用于测试,因此结论并不可靠。相反,十折交叉验证将数据集分为10 等份,将其中的1份用于测试,另外9份用于训练,如此依次进行10次训练和评估,显然得到的结论要可靠一些。

     

     

     


      最后,检查一下分类错误的可视化表示。右击结果列表中的trees.J48条目,然后从上下文菜单中选择Visualize classifier errors(可视化分类错误)菜单项。会弹出一个散点图窗口,正确分类的实例标记为小十字,不正确的分类实例标记为小空心方块,如下图所示。

      注意:这里是接着上面的iris.arff文件来的。

       横坐标表示真实的类别,纵坐标表示预测的类别。请注意,不要为表而现象迷惑,一个小十字并不一定只代表一个实例,一个小空心方块有时也并不仅仅代表一个 错分的实例。如果想看到底有几个实例错分,可以拉动Jitter滑条,会错开一些相互叠加 的实例,便于看清楚到底有多少个错分的实例。另一种办法是单击小空心方块,就会弹出 如下图所示的实例信息,显示每个实例的各属性值以及预测类别和真实类别。

     

     

     

     

     

       

     

     

     

    2、使用分类器预测未知数据

      还是使用J48分类器对天气数据集进行训练,得到如下图所示的决策树。

      现在构建一个测试数据集,用任意的文本编辑器,编辑如下内容:

     

      将测试数据集保存为weather.nominal.test.arff文件。

     

      然后,在探索者分类面板的Test options子面板下,选择Supplied test set作为测试策略,单击后面的Set按钮,打开测试实例对话框,如图2.52所示。单击对话框里的Open file按钮,打开刚才保存的测试数据集weather.nominal.test.arff文件,单击Close按钮关闭 对话框。

     

     

     


      然后,单击Test options子面板下部的More option按钮,打开如下图所示的分类器评估选项对话框,单击对话框中部的Choose按钮,选择PlainText选项,该选项使分类器 的输出中包含预测信息,单击0K按钮关闭对话框。

     

     

     

     

     

     

     

      现在,一切准备就绪了。单击start按钮,启动分类器训练和评估过程,像以前一样。探索者在分类器输出区域输出性能统计信息。仔细查看,会返现多了如下一项测试集的预测结果,表明测试集仅有一个实例,预测值和实际值都为yes,预测没有错误。

     

    === Run information ===
    
    Scheme:       weka.classifiers.misc.InputMappedClassifier -I -trim -W weka.classifiers.rules.ZeroR
    Relation:     iris
    Instances:    150
    Attributes:   5
                  sepallength
                  sepalwidth
                  petallength
                  petalwidth
                  class
    Test mode:    user supplied test set:  size unknown (reading incrementally)
    
    === Classifier model (full training set) ===
    
    InputMappedClassifier:
    
    ZeroR predicts class value: Iris-setosa
    Attribute mappings:
    
    Model attributes               Incoming attributes
    -----------------------        ----------------
    (numeric) sepallength      --> - missing (no match)
    (numeric) sepalwidth       --> - missing (no match)
    (numeric) petallength      --> - missing (no match)
    (numeric) petalwidth       --> - missing (no match)
    (nominal) class            --> - missing (no match)
    
    
    Time taken to build model: 0 seconds
    
    === Predictions on test set ===
    
     inst#     actual  predicted error prediction
         1      1:yes      1:yes       0.333 
    
    === Evaluation on test set ===
    
    Time taken to test model on supplied test set: 0 seconds
    
    === Summary ===
    
    Correctly Classified Instances           1              100      %
    Incorrectly Classified Instances         0                0      %
    Kappa statistic                          1     
    Mean absolute error                      0.4444
    Root mean squared error                  0.4714
    Relative absolute error                100      %
    Root relative squared error            100      %
    Coverage of cases (0.95 level)         100      %
    Mean rel. region size (0.95 level)     100      %
    Total Number of Instances                1     
    
    === Detailed Accuracy By Class ===
    
                     TP Rate  FP Rate  Precision  Recall   F-Measure  MCC      ROC Area  PRC Area  Class
                     1.000    0.000    1.000      1.000    1.000      0.000    ?         1.000     Iris-setosa
                     0.000    0.000    0.000      0.000    0.000      0.000    ?         ?         Iris-versicolor
                     0.000    0.000    0.000      0.000    0.000      0.000    ?         ?         Iris-virginica
    Weighted Avg.    1.000    0.000    1.000      1.000    1.000      0.000    0.000     1.000     
    
    === Confusion Matrix ===
    
     a b c   <-- classified as
     1 0 0 | a = Iris-setosa
     0 0 0 | b = Iris-versicolor
     0 0 0 | c = Iris-virginica

     

     

     

    3、使用决策规则

      本示例使用决策规则训练天气数据集,并评估分类器性能。

      首先启动探索者界面,在预处理面板中加载weather.nominal.arff数据文件。切换至分类面板,单击Classifier子面板下的Choose按钮,选择rules条目下的JRip分类器,保持默认参数不变,单击Start按钮启动训练,训练结果如下所示。

     

    === Run information ===
    
    Scheme:       weka.classifiers.rules.JRip -F 3 -N 2.0 -O 2 -S 1
    Relation:     weather.symbolic
    Instances:    14
    Attributes:   5
                  outlook
                  temperature
                  humidity
                  windy
                  play
    Test mode:    10-fold cross-validation
    
    === Classifier model (full training set) ===
    
    JRIP rules:
    ===========
    
    (humidity = high) and (outlook = sunny) => play=no (3.0/0.0)
    (outlook = rainy) and (windy = TRUE) => play=no (2.0/0.0)
     => play=yes (9.0/0.0)
    
    Number of Rules : 3
    
    
    Time taken to build model: 0.01 seconds
    
    === Stratified cross-validation ===
    === Summary ===
    
    Correctly Classified Instances           9               64.2857 %
    Incorrectly Classified Instances         5               35.7143 %
    Kappa statistic                          0.186 
    Mean absolute error                      0.3674
    Root mean squared error                  0.5338
    Relative absolute error                 77.1635 %
    Root relative squared error            108.1927 %
    Coverage of cases (0.95 level)          92.8571 %
    Mean rel. region size (0.95 level)      75      %
    Total Number of Instances               14     
    
    === Detailed Accuracy By Class ===
    
                     TP Rate  FP Rate  Precision  Recall   F-Measure  MCC      ROC Area  PRC Area  Class
                     0.778    0.600    0.700      0.700    0.700      0.189    0.656     0.757     yes
                     0.400    0.222    0.500      0.500    0.500      0.189    0.656     0.646     no
    Weighted Avg.    0.643    0.465    0.629      0.643    0.632      0.189    0.656     0.717     
    
    === Confusion Matrix ===
    
     a b   <-- classified as
     7 2 | a = yes
     3 2 | b = no

     

     

     

       经过训练,生成的规则一共有如下三条。

    JRIP rules:
    ===========
    
    (humidity = high) and (outlook = sunny) => play=no (3.0/0.0)
    (outlook = rainy) and (windy = TRUE) => play=no (2.0/0.0)
     => play=yes (9.0/0.0)
    
    Number of Rules : 3

      每条规则用“=>”分开规则前件和规则后件,规则后件有用括号引起的两个数字,第一个数字表示规则覆盖的实例数量,第二个数字表示错分的实例数量。注意到第三条规则的规则前件为空,表示这条规则覆盖除去前两条规则覆盖的训练实例外的所有实例。

     

     


      同样也可以可视化分类错误。右击结果列表中的rules. JRip条目,然后从上下文菜单中选择Visualize classifier errors菜单项。会弹出一个散点图窗口,在窗口中拉动Jitter滑条,会错开一些相互叠加的实例,如下图所示。

                      可视化JRip分类错误散点图

       在分类错误散点图中,左上角和右下角的小方块都是正确分类的实例,左下角的小蓝叉和右上角的小红叉都是错分的实例,可视化能直观看到错分实例的数量。

     

     

     


    4、使用线性回归
      本示例使用线性回归训练CPU数据集,并评估分类器性能。
      首先启动探索者界面,在预处理面板中加载cpu.arff数据文件。如下图所示,在窗口右下角可以看到第一个属性MYCT的直方图,由于类别属性是连续型数值,因此该直方图不是彩色的。

     

     

     

       

      切换至分类面板,单击Classifier子面板下的Choose按钮,选择functions条目下的LinearRegression分类器,保持默认参数不变,单击Start启动训练,训练结果如下所示

     

     

    === Run information ===
    
    Scheme:       weka.classifiers.functions.LinearRegression -S 0 -R 1.0E-8
    Relation:     cpu
    Instances:    209
    Attributes:   7
                  MYCT
                  MMIN
                  MMAX
                  CACH
                  CHMIN
                  CHMAX
                  class
    Test mode:    10-fold cross-validation
    
    === Classifier model (full training set) ===
    
    
    Linear Regression Model
    
    class =
    
          0.0491 * MYCT +
          0.0152 * MMIN +
          0.0056 * MMAX +
          0.6298 * CACH +
          1.4599 * CHMAX +
        -56.075 
    
    Time taken to build model: 0.06 seconds
    
    === Cross-validation ===
    === Summary ===
    
    Correlation coefficient                  0.9012
    Mean absolute error                     41.0886
    Root mean squared error                 69.556 
    Relative absolute error                 42.6943 %
    Root relative squared error             43.2421 %
    Total Number of Instances              209     

       从结果中可以看到,LinearRegression分类器构建了一个回归公式,交叉验证显示其性能不佳。

     

     

      再次单击Choose按钮,选择另一种分类器——M5P,该分类器在trees条目下。还是 保持默认参数不变,单击Start按钮启动训练,训练结果如下图所示。

    === Run information ===
    
    Scheme:       weka.classifiers.trees.M5P -M 4.0
    Relation:     cpu
    Instances:    209
    Attributes:   7
                  MYCT
                  MMIN
                  MMAX
                  CACH
                  CHMIN
                  CHMAX
                  class
    Test mode:    10-fold cross-validation
    
    === Classifier model (full training set) ===
    
    M5 pruned model tree:
    (using smoothed linear models)
    
    CHMIN <= 7.5 : LM1 (165/12.903%)
    CHMIN >  7.5 : 
    |   MMAX <= 28000 : 
    |   |   MMAX <= 13240 : 
    |   |   |   CACH <= 81.5 : LM2 (6/18.551%)
    |   |   |   CACH >  81.5 : LM3 (4/30.824%)
    |   |   MMAX >  13240 : LM4 (11/24.185%)
    |   MMAX >  28000 : LM5 (23/48.302%)
    
    LM num: 1
    class = 
        -0.0055 * MYCT 
        + 0.0013 * MMIN 
        + 0.0029 * MMAX 
        + 0.8007 * CACH 
        + 0.4015 * CHMAX 
        + 11.0971
    
    LM num: 2
    class = 
        -1.0307 * MYCT 
        + 0.0086 * MMIN 
        + 0.0031 * MMAX 
        + 0.7866 * CACH 
        - 2.4503 * CHMIN 
        + 1.1597 * CHMAX 
        + 70.8672
    
    LM num: 3
    class = 
        -1.1057 * MYCT 
        + 0.0086 * MMIN 
        + 0.0031 * MMAX 
        + 0.7995 * CACH 
        - 2.4503 * CHMIN 
        + 1.1597 * CHMAX 
        + 83.0016
    
    LM num: 4
    class = 
        -0.8813 * MYCT 
        + 0.0086 * MMIN 
        + 0.0031 * MMAX 
        + 0.6547 * CACH 
        - 2.3561 * CHMIN 
        + 1.1597 * CHMAX 
        + 82.5725
    
    LM num: 5
    class = 
        -0.4882 * MYCT 
        + 0.0218 * MMIN 
        + 0.003 * MMAX 
        + 0.3865 * CACH 
        - 1.3252 * CHMIN 
        + 3.3671 * CHMAX 
        - 51.8474
    
    Number of Rules : 5
    
    Time taken to build model: 0.2 seconds
    
    === Cross-validation ===
    === Summary ===
    
    Correlation coefficient                  0.9274
    Mean absolute error                     29.8309
    Root mean squared error                 60.7112
    Relative absolute error                 30.9967 %
    Root relative squared error             37.7434 %
    Total Number of Instances              209     

     

     

     从上图可以看到,M5P是决策树方案和线性回归方案的结合体。前半部分使用剪枝的决策树,后半部分则使用线性回归。如果要稍微深入了解M5P算法的原理,不妨在结果列表中单击蓝色的条目,在弹出的上下文菜单中选择Visualize tree菜单项,Weka弹出如下图所示的决策树的可视化结果。

      剪枝模型树使用数据集中六个属性中的三个进行分叉,树根对CHMIN属性分叉,在左分支上得到一个线性模型——LM1,剩余的结构放到右分支上。继续分叉,得到另外的四个线性模型——LM2〜LM5。一共有五个叶节点, 每个叶节点对应一个线性模型。括号中有两个数字,第一个数字是达到该叶子节点的实例数量,第二个百分数是用该叶节点的线性模型对这些实例进行预测的均方根误差,用百分比表示对全部训练数据计算而得到的类别属性的标准偏差。

     

     

     

      为了对两个分类器的性能有一个直观的认识,使用可视化方法来观察两个学习方案的误差。在历史列表子面板中分别右击两个条目,选择Visualize classifier errors菜单项,得到两个学习方案的可视化误差如下两个图所示。

          LinearRegression误差

     

     

     

     

                M5p误差

     

      显示的数据点随类别属性值的不同而异,由于类别属性是连续数值,因此数据点的颜色也是连续变化的。这里选择 MMAX属性作为X轴,CACH属性作为^轴,这样数据点能够尽量散开。每个数据点用 一个小叉表示,其大小表示该实例的误差的绝对值。可以看到,图M5p误差的小叉数量多于 图LinearRegression误差的小叉数量,说明M5P的性能优于LinearRegression。

     

     

     

     

     

     

    5、 使用用户分类器
      用户分类器(User Classifier)允许Weka用户以交互方式建立自己的分类器。该分类器位于分层菜单trees部分之下,名称为User Classifier,全名为weka.classifiers.trees. UserClassifier。如果在自己的Weka版本中找不到该分类器,说明还没有安装,请按照之前写的Weka包管理器的相关内容进行安装。

      本例使用segment数据集来说明操作方式。根据给定平均intensity(亮度)、hue(色调)、 size(大小)、position(位置),以及各种简单的纹理特征的属性,将视觉图像数据分割成各种 分类标签,如grass(草)、sky(天空)、foliage(树叶)、brick(砖)和cement(水泥)。训练数据文 件随Weka软件配附,名称为segment-challenge.arff。加载该数据文件,选择UserClassifier 分类器。

     

     

      评估使用特殊的测试集,名为segment-test.arff。

     

     

     

     

      如果在自己的Weka版本(我的目前是weka3.7.8)中找不到该UserClassifier分类器,说明还没有安装,请按照之前写的Weka包管理器的相关内容进行安装。或者见如下也是可以的。

     

     

       这里,大家得要去升级下,自己的Weka版本。很简单,暂时没有提供在线升级,直接去官网,下载最新的weka版本。

    Weka中数据挖掘与机器学习系列之Weka系统安装(四)

     

       我这里,以weka3.7.8 到 3.9.0

     (因为,我本地windows7下,已经安装好了jdk1.7了)

      

      下载,请见

     http://download.csdn.net/detail/u010106732/9842662

     

     

     

     

     

     

     

     

      我这里,在我自己电脑里,这两款版本我都保留了。大家也可以这样去做。因为,有些资料网上,还现在很大程度上,停留在3.7,当然慢慢会有3.9的资料增加!

     

       大家也许会有个疑问:那么在环境变量那一步,怎么共存两个不同的weka版本呢?

       很简单:WEKA37_HOME=D:\SoftWare\Weka-3-7

           WEKA39_HOME=D:\SoftWare\Weka-3-9

     Weka中数据挖掘与机器学习系列之Weka3.7和3.9不同版本共存(七)

     

     

     

     

      然后,安装好之后,去盖好相关的配置和数据库连接,这里自己去看我前面都博客,不要嫌麻烦。学习本来就是一个更新替换的过程,没有多次弄,怎么会学好呢?

      然后,再把UserClassifier分类器下载好。

    Weka中数据挖掘与机器学习系列之Weka Package Manager安装所需WEKA的附加算法包出错问题解决方案总结(八)

     

       为此,我这里是,以weka3.9.0版本为例。

     

     

     

     

     

     

     

       在Classify面板的Test options子面板 中选择Supplied test set(提供测试集)选项。这里要注意,用户分类器不能使用交叉验证进行评估,因为无法为每个折都手动构建分类器。单击Supplied test set选项后面的Set按钮,弹出Test Instances(测试实例)窗口,然后单击Openfile按钮,如下图所示在标准的打开文件窗口中选择data目录下的segment-test.arff文件。单击Close按钮关闭测试实例窗口。

     

     

     

     

     

     


      然后,单击Weka探索者Classify标签页下的Start按钮,启动交互构建分类器的界面,这时,探索者界面右下角的小鸟站起来不断走动,表明Weka正在等待用 下图选择测试集户完成分类器的构建工作。

     

    === Run information ===
    
    Scheme:       weka.classifiers.trees.UserClassifier 
    Relation:     segment
    Instances:    810
    Attributes:   20
                  region-centroid-col
                  region-centroid-row
                  region-pixel-count
                  short-line-density-5
                  short-line-density-2
                  vedge-mean
                  vegde-sd
                  hedge-mean
                  hedge-sd
                  intensity-mean
                  rawred-mean
                  rawblue-mean
                  rawgreen-mean
                  exred-mean
                  exblue-mean
                  exgreen-mean
                  value-mean
                  saturation-mean
                  hue-mean
                  class
    Test mode:    user supplied test set:  size unknown (reading incrementally)

     

     

     

     

       窗口分为Tree Visualizer(树可视化工具)和Data Visualizer(数据可视化工具)两个标签页,可以切换不同的视图。前者显示分类树的当前状态,并且每个节点都给出到达该节点的每个类别的实例数目。构建用户分类器的目标就是得到一棵其叶节点都尽可能纯净的树。最初只有一个根节点,其中包含全部数据。切换到Data Visualizer标签页去创建分割,显示了一个二维散点图,可以参考本博文后面的“可视化面板”的使用方法,选择哪个属性作为X轴,哪个属性作为Y轴。这里的目标是要找到一个X轴和Y轴的属性组合,将不同类别尽可能完全进行分离。尝试多遍以后,读者可能会找到一个好的选择:使用region- centroid-row 属性作为X轴,使用 intensity-mean 属性作为Y轴,这样会将红色的实例几乎 完全与其他实例分离,如下图所示。

      

     

     

     


      找到了很好的分离点之后,必须在图中指定一个区域。在Jitter滑块之上的下拉菜单,可以选择四种选择工具:

      选择Select Instance(选择实例)选项标识一个特定实例;

      选择 Rectangle(矩形)选项在图形上拖出一个矩形:

      选择Polygon(多边形)选项画一个自由形状的 多边形;

      选择Polyline(折线)选项画一种自由形状的折线。

     

     

     

     

     

     

      操作方式都是:单击添加了一个顶点,右击完成操作。一旦选择某个区域,该区域会变成灰色。在下图中,用户己经定义好了一个矩形。

     (这一步其实是本博文后面所要讲到的可视化界面)。

       Select Instance(选择实例)下拉列表框,以及Reset、Clear、Save按钮,让用户修改数据集。可以选择某些实例并删除其他实例。例如,尝试这样使用Rectangle(矩形)选项:首先从下拉框中选中Rectangle选项,然后单击并拖动鼠标来选择一个区域。这时,Reset按钮会自动变成Submit按钮,单击Submit按钮,矩形以外的所有实例都将被删除(注意看如下的图)。用户可以使用Save按钮将修改过的数据集保存到文件中,当然,Open按钮可以打开保存后的数据集文件。单击Redet按钮,可以恢复到原来的数据集。

     

     

     

     

     

      如果单击Submit(提交)按钮,则在树中创建两个新的节点,一个节点容纳选定的实例,另一个节点容纳其余的实例。Clear(清除)按钮清除选择,Save(保存)按钮将当前树的节点实例保存为一个ARFF文件。

     

     

     

     

      这时,Tree Visualizer标签页显示如下图所示,左边的节点表示为sky类别,纯粹只有一种类别,但右边的节点还是混合了多个分类,需要进一步进行分割。单击不同节点,可以在Data Visualizer标签页中切换显示哪个数据子集。继续添加节点,直到得到满意的结果,也就是说,直到叶子节点大多是只有一种分类的纯洁点为止。然后,在Tree Visualizer标签页的任意空白处右击,并选择Accept the Tree(接受树)菜单项。Weka使用测试集评估建立的树,并输出性能统计信息。对于本例而言,90%已经是很高的得分了。

     

     

     

       这是非常考验细心和耐心的工作,如果能得到93以上成绩真值得骄傲。

      现在和Weka的机器学习比试一下。还是使用同样的训练集和测试集,但选择J48分类器来替换用户分类器,单击Start按钮启动训练和评估,本例J48分类器的正确率高达96.1728%,的确是手工交互进行分类难以达到的目标。

     

     

     

     

     

     

     

    6、使用支持向量机

      本示例分为两个部分,第一部分展示如何使用SMO分类器,第二部分展示如何使用LibSVM。

       启动探索者界面,首先在预处理面板中加载iris数据集,然后切换到分类面板,单击Classifier子面板下的Choose按钮,选择functions条目下的SMO分类器,使用默认的十折交叉验证测试选项,单击Start按钮启动分类模型构建并评估,运行结果如下图所示。

     

    === Run information ===
    
    Scheme:       weka.classifiers.functions.SMO -C 1.0 -L 0.001 -P 1.0E-12 -N 0 -V -1 -W 1 -K "weka.classifiers.functions.supportVector.PolyKernel -E 1.0 -C 250007" -calibrator "weka.classifiers.functions.Logistic -R 1.0E-8 -M -1 -num-decimal-places 4"
    Relation:     iris
    Instances:    150
    Attributes:   5
                  sepallength
                  sepalwidth
                  petallength
                  petalwidth
                  class
    Test mode:    10-fold cross-validation
    
    === Classifier model (full training set) ===
    
    SMO
    
    Kernel used:
      Linear Kernel: K(x,y) = <x,y>
    
    Classifier for classes: Iris-setosa, Iris-versicolor
    
    BinarySMO
    
    Machine linear: showing attribute weights, not support vectors.
    
             0.6829 * (normalized) sepallength
     +      -1.523  * (normalized) sepalwidth
     +       2.2034 * (normalized) petallength
     +       1.9272 * (normalized) petalwidth
     -       0.7091
    
    Number of kernel evaluations: 352 (70.32% cached)
    
    Classifier for classes: Iris-setosa, Iris-virginica
    
    BinarySMO
    
    Machine linear: showing attribute weights, not support vectors.
    
             0.5886 * (normalized) sepallength
     +      -0.5782 * (normalized) sepalwidth
     +       1.6429 * (normalized) petallength
     +       1.4777 * (normalized) petalwidth
     -       1.1668
    
    Number of kernel evaluations: 284 (68.996% cached)
    
    Classifier for classes: Iris-versicolor, Iris-virginica
    
    BinarySMO
    
    Machine linear: showing attribute weights, not support vectors.
    
             0.3176 * (normalized) sepallength
     +      -0.863  * (normalized) sepalwidth
     +       3.0543 * (normalized) petallength
     +       4.0815 * (normalized) petalwidth
     -       4.5924
    
    Number of kernel evaluations: 453 (61.381% cached)
    
    
    
    Time taken to build model: 0.1 seconds
    
    === Stratified cross-validation ===
    === Summary ===
    
    Correctly Classified Instances         144               96      %
    Incorrectly Classified Instances         6                4      %
    Kappa statistic                          0.94  
    Mean absolute error                      0.2311
    Root mean squared error                  0.288 
    Relative absolute error                 52      %
    Root relative squared error             61.101  %
    Total Number of Instances              150     
    
    === Detailed Accuracy By Class ===
    
                     TP Rate  FP Rate  Precision  Recall   F-Measure  MCC      ROC Area  PRC Area  Class
                     1.000    0.000    1.000      1.000    1.000      1.000    1.000     1.000     Iris-setosa
                     0.980    0.050    0.907      0.980    0.942      0.913    0.965     0.896     Iris-versicolor
                     0.900    0.010    0.978      0.900    0.938      0.910    0.970     0.930     Iris-virginica
    Weighted Avg.    0.960    0.020    0.962      0.960    0.960      0.941    0.978     0.942     
    
    === Confusion Matrix ===
    
      a  b  c   <-- classified as
     50  0  0 |  a = Iris-setosa
      0 49  1 |  b = Iris-versicolor
      0  5 45 |  c = Iris-virginica

      本例使用指数为1的Polykernel(多项式核),使得模型成为线性支持向量机。由于iris数据包含三个类别值,就输出三个对应的二元SMO模型,

     这是因为一个超平面分隔每个可能类别值对。此外,由于SVM是线性的,超平面表示为在原来空间中的属性值的函数,如上的函数表达式。

     

     

       下图所示的是将多项式核函数的指数设置为2的结果,这使得支持向量机成为非线性的。和前面的一样,也有三个二元的SMO模型,但这次超平面表示为支持向量的函数。支持向量显示在尖括号中,还显示其系数α的值。

     

     

     

     

     

     

     

     

     

     7、使用元学习器

      元学习器能将简单的分类器变为更强大的学习器,这里以实例进行说明。

      首先加载鸢尾花数据集,然后选择DecisionStump分类器,这是一个称为决策树桩的简单分类器,全名为weka.classifiers.trees.DecisionStump。

     

      然后选择十折交叉验证为测试选择项进行训练和评估,得到的分类正确率为66.6667%。

     

    === Run information ===
    
    Scheme:       weka.classifiers.trees.DecisionStump 
    Relation:     iris
    Instances:    150
    Attributes:   5
                  sepallength
                  sepalwidth
                  petallength
                  petalwidth
                  class
    Test mode:    10-fold cross-validation
    
    === Classifier model (full training set) ===
    
    Decision Stump
    
    Classifications
    
    petallength <= 2.45 : Iris-setosa
    petallength > 2.45 : Iris-versicolor
    petallength is missing : Iris-setosa
    
    Class distributions
    
    petallength <= 2.45
    Iris-setosa    Iris-versicolor    Iris-virginica    
    1.0    0.0    0.0    
    petallength > 2.45
    Iris-setosa    Iris-versicolor    Iris-virginica    
    0.0    0.5    0.5    
    petallength is missing
    Iris-setosa    Iris-versicolor    Iris-virginica    
    0.3333333333333333    0.3333333333333333    0.3333333333333333    
    
    
    Time taken to build model: 0.04 seconds
    
    === Stratified cross-validation ===
    === Summary ===
    
    Correctly Classified Instances         100               66.6667 %
    Incorrectly Classified Instances        50               33.3333 %
    Kappa statistic                          0.5   
    Mean absolute error                      0.2222
    Root mean squared error                  0.3333
    Relative absolute error                 50      %
    Root relative squared error             70.7107 %
    Coverage of cases (0.95 level)         100      %
    Mean rel. region size (0.95 level)      55.5556 %
    Total Number of Instances              150     
    
    === Detailed Accuracy By Class ===
    
                     TP Rate  FP Rate  Precision  Recall   F-Measure  MCC      ROC Area  PRC Area  Class
                     1.000    0.000    1.000      1.000    1.000      1.000    1.000     1.000     Iris-setosa
                     1.000    0.500    0.500      0.500    0.500      0.500    0.750     0.500     Iris-versicolor
                     0.000    0.000    0.000      0.000    0.000      0.000    0.750     0.500     Iris-virginica
    Weighted Avg.    0.667    0.167    0.500      0.667    0.556      0.500    0.833     0.667     
    
    === Confusion Matrix ===
    
      a  b  c   <-- classified as
     50  0  0 |  a = Iris-setosa
      0 50  0 |  b = Iris-versicolor
      0 50  0 |  c = Iris-virginica

     

     

     

     

       接下来,选择AdaboostM1分类器,这是一个使用提升算法的集成学习器,其全名为weka.classifiers.meta.AdaBoostM1。单击该分类器进行设置,出现如下图所示的对象编辑器。为了和DecisionStump分类器进行比较,设置AdaboostM1的基分类器为DecisionStump分类器。如果需要,还可以继续单击以进一步配置基分类器的选项,但由于DecisionStump刚好没有课编辑的属性。因此,单击OK按钮返回到主分类面板,并且单击Start按钮启动训练。

      由于上图中的numIterations参数默认为10,也就是训练会迭代提升DecisionStump分类器10次。

     

      在下图中的运行结果表明,在150个iris数据中,只有7个错分的实例,分类正确率高达95.3333%。

      考虑到DecisionStump算法本类就十分原始。并且只听过很少次数的提升迭代,性能提高很大,令人满意。

     

     

     

     

     

    8、深入研究离散化

      这里,研究离散化的效果,加载ionosphere.arff数据文件,构建J48决策树。该数据集包括从电离层传回的雷达信号信息。数据集共有34个属性外加1个类别属性,共有351个实例,没有缺失值。

     

     

      二元类别标签分别是good和bad,其中,“好”的样本指那些能够显示出电离层中的一些结构类型证据的实例,而“坏”的样本指信号直接穿过电离层的实例。更为详细的信息可以查看ARFF文件中的注释。

     

     

     

     

     

      首先以无监督离散化开始,采用十折交叉验证,比较不同学习方案的正确率以及决策树的大小。采用J48分类器对原始数据进行分类,正确分类的实例数量为321,正确率为 91.453%,叶节点数为18,树的大小为35;然后使用无监督的Discretize过滤器,保持过滤器参数为默认值,先进行过滤,再采用j48分类器对过滤后的数据进行分类,正确分类的实例数最为304,正确率为86.6097%,叶节点数为46,树的大小为51;最后将无监督 Discretize过滤器的makeBinary参数设置为True,其余参数仍为缺省值,先进行过滤,再 采用J48分类器对过滤后的数据进行分类,正确分类的实例数量为326,正确率为 92.8775%,叶节点数为9,树的大小为17。无监督离散化的效果如下表所示。

     

      研究上表的结果,可以得出这样的结论:使用二元化的无监督离散化,可以提高分 类器的正确率,并大幅减少决策树的大小。

     

     

     

     


      现在轮到有监督离散化。这里出现一个微妙的问题,如果简单地重复使用有监督离散化方法替换无监督离散化,结果必然过于乐观。因为这里将交叉验证用于评价,测试集里的数据在确定离散间隔时己经使用过,必然造成如同预先偷看到答案再考试的效果。对于新的数据,这就无法给出一个合理的性能评估。
      要合理地评估有监督离散化,最好使用Weka的元学习器FilteredClassifier。它仅使用训练数据来构建过滤器,然后,使用训练数据计算得到的离散间隔来离散化册数数据,并予以评估。总之,这种方式完全符合在真实实战中处理新数据的过程。

       仍然使用ionsphere.arff数据文件,取消在过滤器标签页中选择的过滤器,并在分类器标签页中选择FilteredClassifier分类器,其全名为weka.classifiers.meta.FilterdClassifier。设置该分类器的classifier为J48。filter为有监督的Discretize,保持默认参数不变,如下图所示。

     

     

     

     

     

    === Run information ===
    
    Scheme:       weka.classifiers.meta.FilteredClassifier -F "weka.filters.supervised.attribute.Discretize -R first-last" -W weka.classifiers.trees.J48 -- -C 0.25 -M 2
    Relation:     ionosphere
    Instances:    351
    Attributes:   35
                  a01
                  a02
                  a03
                  a04
                  a05
                  a06
                  a07
                  a08
                  a09
                  a10
                  a11
                  a12
                  a13
                  a14
                  a15
                  a16
                  a17
                  a18
                  a19
                  a20
                  a21
                  a22
                  a23
                  a24
                  a25
                  a26
                  a27
                  a28
                  a29
                  a30
                  a31
                  a32
                  a33
                  a34
                  class
    Test mode:    10-fold cross-validation
    
    === Classifier model (full training set) ===
    
    FilteredClassifier using weka.classifiers.trees.J48 -C 0.25 -M 2 on data filtered through weka.filters.supervised.attribute.Discretize -R first-last
    
    Filtered Header
    @relation ionosphere-weka.filters.supervised.attribute.Discretize-Rfirst-last
    
    @attribute a01 {'\'(-inf-0.5]\'','\'(0.5-inf)\''}
    @attribute a02 {'\'All\''}
    @attribute a03 {'\'(-inf-0.19028]\'','\'(0.19028-0.73947]\'','\'(0.73947-0.998505]\'','\'(0.998505-inf)\''}
    @attribute a04 {'\'(-inf--0.609635]\'','\'(-0.609635--0.00017]\'','\'(-0.00017-0.007075]\'','\'(0.007075-0.74685]\'','\'(0.74685-inf)\''}
    @attribute a05 {'\'(-inf-0.04144]\'','\'(0.04144-0.418075]\'','\'(0.418075-0.995175]\'','\'(0.995175-inf)\''}
    @attribute a06 {'\'(-inf--0.79531]\'','\'(-0.79531--0.217515]\'','\'(-0.217515--0.000715]\'','\'(-0.000715-0.00101]\'','\'(0.00101-0.82509]\'','\'(0.82509-inf)\''}
    @attribute a07 {'\'(-inf-0.029375]\'','\'(0.029375-0.999995]\'','\'(0.999995-inf)\''}
    @attribute a08 {'\'(-inf--0.983575]\'','\'(-0.983575--0.000375]\'','\'(-0.000375-0.000985]\'','\'(0.000985-0.994515]\'','\'(0.994515-inf)\''}
    @attribute a09 {'\'(-inf--0.704705]\'','\'(-0.704705--0.036395]\'','\'(-0.036395-0.011975]\'','\'(0.011975-0.05561]\'','\'(0.05561-inf)\''}
    @attribute a10 {'\'(-inf--0.57299]\'','\'(-0.57299-0.591395]\'','\'(0.591395-0.9891]\'','\'(0.9891-inf)\''}
    @attribute a11 {'\'(-inf--0.91576]\'','\'(-0.91576--0.01058]\'','\'(-0.01058-0.08713]\'','\'(0.08713-0.9991]\'','\'(0.9991-inf)\''}
    @attribute a12 {'\'(-inf--0.56293]\'','\'(-0.56293--0.00027]\'','\'(-0.00027-0.001845]\'','\'(0.001845-0.981525]\'','\'(0.981525-inf)\''}
    @attribute a13 {'\'(-inf--0.96941]\'','\'(-0.96941--0.076515]\'','\'(-0.076515-0.01567]\'','\'(0.01567-0.35474]\'','\'(0.35474-0.998725]\'','\'(0.998725-inf)\''}
    @attribute a14 {'\'(-inf--0.554585]\'','\'(-0.554585-0.652535]\'','\'(0.652535-0.97565]\'','\'(0.97565-inf)\''}
    @attribute a15 {'\'(-inf--0.98825]\'','\'(-0.98825--0.0283]\'','\'(-0.0283-0.239955]\'','\'(0.239955-0.99914]\'','\'(0.99914-inf)\''}
    @attribute a16 {'\'(-inf--0.90517]\'','\'(-0.90517--0.00197]\'','\'(-0.00197-0.00143]\'','\'(0.00143-0.96841]\'','\'(0.96841-inf)\''}
    @attribute a17 {'\'(-inf--0.96177]\'','\'(-0.96177--0.57273]\'','\'(-0.57273--0.05415]\'','\'(-0.05415-0.29207]\'','\'(0.29207-0.99815]\'','\'(0.99815-inf)\''}
    @attribute a18 {'\'(-inf--0.805795]\'','\'(-0.805795-0.99361]\'','\'(0.99361-inf)\''}
    @attribute a19 {'\'(-inf--0.989535]\'','\'(-0.989535--0.04391]\'','\'(-0.04391-0.12183]\'','\'(0.12183-0.46784]\'','\'(0.46784-0.998845]\'','\'(0.998845-inf)\''}
    @attribute a20 {'\'(-inf--0.912755]\'','\'(-0.912755-0.975495]\'','\'(0.975495-inf)\''}
    @attribute a21 {'\'(-inf--0.957365]\'','\'(-0.957365--0.000015]\'','\'(-0.000015-0.07206]\'','\'(0.07206-0.99888]\'','\'(0.99888-inf)\''}
    @attribute a22 {'\'(-inf--0.96798]\'','\'(-0.96798--0.0014]\'','\'(-0.0014-0.000375]\'','\'(0.000375-0.923655]\'','\'(0.923655-inf)\''}
    @attribute a23 {'\'(-inf--0.96809]\'','\'(-0.96809--0.0092]\'','\'(-0.0092-0.18657]\'','\'(0.18657-0.999665]\'','\'(0.999665-inf)\''}
    @attribute a24 {'\'(-inf--0.987455]\'','\'(-0.987455-0.89747]\'','\'(0.89747-inf)\''}
    @attribute a25 {'\'(-inf--0.87839]\'','\'(-0.87839--0.00017]\'','\'(-0.00017-0.08722]\'','\'(0.08722-0.999495]\'','\'(0.999495-inf)\''}
    @attribute a26 {'\'(-inf--0.98148]\'','\'(-0.98148-0.80245]\'','\'(0.80245-inf)\''}
    @attribute a27 {'\'(-inf-0.52812]\'','\'(0.52812-0.999945]\'','\'(0.999945-inf)\''}
    @attribute a28 {'\'(-inf--0.936175]\'','\'(-0.936175-0.86022]\'','\'(0.86022-inf)\''}
    @attribute a29 {'\'(-inf--0.91183]\'','\'(-0.91183--0.00009]\'','\'(-0.00009-0.06779]\'','\'(0.06779-0.997]\'','\'(0.997-inf)\''}
    @attribute a30 {'\'(-inf--0.91428]\'','\'(-0.91428-0.930305]\'','\'(0.930305-inf)\''}
    @attribute a31 {'\'(-inf--0.84848]\'','\'(-0.84848--0.1671]\'','\'(-0.1671-0.132415]\'','\'(0.132415-0.99556]\'','\'(0.99556-inf)\''}
    @attribute a32 {'\'(-inf--0.969765]\'','\'(-0.969765-0.87076]\'','\'(0.87076-inf)\''}
    @attribute a33 {'\'(-inf--0.959515]\'','\'(-0.959515--0.00004]\'','\'(-0.00004-0.0002]\'','\'(0.0002-0.994855]\'','\'(0.994855-inf)\''}
    @attribute a34 {'\'(-inf--0.974115]\'','\'(-0.974115--0.00003]\'','\'(-0.00003-0.0054]\'','\'(0.0054-0.95098]\'','\'(0.95098-inf)\''}
    @attribute class {b,g}
    
    @data
    
    
    Classifier Model
    J48 pruned tree
    ------------------
    
    a05 = '(-inf-0.04144]': b (67.0)
    a05 = '(0.04144-0.418075]'
    |   a03 = '(-inf-0.19028]': b (5.0)
    |   a03 = '(0.19028-0.73947]'
    |   |   a33 = '(-inf--0.959515]': g (0.0)
    |   |   a33 = '(-0.959515--0.00004]'
    |   |   |   a16 = '(-inf--0.90517]': b (1.0)
    |   |   |   a16 = '(-0.90517--0.00197]': g (2.0)
    |   |   |   a16 = '(-0.00197-0.00143]': b (0.0)
    |   |   |   a16 = '(0.00143-0.96841]': b (2.0)
    |   |   |   a16 = '(0.96841-inf)': b (0.0)
    |   |   a33 = '(-0.00004-0.0002]': g (0.0)
    |   |   a33 = '(0.0002-0.994855]': g (9.0)
    |   |   a33 = '(0.994855-inf)': b (1.0)
    |   a03 = '(0.73947-0.998505]': g (1.0)
    |   a03 = '(0.998505-inf)': g (1.0)
    a05 = '(0.418075-0.995175]': g (163.0/9.0)
    a05 = '(0.995175-inf)'
    |   a08 = '(-inf--0.983575]': b (15.0)
    |   a08 = '(-0.983575--0.000375]'
    |   |   a18 = '(-inf--0.805795]': b (3.0)
    |   |   a18 = '(-0.805795-0.99361]': g (32.0/3.0)
    |   |   a18 = '(0.99361-inf)': g (0.0)
    |   a08 = '(-0.000375-0.000985]': b (8.0)
    |   a08 = '(0.000985-0.994515]': g (27.0/1.0)
    |   a08 = '(0.994515-inf)': b (14.0/3.0)
    
    Number of Leaves  :     21
    
    Size of the tree :     27
    
    
    Time taken to build model: 0.72 seconds
    
    === Stratified cross-validation ===
    === Summary ===
    
    Correctly Classified Instances         320               91.1681 %
    Incorrectly Classified Instances        31                8.8319 %
    Kappa statistic                          0.8043
    Mean absolute error                      0.1185
    Root mean squared error                  0.2769
    Relative absolute error                 25.733  %
    Root relative squared error             57.7242 %
    Coverage of cases (0.95 level)          96.2963 %
    Mean rel. region size (0.95 level)      67.2365 %
    Total Number of Instances              351     
    
    === Detailed Accuracy By Class ===
    
                     TP Rate  FP Rate  Precision  Recall   F-Measure  MCC      ROC Area  PRC Area  Class
                     0.833    0.044    0.913      0.913    0.913      0.806    0.926     0.904     b
                     0.956    0.167    0.911      0.911    0.911      0.806    0.926     0.939     g
    Weighted Avg.    0.912    0.123    0.912      0.912    0.911      0.806    0.926     0.927     
    
    === Confusion Matrix ===
    
       a   b   <-- classified as
     105  21 |   a = b
      10 215 |   b = g

     

     

       这时,单击Start按钮启动训练及评估,得到输出结果:正确分类的实例数量为320,正确率为91.1681%,叶节点数为21,数的大小为27。然后,修改FilterClassifier分类器的filter参数,将有监督Discretize的makeBinary参数设置为True,其余参数仍为缺省值,输入框中的命令行应该是Doscretize -D -R first-last。再次单击Start按钮,得到输出结果值:正确分类的实例数量为325,正确率为92.5926%,叶子节点数为9,数的大小为17。有监督离散化的效果如下所示。

     

      仍然可以得出这样的结论:使用二元化的有监督离散化,可以提高分类器的正确率,并大幅度减少决策树的大小。

     

     

     

     

     

    9、初识最近邻分类器
      本节使用IBk分类器,这是一种k-最近邻分类器,既可以在交叉验证的基础上选择合适的k值,也可以加距离权重。
      在探索者界面中加载glass.arff数据集,切换至Classify面板,单击Choose按钮选择 IBk分类器,其全名为weka.classifiers.lazy.IBk。

     

     

     

     

      使用交叉验证测试该分类器的性能,使用交叉验证,保持折数为默认值10。IBk的选项都保持为默认值,这里要注意的参数是KNN,KNN值默认为1,这是分类时所用的近邻实例的数量。

     

     

     

      单击Start按钮运行一次分类算法,记录正确分类的百分比,其值为70%.5607%。

     

     

    === Run information ===
    
    Scheme:       weka.classifiers.lazy.IBk -K 1 -W 0 -A "weka.core.neighboursearch.LinearNNSearch -A \"weka.core.EuclideanDistance -R first-last\""
    Relation:     Glass
    Instances:    214
    Attributes:   10
                  RI
                  Na
                  Mg
                  Al
                  Si
                  K
                  Ca
                  Ba
                  Fe
                  Type
    Test mode:    10-fold cross-validation
    
    === Classifier model (full training set) ===
    
    IB1 instance-based classifier
    using 1 nearest neighbour(s) for classification
    
    
    Time taken to build model: 0 seconds
    
    === Stratified cross-validation ===
    === Summary ===
    
    Correctly Classified Instances         151               70.5607 %
    Incorrectly Classified Instances        63               29.4393 %
    Kappa statistic                          0.6005
    Mean absolute error                      0.0897
    Root mean squared error                  0.2852
    Relative absolute error                 42.3747 %
    Root relative squared error             87.8627 %
    Coverage of cases (0.95 level)          70.5607 %
    Mean rel. region size (0.95 level)      14.2857 %
    Total Number of Instances              214     
    
    === Detailed Accuracy By Class ===
    
                     TP Rate  FP Rate  Precision  Recall   F-Measure  MCC      ROC Area  PRC Area  Class
                     0.786    0.167    0.696      0.696    0.696      0.602    0.806     0.628     build wind float
                     0.671    0.130    0.739      0.739    0.739      0.554    0.765     0.629     build wind non-float
                     0.294    0.051    0.333      0.333    0.333      0.258    0.590     0.144     vehic wind float
                     0.000    0.000    0.000      0.000    0.000      0.000    ?         ?         vehic wind non-float
                     0.769    0.030    0.625      0.625    0.625      0.671    0.895     0.456     containers
                     0.778    0.015    0.700      0.700    0.700      0.726    0.838     0.598     tableware
                     0.793    0.011    0.920      0.920    0.920      0.834    0.884     0.772     headlamps
    Weighted Avg.    0.706    0.109    0.709      0.706    0.704      0.598    0.792     0.598     
    
    === Confusion Matrix ===
    
      a  b  c  d  e  f  g   <-- classified as
     55  9  6  0  0  0  0 |  a = build wind float
     15 51  4  0  3  2  1 |  b = build wind non-float
      9  3  5  0  0  0  0 |  c = vehic wind float
      0  0  0  0  0  0  0 |  d = vehic wind non-float
      0  2  0  0 10  0  1 |  e = containers
      0  1  0  0  1  7  0 |  f = tableware
      0  3  0  0  2  1 23 |  g = headlamps

     

     

     

     

       然后,修改KNN值为5,再次运行分类算法,记录正确分类的百分比,其值为67.757%,如下图所示。

    === Run information ===
    
    Scheme:       weka.classifiers.lazy.IBk -K 5 -W 0 -A "weka.core.neighboursearch.LinearNNSearch -A \"weka.core.EuclideanDistance -R first-last\""
    Relation:     Glass
    Instances:    214
    Attributes:   10
                  RI
                  Na
                  Mg
                  Al
                  Si
                  K
                  Ca
                  Ba
                  Fe
                  Type
    Test mode:    10-fold cross-validation
    
    === Classifier model (full training set) ===
    
    IB1 instance-based classifier
    using 5 nearest neighbour(s) for classification
    
    
    Time taken to build model: 0 seconds
    
    === Stratified cross-validation ===
    === Summary ===
    
    Correctly Classified Instances         145               67.757  %
    Incorrectly Classified Instances        69               32.243  %
    Kappa statistic                          0.5469
    Mean absolute error                      0.1085
    Root mean squared error                  0.2563
    Relative absolute error                 51.243  %
    Root relative squared error             78.9576 %
    Coverage of cases (0.95 level)          89.7196 %
    Mean rel. region size (0.95 level)      26.1682 %
    Total Number of Instances              214     
    
    === Detailed Accuracy By Class ===
    
                     TP Rate  FP Rate  Precision  Recall   F-Measure  MCC      ROC Area  PRC Area  Class
                     0.843    0.229    0.641      0.641    0.641      0.582    0.867     0.713     build wind float
                     0.684    0.174    0.684      0.684    0.684      0.510    0.848     0.756     build wind non-float
                     0.000    0.010    0.000      0.000    0.000      -0.029   0.642     0.161     vehic wind float
                     0.000    0.000    0.000      0.000    0.000      0.000    ?         ?         vehic wind non-float
                     0.385    0.025    0.500      0.500    0.500      0.407    0.952     0.546     containers
                     0.667    0.010    0.750      0.750    0.750      0.695    0.909     0.565     tableware
                     0.793    0.016    0.885      0.885    0.885      0.814    0.890     0.843     headlamps
    Weighted Avg.    0.678    0.142    0.635      0.678    0.651      0.533    0.853     0.685     
    
    === Confusion Matrix ===
    
      a  b  c  d  e  f  g   <-- classified as
     59 10  1  0  0  0  0 |  a = build wind float
     20 52  1  0  3  0  0 |  b = build wind non-float
     12  5  0  0  0  0  0 |  c = vehic wind float
      0  0  0  0  0  0  0 |  d = vehic wind non-float
      0  5  0  0  5  0  3 |  e = containers
      0  2  0  0  1  6  0 |  f = tableware
      1  2  0  0  1  2 23 |  g = headlamps

     

     

     

     

      可见,将KNN值由1增大至5后,IBK准确度稍微有所下降。从这个实例中,大家可能会凭着直觉得出KNN值越小越好的结论,事实会是这样的吗?且看后文。

     

     

     

     

     

     

    10、分类噪声与最近邻学习
      和其他技术一样,最近邻学习对训练数据中的噪声很敏感。在本节中,将大小不等的分类噪声注入数据中,并观察其对分类器性能的影响。
      本节使用一种称为AddNoise的无监督的属性过滤器来添加噪声,该属性过滤器位于 weka.filters.unsupervised.attribute包中,使用该过滤器,可以将数据中一定比例的类别标签翻转为随机选择的其他值。然而,对于本次实验,最重要的是要保证测试数据不受分类噪声的影响,这样才能得到可靠的评估结果。很多实际情况都要求过滤训练数据,但不能过滤测试数据,满足这种要求的元学习器称为niteredClassifier,位于weka.classifiers.meta包中。本例将该元学习器配置为使用IBK作为分类器,使用AddNoise作为过滤器。在运行学习算法之前,FilteredClassifier先对数据应用过滤器过滤,分两批完成:先训练数据,后测试数据。AddNoise过滤器只在遇到的首批数据中添加噪声,也就是说,随后的测试数据在通过时不受任何影响。

     

     

     

       还是使用玻璃数据集,在Classify面板中选择FilteredClassifier分类器。

     

     

     

       然后打开通用对象编辑器编辑该分类器的参数,选择classifier为IBk, filter参数为AddNoise,如图下图所示。

     

     

     

     

     

     

     

     

     


      修改IBk分类器的邻居数量KNN参数,分别设置为k = 1,k=3, k = 5。同时修改 AddNoise过滤器的分类噪声百分比percent参数,从0%、10%—直到100%。每次设置完毕后,单击Start按钮启动训练和评估,将得到的分类正确率填入下表中。

     

     

    === Run information ===
    
    Scheme:       weka.classifiers.meta.FilteredClassifier -F "weka.filters.unsupervised.attribute.AddNoise -C last -P 10 -S 1" -W weka.classifiers.lazy.IBk -- -K 1 -W 0 -A "weka.core.neighboursearch.LinearNNSearch -A \"weka.core.EuclideanDistance -R first-last\""
    Relation:     Glass
    Instances:    214
    Attributes:   10
                  RI
                  Na
                  Mg
                  Al
                  Si
                  K
                  Ca
                  Ba
                  Fe
                  Type
    Test mode:    10-fold cross-validation
    
    === Classifier model (full training set) ===
    
    FilteredClassifier using weka.classifiers.lazy.IBk -K 1 -W 0 -A "weka.core.neighboursearch.LinearNNSearch -A \"weka.core.EuclideanDistance -R first-last\"" on data filtered through weka.filters.unsupervised.attribute.AddNoise -C last -P 10 -S 1
    
    Filtered Header
    @relation Glass-weka.filters.unsupervised.attribute.AddNoise-Clast-P10-S1
    
    @attribute RI numeric
    @attribute Na numeric
    @attribute Mg numeric
    @attribute Al numeric
    @attribute Si numeric
    @attribute K numeric
    @attribute Ca numeric
    @attribute Ba numeric
    @attribute Fe numeric
    @attribute Type {'build wind float','build wind non-float','vehic wind float','vehic wind non-float',containers,tableware,headlamps}
    
    @data
    
    
    Classifier Model
    IB1 instance-based classifier
    using 1 nearest neighbour(s) for classification
    
    
    Time taken to build model: 0.02 seconds
    
    === Stratified cross-validation ===
    === Summary ===
    
    Correctly Classified Instances         134               62.6168 %
    Incorrectly Classified Instances        80               37.3832 %
    Kappa statistic                          0.4954
    Mean absolute error                      0.1116
    Root mean squared error                  0.3213
    Relative absolute error                 52.717  %
    Root relative squared error             98.9904 %
    Coverage of cases (0.95 level)          62.6168 %
    Mean rel. region size (0.95 level)      14.2857 %
    Total Number of Instances              214     
    
    === Detailed Accuracy By Class ===
    
                     TP Rate  FP Rate  Precision  Recall   F-Measure  MCC      ROC Area  PRC Area  Class
                     0.729    0.215    0.622      0.622    0.622      0.495    0.753     0.559     build wind float
                     0.605    0.130    0.719      0.719    0.719      0.496    0.725     0.587     build wind non-float
                     0.235    0.066    0.235      0.235    0.235      0.169    0.570     0.111     vehic wind float
                     0.000    0.005    0.000      0.000    0.000      0.000    ?         ?         vehic wind non-float
                     0.769    0.030    0.625      0.625    0.625      0.671    0.892     0.439     containers
                     0.667    0.024    0.545      0.545    0.545      0.584    0.759     0.446     tableware
                     0.586    0.032    0.739      0.739    0.739      0.612    0.814     0.545     headlamps
    Weighted Avg.    0.626    0.129    0.638      0.626    0.627      0.500    0.745     0.519     
    
    === Confusion Matrix ===
    
      a  b  c  d  e  f  g   <-- classified as
     51  9  7  1  1  0  1 |  a = build wind float
     16 46  5  0  3  2  4 |  b = build wind non-float
      9  3  4  0  0  1  0 |  c = vehic wind float
      0  0  0  0  0  0  0 |  d = vehic wind non-float
      0  2  0  0 10  0  1 |  e = containers
      1  1  0  0  1  6  0 |  f = tableware
      5  3  1  0  1  2 17 |  g = headlamps

     

     

     

     

     

     

     

     

     

     

     

     

    === Run information ===
    
    Scheme:       weka.classifiers.meta.FilteredClassifier -F "weka.filters.unsupervised.attribute.AddNoise -C last -P 10 -S 1" -W weka.classifiers.lazy.IBk -- -K 3 -W 0 -A "weka.core.neighboursearch.LinearNNSearch -A \"weka.core.EuclideanDistance -R first-last\""
    Relation:     Glass
    Instances:    214
    Attributes:   10
                  RI
                  Na
                  Mg
                  Al
                  Si
                  K
                  Ca
                  Ba
                  Fe
                  Type
    Test mode:    10-fold cross-validation
    
    === Classifier model (full training set) ===
    
    FilteredClassifier using weka.classifiers.lazy.IBk -K 3 -W 0 -A "weka.core.neighboursearch.LinearNNSearch -A \"weka.core.EuclideanDistance -R first-last\"" on data filtered through weka.filters.unsupervised.attribute.AddNoise -C last -P 10 -S 1
    
    Filtered Header
    @relation Glass-weka.filters.unsupervised.attribute.AddNoise-Clast-P10-S1
    
    @attribute RI numeric
    @attribute Na numeric
    @attribute Mg numeric
    @attribute Al numeric
    @attribute Si numeric
    @attribute K numeric
    @attribute Ca numeric
    @attribute Ba numeric
    @attribute Fe numeric
    @attribute Type {'build wind float','build wind non-float','vehic wind float','vehic wind non-float',containers,tableware,headlamps}
    
    @data
    
    
    Classifier Model
    IB1 instance-based classifier
    using 3 nearest neighbour(s) for classification
    
    
    Time taken to build model: 0.01 seconds
    
    === Stratified cross-validation ===
    === Summary ===
    
    Correctly Classified Instances         149               69.6262 %
    Incorrectly Classified Instances        65               30.3738 %
    Kappa statistic                          0.5784
    Mean absolute error                      0.1203
    Root mean squared error                  0.2701
    Relative absolute error                 56.8261 %
    Root relative squared error             83.2287 %
    Coverage of cases (0.95 level)          84.1121 %
    Mean rel. region size (0.95 level)      25.4339 %
    Total Number of Instances              214     
    
    === Detailed Accuracy By Class ===
    
                     TP Rate  FP Rate  Precision  Recall   F-Measure  MCC      ROC Area  PRC Area  Class
                     0.857    0.236    0.638      0.638    0.638      0.587    0.837     0.661     build wind float
                     0.658    0.123    0.746      0.746    0.746      0.552    0.803     0.673     build wind non-float
                     0.235    0.025    0.444      0.444    0.444      0.283    0.634     0.175     vehic wind float
                     0.000    0.000    0.000      0.000    0.000      0.000    ?         ?         vehic wind non-float
                     0.538    0.015    0.700      0.700    0.700      0.593    0.918     0.547     containers
                     0.556    0.010    0.714      0.714    0.714      0.616    0.909     0.621     tableware
                     0.793    0.022    0.852      0.852    0.852      0.795    0.877     0.793     headlamps
    Weighted Avg.    0.696    0.127    0.697      0.696    0.687      0.580    0.822     0.636     
    
    === Confusion Matrix ===
    
      a  b  c  d  e  f  g   <-- classified as
     60  6  3  0  0  0  1 |  a = build wind float
     22 50  2  0  1  0  1 |  b = build wind non-float
      9  4  4  0  0  0  0 |  c = vehic wind float
      0  0  0  0  0  0  0 |  d = vehic wind non-float
      0  4  0  0  7  0  2 |  e = containers
      1  2  0  0  1  5  0 |  f = tableware
      2  1  0  0  1  2 23 |  g = headlamps

     

     

     

     

     

     

     

     

     

     

    === Run information ===
    
    Scheme:       weka.classifiers.meta.FilteredClassifier -F "weka.filters.unsupervised.attribute.AddNoise -C last -P 10 -S 1" -W weka.classifiers.lazy.IBk -- -K 5 -W 0 -A "weka.core.neighboursearch.LinearNNSearch -A \"weka.core.EuclideanDistance -R first-last\""
    Relation:     Glass
    Instances:    214
    Attributes:   10
                  RI
                  Na
                  Mg
                  Al
                  Si
                  K
                  Ca
                  Ba
                  Fe
                  Type
    Test mode:    10-fold cross-validation
    
    === Classifier model (full training set) ===
    
    FilteredClassifier using weka.classifiers.lazy.IBk -K 5 -W 0 -A "weka.core.neighboursearch.LinearNNSearch -A \"weka.core.EuclideanDistance -R first-last\"" on data filtered through weka.filters.unsupervised.attribute.AddNoise -C last -P 10 -S 1
    
    Filtered Header
    @relation Glass-weka.filters.unsupervised.attribute.AddNoise-Clast-P10-S1
    
    @attribute RI numeric
    @attribute Na numeric
    @attribute Mg numeric
    @attribute Al numeric
    @attribute Si numeric
    @attribute K numeric
    @attribute Ca numeric
    @attribute Ba numeric
    @attribute Fe numeric
    @attribute Type {'build wind float','build wind non-float','vehic wind float','vehic wind non-float',containers,tableware,headlamps}
    
    @data
    
    
    Classifier Model
    IB1 instance-based classifier
    using 5 nearest neighbour(s) for classification
    
    
    Time taken to build model: 0.01 seconds
    
    === Stratified cross-validation ===
    === Summary ===
    
    Correctly Classified Instances         138               64.486  %
    Incorrectly Classified Instances        76               35.514  %
    Kappa statistic                          0.5026
    Mean absolute error                      0.1265
    Root mean squared error                  0.2635
    Relative absolute error                 59.7351 %
    Root relative squared error             81.1902 %
    Coverage of cases (0.95 level)          90.6542 %
    Mean rel. region size (0.95 level)      32.1095 %
    Total Number of Instances              214     
    
    === Detailed Accuracy By Class ===
    
                     TP Rate  FP Rate  Precision  Recall   F-Measure  MCC      ROC Area  PRC Area  Class
                     0.843    0.257    0.615      0.615    0.615      0.553    0.858     0.684     build wind float
                     0.618    0.167    0.671      0.671    0.671      0.461    0.836     0.709     build wind non-float
                     0.118    0.020    0.333      0.333    0.333      0.159    0.604     0.150     vehic wind float
                     0.000    0.000    0.000      0.000    0.000      0.000    ?         ?         vehic wind non-float
                     0.308    0.025    0.444      0.444    0.444      0.337    0.960     0.551     containers
                     0.444    0.010    0.667      0.667    0.667      0.529    0.896     0.492     tableware
                     0.759    0.027    0.815      0.815    0.815      0.754    0.901     0.841     headlamps
    Weighted Avg.    0.645    0.150    0.631      0.645    0.626      0.502    0.843     0.656     
    
    === Confusion Matrix ===
    
      a  b  c  d  e  f  g   <-- classified as
     59  9  2  0  0  0  0 |  a = build wind float
     24 47  1  0  3  0  1 |  b = build wind non-float
     11  4  2  0  0  0  0 |  c = vehic wind float
      0  0  0  0  0  0  0 |  d = vehic wind non-float
      0  6  0  0  4  0  3 |  e = containers
      1  2  0  0  1  4  1 |  f = tableware
      1  2  1  0  1  2 22 |  g = headlamps

     

     

     

     

      在上图的折线图中,横坐标为噪声,纵坐标为分类准确率。对折线图进行分析,容易得到如下结论:
      第一,当噪声增大时,分类准确率随之下降;
      第二,改变k值,对分类正确率的影响较为复杂。当分类噪声百分比较小(低于60%) 时,增大k值会增加分类准确率:但分类噪声百分比较大(约高于60%)时,增大k值会降 低分类准确率。

     

     


    11、研究改变训练集大小的影响
      本节讨论学习曲线,显示训练数据量逐渐増加后的效果。同样使用玻璃数据集,但这—次使用IBk以及在Weka中的实现为J48的C4.5决策树学习器。
      获取学习曲线,再次使用FilteredClassifier分类器,这一次结合Resample (其全称为 weka. filters.unsupervised. instance.Resampie)过滤器,其功能是抽取出给定的一定比例的数据集,返回减少后的数据集。与上一个示例相同,只为第一批训练数据应用过滤器,所以测试数据通过FilteredClassifier分类器到达分类器之前,并不会受任何修改。

     

     

     

     


      具体步骤是,首先加载玻璃数据集,然后选择FilteredClassifier分类器。

     

     

     

     

       打开通用对象编辑器编辑该分类器的参数,分别选择classifier为IBk和J48, filter参数为Resample, 如下图所示。

     

     

     

     

     选择classifier为IBK(k=1)或J48。同时修改Resample过滤器的子样本大小百分比 sampleSizePercent参数,从10%—直到100%。

     

     

     .. 省略

     

     

     

     

     

     

     

     

      选择classifier为IBK(k=1)或J48。同时修改Resample过滤器的子样本大小百分比 sampleSizePercent参数,从10%—直到100%。

     

     ...省略

     

     

     

     

     


       每次设置完毕后,单击Start按钮启动训练和评估,将得到的分类正确率如下表中。

     

     

     

     

     

     

     

     

     

    4、聚类

      聚类是对物理对象或抽象对象的集合进行分组的过程,所生成的组

     

     

    展开全文
  • 该软件以 Java™ 语言编写并包含了一个图形界面来与数据文件交互并生成可视结果(比如表和曲线)。 WEKA除了作为一个独立PC应用外,它居然还有一个通用 API weka.jar,所以我们可以像嵌入其他的库一样将 WEKA 嵌入...
  • 异常点检测算法分析与选择

    千次阅读 2018-05-28 12:06:28
    为克服这一问题,一些人提出对数据集进行分布拟合,但分布拟合存在两个问题:①给出的分布可能不适合任一标准分布。②即使存在一个标准分布,分布拟合的过程耗时太长。此外,基于统计的离群检测算法大多只适合于挖掘...
  • 6.3.3 时间对比 6.3.4 拟合效果对比 6.3.5 预测过程的结果 6.4 结论 7. A self-adaptive classification method for plant disease detection using GMDH-Logistic model (IF=2.71, 2019) 7.1. 方法 7.2. 结论 8. ...
  • AutoML简介

    千次阅读 2020-04-09 00:20:01
    代理函数会计算出一条平均值曲线和对应的标准差(Standard Deviation)。有个代理函数,我们就可以找到一下个探索点。这个过程,用一个获取函数Acquisition Function里实现。 贝叶斯优化,是在一个特定的搜索空间...
  • 这是因为,如果当时的学习器能够拟合出的维度很有限(例如,超平面),这样很难完全将样本区分开,这就导致了在训练集和测试集上的结果差不多,当时的人们也就认为没有这么做的必要了。但是随着机器学习研究的深入,...
  • 在大多数情况下,结果都过度拟合A类数据。” 在数据不均衡的情况下,我们得到90%的准确率(比如包含90%的数据类型一的实例)是因为我们的模型观察数据并且智能地总是根据数据类型一的数据进行预测(A类数据),并...
  • ROC曲线(ROC Curves):见 Assessing and Comparing Classifier Performance with ROC Curves 对数据集进行重采样  可以使用一些策略该减轻数据的不平衡程度。该策略便是采样(sampling),主要有两种采样...
  • 最全的机器学习资料

    千次阅读 2018-10-08 12:53:27
    – Clojure中基于Weka及其相关环境的深度学习库; Encog – 在Clojure中封装成Encog (v3) (专门研究神经网络的机器学习框架); Fungp – Clojure中的遗传编程实例库; Statistiker – Clojure中基础...
  • 最后我的分类器对类A的样本过拟合了,而对其它两个类别的样本欠拟合。 什么是类别不均衡问题 类别数据不均衡是分类任务中一个典型的存在的问题。简而言之,即数据集中,每个类别下的样本数目相差很大。例如,...
  • 至少,你要知道机器学习中的基本概念:过拟合,生成模型,ROC曲线等,上来就看深度学习,如没有背景知识你将不知所云。另外,神经网络只是机器学习中的一类方法,对于很多问题,其他机器学习算法如logistic回归,...
  • 其次,尽管其他系统也包含剪枝,C4.5使用了一个单向的剪枝过程来缓解过渡拟合。剪枝给结果带来了很多改进。 再次,C4.5算法既可以处理连续数据也可以处理离散数据。我的理解是,算法通过对连续的数据指定范围或者...
  • ... 分类器是进行数据挖掘的一个工具,它处理大量需要进行分类的数据,并尝试预测新数据所属的类别。...用一个病人的数据属性集和对应病人...例如,一场考试的分数可能符合一种钟形曲线,因此这种分数分布符合钟形...
  •  回归在数学上来说是给定一个点集,能够用一条曲线拟合之,如果这个曲线是一条直线,那就被称为线性回归,如果曲线是一条二次曲线,就被称为二次回归,回归还有很多的变种,如locally weighted回归,logistic回归...
  •  回归在数学上来说是给定一个点集,能够用一条曲线拟合之,如果这个曲线是一条直线,那就被称为线性回归,如果曲线是一条二次曲线,就被称为二次回归,回归还有很多的变种,如locally weighted回归,logistic回归...
  • 最后我的分类器对类A的样本过拟合了,而对其它两个类别的样本欠拟合。 什么是类别不均衡问题   类别数据不均衡是分类任务中一个典型的存在的问题。简而言之,即数据集中,每个类别下的样本数目相差很大...
  • 数据挖掘工程师是做什么的?

    千次阅读 2016-08-09 10:04:09
    ConfusionMatrix(混淆矩阵),Precision(精确度),Recall(召回率),Accuracy(准确率),F-score(F得分),ROC Curve(ROC曲线),AUC(AUC面积),Lift Curve(Lift曲线) ,KS Curve(KS曲线)。 PGM...
  • 人工智能之机器学习路线图

    万次阅读 多人点赞 2016-09-07 23:21:02
    WEKA Machine Learning Workbench 相当于java中的scikit-learn 其他的工具如Massive Online Analysis(MOA)、MEKA 、 Mallet 等也非常有名。 更多详细的应用请参考这篇文章《25个Java机器学习工具&库》 ...
  • 机器学习系列(7)_机器学习路线图(附资料)

    万次阅读 多人点赞 2016-02-28 11:54:10
    WEKA Machine Learning Workbench 相当于java中的scikit-learn 其他的工具如 Massive Online Analysis(MOA) 、 MEKA 、 Mallet 等也非常有名。 更多详细的应用请参考这篇文章 《25个Java机器学习工具&库》...
  • 机器学习系列(7)_机器学习路线图(附资料)

    万次阅读 多人点赞 2016-02-28 11:55:21
    WEKA Machine Learning Workbench 相当于java中的scikit-learn 其他的工具如 Massive Online Analysis(MOA) 、 MEKA 、 Mallet 等也非常有名。 更多详细的应用请参考这篇文章 《25个Java机器学习工具&库》...
  • 看似学习难度大,曲线陡的机器学习,对大多数入门者也有一个比较通用的学习路径,也有一些优秀的入门资料可以降低大家的学习门槛,同时激发我们的学习乐趣。 简单说来,大概的一个学习路径如下: ...
  • 非线性回归 - 案例按步骤详解 -(SPSS建模)

    万次阅读 多人点赞 2019-02-15 13:09:27
     根据散点图,我们可以判断金额的变化趋势大致是一条曲线,倾向于指数型曲线,接下来验证一下,二次曲线和指数型曲线哪个拟合度更高! 第二步:模型拟合度对比,选择拟合度最高的模型 【分析】--【回归】--...
  • 机器学习路线图

    千次阅读 2016-03-10 18:51:27
    WEKA Machine Learning Workbench 相当于java中的scikit-learn 其他的工具如Massive Online Analysis(MOA)、MEKA 、 Mallet 等也非常有名。 更多详细的应用请参考这篇文章《25个Java机器学习工具&库》 C++系列 ...
  • pcurve包做主曲线(Principal Curve)分析和可视化。 gmodels包提供适合大矩阵的fast.prcomp()和fast.svd()。 kernlab包里的kpca()用核方法做非线性的主成分分析。 pcaPP包用投影寻踪(projection pursuit)法计算...

空空如也

空空如也

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

weka拟合曲线