Weka中数据挖掘与机器学习系列之Exploer界面（七）

　　不多说，直接上干货！

　　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
Relation:     weather.symbolic
Instances:
Attributes:
              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                              %
Incorrectly Classified Instances                               %
Kappa statistic
Mean absolute error
Root mean squared error
Relative absolute error                        %
Root relative squared error                    %
Coverage of cases (0.95 level)               %
Mean rel. region size (0.95 level)            %
Total Number of Instances                    

=== 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
   | a = yes
   | 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  :     

Size of the tree :     

　　上述文字表述构建的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:
Attributes:
              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                         33.3333 %
Incorrectly Classified Instances                      66.6667 %
Kappa statistic
Mean absolute error                      0.4444
Root mean squared error                  0.4714
Relative absolute error                      %
Root relative squared error                  %
Coverage of cases (0.95 level)               %
Mean rel. region size (0.95 level)           %
Total Number of Instances                   

=== 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
      |  a = Iris-setosa
      |  b = Iris-versicolor
      |  c = Iris-virginica

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

=== Run information ===

Scheme:       weka.classifiers.rules.ZeroR
Relation:     iris
Instances:
Attributes:
              sepallength
              sepalwidth
              petallength
              petalwidth
              class
Test mode:    -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                         33.3333 %
Incorrectly Classified Instances                      66.6667 %
Kappa statistic
Mean absolute error                      0.4444
Root mean squared error                  0.4714
Relative absolute error                      %
Root relative squared error                  %
Coverage of cases (0.95 level)               %
Mean rel. region size (0.95 level)           %
Total Number of Instances                   

=== 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
      |  a = Iris-setosa
      |  b = Iris-versicolor
      |  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:
Attributes:
              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:  seconds

=== Predictions on test set ===

 inst#     actual  predicted error prediction
           :yes      :yes       0.333 

=== Evaluation on test set ===

Time taken to test model on supplied test set:  seconds

=== Summary ===

Correctly Classified Instances                               %
Incorrectly Classified Instances                               %
Kappa statistic
Mean absolute error                      0.4444
Root mean squared error                  0.4714
Relative absolute error                      %
Root relative squared error                  %
Coverage of cases (0.95 level)               %
Mean rel. region size (0.95 level)           %
Total Number of Instances                     

=== 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
    | a = Iris-setosa
    | b = Iris-versicolor
    | c = Iris-virginica

3、使用决策规则

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

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

=== Run information ===

Scheme:       weka.classifiers.rules.JRip -F  -N 2.0 -O  -S
Relation:     weather.symbolic
Instances:
Attributes:
              outlook
              temperature
              humidity
              windy
              play
Test mode:    -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 : 

Time taken to build model: 0.01 seconds

=== Stratified cross-validation ===
=== Summary ===

Correctly Classified Instances                          64.2857 %
Incorrectly Classified Instances                        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)            %
Total Number of Instances                    

=== 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
   | a = yes
   | 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 : 

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

　　同样也可以可视化分类错误。右击结果列表中的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  -R 1.0E-8
Relation:     cpu
Instances:
Attributes:
              MYCT
              MMIN
              MMAX
              CACH
              CHMIN
              CHMAX
              class
Test mode:    -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                   

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

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

=== Run information ===

Scheme:       weka.classifiers.trees.M5P -M 4.0
Relation:     cpu
Instances:
Attributes:
              MYCT
              MMIN
              MMAX
              CACH
              CHMIN
              CHMAX
              class
Test mode:    -fold cross-validation

=== Classifier model (full training set) ===

M5 pruned model tree:
(using smoothed linear models)

CHMIN <= 7.5 : LM1 (/12.903%)
CHMIN >  7.5 :
|   MMAX <=  :
|   |   MMAX <=  :
|   |   |   CACH <= 81.5 : LM2 (/18.551%)
|   |   |   CACH >  81.5 : LM3 (/30.824%)
|   |   MMAX >   : LM4 (/24.185%)
|   MMAX >   : LM5 (/48.302%)

LM num:
class =
    -0.0055 * MYCT
    + 0.0013 * MMIN
    + 0.0029 * MMAX
    + 0.8007 * CACH
    + 0.4015 * CHMAX
    + 11.0971

LM num:
class =
    -1.0307 * MYCT
    + 0.0086 * MMIN
    + 0.0031 * MMAX
    + 0.7866 * CACH
    - 2.4503 * CHMIN
    + 1.1597 * CHMAX
    + 70.8672

LM num:
class =
    -1.1057 * MYCT
    + 0.0086 * MMIN
    + 0.0031 * MMAX
    + 0.7995 * CACH
    - 2.4503 * CHMIN
    + 1.1597 * CHMAX
    + 83.0016

LM num:
class =
    -0.8813 * MYCT
    + 0.0086 * MMIN
    + 0.0031 * MMAX
    + 0.6547 * CACH
    - 2.3561 * CHMIN
    + 1.1597 * CHMAX
    + 82.5725

LM num:
class =
    -0.4882 * MYCT
    + 0.0218 * MMIN
    + 0.003 * MMAX
    + 0.3865 * CACH
    - 1.3252 * CHMIN
    + 3.3671 * CHMAX
    - 51.8474

Number of Rules : 

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                   

　

　从上图可以看到，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.****.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:
Attributes:
              region-centroid-col
              region-centroid-row
              region-pixel-count
              short-line-density-
              short-line-density-
              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  -V - -W  -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:
Attributes:
              sepallength
              sepalwidth
              petallength
              petalwidth
              class
Test mode:    -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:  (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:  (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:  (61.381% cached)

Time taken to build model: 0.1 seconds

=== Stratified cross-validation ===
=== Summary ===

Correctly Classified Instances                              %
Incorrectly Classified Instances                               %
Kappa statistic                          0.94
Mean absolute error                      0.2311
Root mean squared error                  0.288
Relative absolute error                       %
Root relative squared error             61.101  %
Total Number of Instances                   

=== 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
      |  a = Iris-setosa
      |  b = Iris-versicolor
      |  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:
Attributes:
              sepallength
              sepalwidth
              petallength
              petalwidth
              class
Test mode:    -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                        66.6667 %
Incorrectly Classified Instances                       33.3333 %
Kappa statistic                          0.5
Mean absolute error                      0.2222
Root mean squared error                  0.3333
Relative absolute error                       %
Root relative squared error             70.7107 %
Coverage of cases (0.95 level)               %
Mean rel. region size (0.95 level)      55.5556 %
Total Number of Instances                   

=== 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
      |  a = Iris-setosa
      |  b = Iris-versicolor
      |  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
Relation:     ionosphere
Instances:
Attributes:
              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:    -fold cross-validation

=== Classifier model (full training set) ===

FilteredClassifier using weka.classifiers.trees.J48 -C 0.25 -M  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  :     

Size of the tree :     

Time taken to build model: 0.72 seconds

=== Stratified cross-validation ===
=== Summary ===

Correctly Classified Instances                        91.1681 %
Incorrectly Classified Instances                        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                   

=== 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
    |   a = b
    |   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  -W  -A "weka.core.neighboursearch.LinearNNSearch -A \"weka.core.EuclideanDistance -R first-last\""
Relation:     Glass
Instances:
Attributes:
              RI
              Na
              Mg
              Al
              Si
              K
              Ca
              Ba
              Fe
              Type
Test mode:    -fold cross-validation

=== Classifier model (full training set) ===

IB1 instance-based classifier
using  nearest neighbour(s) for classification

Time taken to build model:  seconds

=== Stratified cross-validation ===
=== Summary ===

Correctly Classified Instances                        70.5607 %
Incorrectly Classified Instances                       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                   

=== 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
              |  a = build wind float
             |  b = build wind non-float
               |  c = vehic wind float
               |  d = vehic wind non-float
              |  e = containers
               |  f = tableware
              |  g = headlamps

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

=== Run information ===

Scheme:       weka.classifiers.lazy.IBk -K  -W  -A "weka.core.neighboursearch.LinearNNSearch -A \"weka.core.EuclideanDistance -R first-last\""
Relation:     Glass
Instances:
Attributes:
              RI
              Na
              Mg
              Al
              Si
              K
              Ca
              Ba
              Fe
              Type
Test mode:    -fold cross-validation

=== Classifier model (full training set) ===

IB1 instance-based classifier
using  nearest neighbour(s) for classification

Time taken to build model:  seconds

=== Stratified cross-validation ===
=== Summary ===

Correctly Classified Instances                        67.757  %
Incorrectly Classified Instances                       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                   

=== 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
             |  a = build wind float
             |  b = build wind non-float
              |  c = vehic wind float
               |  d = vehic wind non-float
               |  e = containers
               |  f = tableware
              |  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  -W  -A "weka.core.neighboursearch.LinearNNSearch -A \"weka.core.EuclideanDistance -R first-last\""
Relation:     Glass
Instances:
Attributes:
              RI
              Na
              Mg
              Al
              Si
              K
              Ca
              Ba
              Fe
              Type
Test mode:    -fold cross-validation

=== Classifier model (full training set) ===

FilteredClassifier using weka.classifiers.lazy.IBk -K  -W  -A "weka.core.neighboursearch.LinearNNSearch -A \"weka.core.EuclideanDistance -R first-last\"" on data filtered through weka.filters.unsupervised.attribute.AddNoise -C last -P  -S 

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  nearest neighbour(s) for classification

Time taken to build model: 0.02 seconds

=== Stratified cross-validation ===
=== Summary ===

Correctly Classified Instances                        62.6168 %
Incorrectly Classified Instances                       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                   

=== 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
              |  a = build wind float
             |  b = build wind non-float
               |  c = vehic wind float
               |  d = vehic wind non-float
              |  e = containers
               |  f = tableware
              |  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  -W  -A "weka.core.neighboursearch.LinearNNSearch -A \"weka.core.EuclideanDistance -R first-last\""
Relation:     Glass
Instances:
Attributes:
              RI
              Na
              Mg
              Al
              Si
              K
              Ca
              Ba
              Fe
              Type
Test mode:    -fold cross-validation

=== Classifier model (full training set) ===

FilteredClassifier using weka.classifiers.lazy.IBk -K  -W  -A "weka.core.neighboursearch.LinearNNSearch -A \"weka.core.EuclideanDistance -R first-last\"" on data filtered through weka.filters.unsupervised.attribute.AddNoise -C last -P  -S 

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  nearest neighbour(s) for classification

Time taken to build model: 0.01 seconds

=== Stratified cross-validation ===
=== Summary ===

Correctly Classified Instances                        69.6262 %
Incorrectly Classified Instances                       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                   

=== 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
              |  a = build wind float
             |  b = build wind non-float
               |  c = vehic wind float
               |  d = vehic wind non-float
               |  e = containers
               |  f = tableware
              |  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  -W  -A "weka.core.neighboursearch.LinearNNSearch -A \"weka.core.EuclideanDistance -R first-last\""
Relation:     Glass
Instances:
Attributes:
              RI
              Na
              Mg
              Al
              Si
              K
              Ca
              Ba
              Fe
              Type
Test mode:    -fold cross-validation

=== Classifier model (full training set) ===

FilteredClassifier using weka.classifiers.lazy.IBk -K  -W  -A "weka.core.neighboursearch.LinearNNSearch -A \"weka.core.EuclideanDistance -R first-last\"" on data filtered through weka.filters.unsupervised.attribute.AddNoise -C last -P  -S 

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  nearest neighbour(s) for classification

Time taken to build model: 0.01 seconds

=== Stratified cross-validation ===
=== Summary ===

Correctly Classified Instances                        64.486  %
Incorrectly Classified Instances                       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                   

=== 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
              |  a = build wind float
             |  b = build wind non-float
              |  c = vehic wind float
               |  d = vehic wind non-float
               |  e = containers
               |  f = tableware
              |  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、聚类

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