1.FireBug

Firebug是测试Javascript,查看CSS和HTML的绝佳工具.你可以在修改代码后立即测试页面的变化.

点击下载  

2.Web Developer Extension

这个扩展是我最早听说也是最常用的一个网页设计扩展,当时修改模板的时候起了很大作用.它几乎囊括了网页设计的所有元素,主要作用在于监测和查看代码.

点击下载

3.Aardvark Extension

这个轻量级扩展可以简单地显示网页元素的Class和ID,当你只想快速获得某个元素的信息时非常有用,你还可以通过它移除网页上的元素.

点击下载

4.Colorzilla

直接从网页上获取色彩代码和RGB信息,相当于图像编辑软件里的拾色器.

点击下载

5.View Source With

使用多种外部软件查看网页代码.

点击下载

6.HTML Validator

快速验证HTML代码的合法性.

Windows平台下载

Linux平台下载

7.Measure It

距离测量工具.

点击下载

8.IE View / IE Tab / OperaView / FirefoxView / Safari View / IE View Lite

在Firefox中调用其他浏览器渲染网页.测试网页的兼容性时很有用.

9.Clear Cache Button

清除网页缓存,检查CSS更改时非常有用.

点击下载

10.Restart Firefox

在不损坏当前标签和进程的情况下重启Firefox.

点击下载

11.Tab Mix Plus

尽管这是一个常规扩展,但是复制标签和复制标签链接功能对网页设计很有作用.

点击下载

12.YSlow

Yslow是雅虎新近出品的一个网页分析工具.它能够给你提供网页错误信息以及网页优化建议.必须安装Firebug后才能使用该扩展.

background:orange;*background:blue;

区别IE6与IE7：

background:green !important;background:blue;

区别IE7与FF：

background:orange; *background:green;

区别FF，IE7，IE6：

background:orange;*background:green !important;*background:blue;

注：IE都能识别*;标准浏览器(如FF)不能识别*；

IE6能识别*，但不能识别 !important,

IE7能识别*，也能识别!important;

FF不能识别*，但能识别!important;

另外再补充一个，下划线"_",
IE6支持下划线，IE7和firefox均不支持下划线。

于是大家还可以这样来区分IE6，IE7，firefox
: background:orange;*background:green;_background:blue;

1.编写新学习方案
如果用户需要实现一个Weka所没有的特殊目的的学习算法,或者用户正在进行机器学习的研究,并且想试验一个新的学习方案,或者用户只是想通过亲自动手编程,了解更多有关一个归纳算法的内部运作,本节用一个简单的范例演示在编写分类器时,如何充分利用Weka的类的层级结构,从而满足用户的需要.

Weka包含了表15-1中所列的基本的、主要用于教育目的的学习方案.表中的方案对于接受命令行选项没有特别要求.它们对于理解分类器的内部运作都很有用.我们会将weka.classifiers.trees.Id3作为一个例子讨论,该方案实现了第4.3节中的ID3决策树学习器.
表15-1 Weka中的简单学习方案

方案  描述
weka.classifiers.bayes.NaiveBayesSimple  概率学习器
weka.classifiers.trees.Id3  决策树学习器
weka.classifiers.rules.Prism  规则学习器
weka.classifiers.lazy.IB1  基于实例的学习器

 
2．一个分类器范例
图15-1给出了weka.classifiers.trees.Id3的源代码,用户从代码中可看出它扩展Classifier类.无论是用于预测名词性类还是预测数值性类,每个Weka中的分类器都必须扩展Classifier类.
weka.classifiers.trees.Id3方案中的第一个方法是globalInfo():我们在进人到更有趣的部分之前先谈谈这个方法.当这个方案在Weka的图形用户界面上被选中时,该方法只是简单地返回一个显示在屏幕上的字符串.
package weka.classifiers.trees;
import weka.classifiers.*;
import weka.core.*;
import java.io.*;
import java.util.*;
/**
* Class implementing an Id3 decision tree classifier.
*/
public class Id3 extends Classifier {
/** The node's successors. */
private Id3[] m_Successors;
/** Attribute used for splitting. */
private Attribute m_Attribute;
/** Class value if node is leaf. */
private double m_ClassValue;
/** Class distribution if node is leaf. */
private double[] m_Distribution;
/** Class attribute of dataset. */
private Attribute m_ClassAttribute;
/**
* Returns a string describing the classifier.
* @return a description suitable for the GUI.
*/
public String globalInfo() {
return "Class for constructing an unpruned decision tree based on the ID3 "
+ "algorithm. Can only deal with nominal attributes. No missing values "
+ "allowed. Empty leaves may result in unclassified instances. For more "
+ "information see: \n\n"
+ " R. Quinlan (1986). \"Induction of decision "
+ "trees\". Machine Learning. Vol.1, No.1, pp. 81-106";
}
/**
* Builds Id3 decision tree classifier.
*
* @param data the training data
* @exception Exception if classifier can't be built successfully
*/
public void buildClassifier(Instances data) throws Exception {
if (!data.classAttribute().isNominal()) {
throw new UnsupportedClassTypeException("Id3: nominal class, please.");
}
Enumeration enumAtt = data.enumerateAttributes();
while (enumAtt.hasMoreElements()) {
if (!((Attribute) enumAtt.nextElement()).isNominal()) {
throw new UnsupportedAttributeTypeException("Id3: only nominal " +
"attributes, please.");
}
}
Enumeration enum = data.enumerateInstances();
while (enum.hasMoreElements()) {
if (((Instance) enum.nextElement()).hasMissingValue()) {
throw new NoSupportForMissingValuesException("Id3: no missing values, "
+ "please.");
}
}
data = new Instances(data);
data.deleteWithMissingClass();
makeTree(data);
}
/**
* Method for building an Id3 tree.
*
* @param data the training data
* @exception Exception if decision tree can't be built successfully
*/
private void makeTree(Instances data) throws Exception {
// Check if no instances have reached this node.
if (data.numInstances() == 0) {
m_Attribute = null;
m_ClassValue = Instance.missingValue();
m_Distribution = new double[data.numClasses()];
return;
}
// Compute attribute with maximum information gain.
double[] infoGains = new double[data.numAttributes()];
Enumeration attEnum = data.enumerateAttributes();
while (attEnum.hasMoreElements()) {
Attribute att = (Attribute) attEnum.nextElement();
infoGains[att.index()] = computeInfoGain(data, att);
}
m_Attribute = data.attribute(Utils.maxIndex(infoGains));
// Make leaf if information gain is zero.
// Otherwise create successors.
if (Utils.eq(infoGains[m_Attribute.index()], 0)) {
m_Attribute = null;
m_Distribution = new double[data.numClasses()];
Enumeration instEnum = data.enumerateInstances();
while (instEnum.hasMoreElements()) {
Instance inst = (Instance) instEnum.nextElement();
m_Distribution[(int) inst.classValue()]++;
}
Utils.normalize(m_Distribution);
m_ClassValue = Utils.maxIndex(m_Distribution);
m_ClassAttribute = data.classAttribute();
} else {
Instances[] splitData = splitData(data, m_Attribute);
m_Successors = new Id3[m_Attribute.numValues()];
for (int j = 0; j < m_Attribute.numValues(); j++) {
m_Successors[j] = new Id3();
m_Successors[j].makeTree(splitData[j]);
}
}
}
/**
* Classifies a given test instance using the decision tree.
*
* @param instance the instance to be classified
* @return the classification
*/
public double classifyInstance(Instance instance)
throws NoSupportForMissingValuesException {
if (instance.hasMissingValue()) {
throw new NoSupportForMissingValuesException("Id3: no missing values, "
+ "please.");
}
if (m_Attribute == null) {
return m_ClassValue;
} else {
return m_Successors[(int) instance.value(m_Attribute)].
classifyInstance(instance);
}
}
/**
* Computes class distribution for instance using decision tree.
*
* @param instance the instance for which distribution is to be computed
* @return the class distribution for the given instance
*/
public double[] distributionForInstance(Instance instance)
throws NoSupportForMissingValuesException {
if (instance.hasMissingValue()) {
throw new NoSupportForMissingValuesException("Id3: no missing values, "
+ "please.");
}
if (m_Attribute == null) {
return m_Distribution;
} else {
return m_Successors[(int) instance.value(m_Attribute)].
distributionForInstance(instance);
}
}
/**
* Prints the decision tree using the private toString method from below.
*
* @return a textual description of the classifier
*/
public String toString() {
if ((m_Distribution == null) && (m_Successors == null)) {
return "Id3: No model built yet.";
}
return "Id3\n\n" + toString(0);
}
/**
* Computes information gain for an attribute.
*
* @param data the data for which info gain is to be computed
* @param att the attribute
* @return the information gain for the given attribute and data
*/
private double computeInfoGain(Instances data, Attribute att)
throws Exception {
double infoGain = computeEntropy(data);
Instances[] splitData = splitData(data, att);
for (int j = 0; j < att.numValues(); j++) {
if (splitData[j].numInstances() > 0) {
infoGain -= ((double) splitData[j].numInstances() /
(double) data.numInstances()) *
computeEntropy(splitData[j]);
}
}
return infoGain;
}
/**
* Computes the entropy of a dataset.
*
* @param data the data for which entropy is to be computed
* @return the entropy of the data's class distribution
*/
private double computeEntropy(Instances data) throws Exception {
double [] classCounts = new double[data.numClasses()];
Enumeration instEnum = data.enumerateInstances();
while (instEnum.hasMoreElements()) {
Instance inst = (Instance) instEnum.nextElement();
classCounts[(int) inst.classValue()]++;
}
double entropy = 0;
for (int j = 0; j < data.numClasses(); j++) {
if (classCounts[j] > 0) {
entropy -= classCounts[j] * Utils.log2(classCounts[j]);
}
}
entropy /= (double) data.numInstances();
return entropy + Utils.log2(data.numInstances());
}
/**
* Splits a dataset according to the values of a nominal attribute.
*
* @param data the data which is to be split
* @param att the attribute to be used for splitting
* @return the sets of instances produced by the split
*/
private Instances[] splitData(Instances data, Attribute att) {
Instances[] splitData = new Instances[att.numValues()];
for (int j = 0; j < att.numValues(); j++) {
splitData[j] = new Instances(data, data.numInstances());
}
Enumeration instEnum = data.enumerateInstances();
while (instEnum.hasMoreElements()) {
Instance inst = (Instance) instEnum.nextElement();
splitData[(int) inst.value(att)].add(inst);
}
for (int i = 0; i < splitData.length; i++) {
splitData[i].compactify();
}
return splitData;
}
/**
* Outputs a tree at a certain level.
*
* @param level the level at which the tree is to be printed
*/
private String toString(int level) {
StringBuffer text = new StringBuffer();
if (m_Attribute == null) {
if (Instance.isMissingValue(m_ClassValue)) {
text.append(": null");
} else {
text.append(": " + m_ClassAttribute.value((int) m_ClassValue));
}
} else {
for (int j = 0; j < m_Attribute.numValues(); j++) {
text.append("\n");
for (int i = 0; i < level; i++) {
text.append("| ");
}
text.append(m_Attribute.name() + " = " + m_Attribute.value(j));
text.append(m_Successors[j].toString(level + 1));
}
}
return text.toString();
}
/**
* Main method.
*
* @param args the options for the classifier
*/
public static void main(String[] args) {
try {
System.out.println(Evaluation.evaluateModel(new Id3(), args));
} catch (Exception e) {
System.err.println(e.getMessage());
}
}
}
图15-1 ID3决策树学习器的源代码
3．buildClassifier()

buildClassifier()方法根据训练数据集构建一个分类器.因为ID3算法无法处理非名词性类,残缺属性值,或任何非名词性的属性,因此,buildClassifier()方法首先在数据中对以上提到的进行查验.然后,它会生成一个训练集的复制件(以避免改变原始数据),并调用weka.core.Instances中的一个方法来删除所有含残缺类值的实例,因为这些实例在训练过程中不起作用.最后,它会调用makeTree(),该方法实际上通过递归的方式产生所有附加到根节点上的子树,从而生成一个决策树.
4．makeTree()

在makeTree()中,第一步是检查数据集是否为空.如果是,通过将m_Attribute设为空生成一个叶节点.为该叶指定的类值m_ClassValue设定为残缺,且m_Distribution中为数据集中的每个类所估计的概率皆初始化为0.如果训练实例已准备好,makeTree()会找出令这些实例产生最大信息增益的属性.它首先生成一个数据集属性的Java枚举.如果类属性的索引已经设定,像正在讨论的这个数据集设定一样,该类属性会被自动排除在该枚举之外.

在枚举内部,每个属性的信J氢增益都由computelnfoGain()计算出来并存储在一个数组中.我们以后会重新讲这个方法.weka.core.Attribute中的index()方法可返回数据集中属性的索引.它可为刚刚提到的数组编制索引.一旦完成了枚举,具有最大信息增益的属性就会存储在实例变量m Attribute中.weka.core.Utils中的maxlndex()方法会返回一个由整数或双精度浮点小数构成的数组中最大值的索引.(如果具有最大值的组元不止一个,那么只有第一个被返回.)该属性的索引会被传给weka.core.Instances中的attribute()方法,该方法返回与索引相对应的属性.

用户也许在想,数组中与类属性相对应的那个值域怎么样了?这个不必担心,因为Java会自动将数组中所有组元初始化为整数0,而信息增益总是大于或等于0.如果最大信息增益是0,makeTree()会生成一个叶节点.在这种情况下,makeTree()会设为空,且makeTree()会同时计算类概率的分布以及具有最大概率的类.(weka,core.Utils中的normalize()方法会将一个双精度浮点小数数组正常化使其组员相加总和为1.)

当它产生一个已指定类值的叶节点时,makeTree()将类属性存储到m_ClassAttrfbute中.这是因为用来输出决策树的方法需要读取该类值以便显示类标签.

如果发现了一个具有非零信息增益的属性,makeTree()会根据该属性的值分割数据集,并以递归的方式为每个新产生的数据集构建子树.该方法调用另一个方法splitData()进行分割.这样就会生成与属性值一样多个空的数据集,且把这些数据集存储到一个数组中(将每个数据集的初始容量设定为原始数据集中所含实例的数量),然后在原始数据集中将每个实例依次循环一遍,并在新数据集中根据相对应的属性值为这些实例开辟空间.然后压缩Instances对象以减少占用的存储器.返回到makeTree()后,所得到的数据集数组用于构建子树.该方法会生成一个由Id3对象构成的数组,数组中的每个对象对应着一个属性值9并将相对应的数据集传给makeTree(),从而在每个对象上调用该方法.
5．computeInfoGain()

现在回到corrtputeInfoGain(),与一个属性和一个数据集相关联的信息增益是用第4.3节中介绍过的方程式的一个直接实现计算出来的.首先计算出数据集的熵,然后用splitData()将数据集分割成子集,并在每个子集上调用computeEntr0py().最后,将前面计算出来的熵与后面计算出来的每个熵的加权总和相减的差,即信息增益返回.computeEntropy()方法使用weka.core.Utils中的log2()方法得出一个数的对数(以2为基数).
6．classifyInstance()

看过了ID3如何构建决策树,我们再来看如何利用树结构来预测类值及概率.每一个分类器都必须实现classifylnstance()方法或distributionFor.Instance()方法(或两个方法都实现).Classifier超类含有这两种方法的默认实现.classifylnstance()的默认实现调用distributionForlns tance().如果类是名词性的,classifyInstance()会把具有最大概率的属性预测为类,否则,如果从distributionForInstance()返回的所有概率都是零,classifylllstarlce()会返回一个残缺值.如果类是数值性的,distributionForlnstance()必须返回有数值性预测的单一组元数组,该数组也就是classifylnstance()要提取并返回的.最后,distributionForlnstance()的默认实现反过来把从classifyInstance()中得来的预测包装成一个单一组元数组.如果类是名词性的,distributionForInstance()将概率1指定给classihzlnstance()预测出的类属性,把概率0指定给其他属性.如果classi.fylnstance()返回一个残缺值,所有属性的概率都设为0.为了让用户更好地了解这些方法所做的工作,weka.classifiers.trees,Id3类重新编写了这两个方法.

我们先来看看针对一个给定实例预测类值的classifylnstance().上一节曾经讲过,与名词性属性值一样,名词性类值是以double变量的形式编码及存储的,表示值的名字在属性声明中的索引.这种更简洁有效的面向对象的处理方式可加快运行速度.在ID3的实现中,classifyInstance()首先查看待分类的实例中是否有残缺值.如果有的话,就丢弃一个异常.否则,它就以递归的方式,根据待分类实例的属性值,沿着树自上而下,直至到达某个末端叶节点.然后,它会返回存储在该叶节点的类值m_ClassValue.要注意所返回的也有可能是残缺值,如果是残缺值,该实例则成为未被分类的实例.distributionForInstance()方法的工作方式与此完全一样,它返回存储于m_Distribution中的概率分布.

大多数机器学习模型,特别是决策树,大致上全面反映了数据本身的结构.因此每个Weka分类器,如同许多其他Java对象一样,实现toString()方法从而以字符串变量的形式生成一个它自身的文本表述.ID3的toString()方法输出一个与J4.8格式大致相同的决策树(图10-5).它通过读取存储于节点上的属性信息,以递归的方式将树的结构输入一个字符串变量.它使用weka.core.Attribute中的name()和value()方法得到每个属性的名字和值.不含类值的空末端叶节点由字符串null标示出来.
7．main()

weka.classifiers.tree.Id3中还没有被描述的唯一方法就是main(),每当由命令行执行一个类, 该方法都会被调用.正如用户看到的一样,该方法很简单:基本上就是告诉Weka的类Evaluation用所给的命令行选项评估Id3,并输出所得到的字符串.完成此项任务的单行表达式就包含在一个try-catch语句中,该语句能捕获各种各样由Weka例程或其他Java方法丢出的异常.

Weka.classifiers.Evaluation中的evaluation()方法解释了第13.3节中讨论过的,可适用于任何学习方案的通用命令行选项及相应的作用.例如,它可接受训练文件名字的-L选项,并载人相对应的数据集.如果没有测试文件,它就进行交叉验证,方式是生成一个分类器,并在训练数据的不同的子集上重复调用buildClassifier(),classify Instance()和distributionForlnstance().除非用户设定了相应的命令行选项从而阻止模型的输出,它还会调用toString()方法,输出由整个训练数据集生成的模型.

如果某个学习方案需要解释一个具体的选项,比如一个修剪参数,怎么办?这可由weka.core中的OptionHandler接口来解决.实现该接口的分类器含有三个方法:listOptions(),setOptions()和getOption().它们分别用来列出所有针对该分类器的选项,设定其中某些选项,以及取得目前已设定的选项.如果一个分类器实现了OptionHandle r接口,Evaluation类中的evaluation()方法会自动调用这些方法.处理完通用选项后,evaluation()会调用setOption()来处理余下的选项,然后利用buildClassifier()产生一个新的分类器.输出所产生的分类器,evaluation()会用getOptions()输出一列目前已设定的选项.在weka.classifiers.rules.0neR的源代码中可找到一个如何实现这些方法的简单范例.

OptionHandler使得在命令行中设定选项成为可能.要在图形用户界面中设定这些选项,Weka使用的是Java豆的架构.实施该构架所要做的全部工作就是为一个类中所用到的每个参数都提供set...()及get...()方法.比方说,方法setPruningParameter()和getPruningParameter()对于一个修剪参数来说就是必须的.还有一个方法也必不可少,pruningParameterTipText()返回的是显示在图形用户界面上的对该参数的一个描述.再强调一次,见weka.classifiers.rules.OneR中的例子.

一些分类器可在新的训练实例陆续到达时进行递增更新,并且不需要在同一批中处理全部数据.在Weka中,递增分类器须实现weka.classifiers中的UpdateableClassifier接口.该接口只声明了一个名为updateClassifier()的方法,该方法只接受一个单独的训练实例作为它的可变参数.要参考一个如何使用该接口的例子,见weka.classifiers.lazy.IBk的源代码.

如果一个分类器能运用实例的权,它必须实现weka.core中的Weightedlnstartce sHandler()接口.如此一来其他的算法,比方说那些用于提升的算法,就可对该属性加以利用.

在weka.core中还有很多其他对于分类器来说很有用的接口,例如,rondomizable,summarizable,drawable,和graphable这些用于分类器的接口.有关接口的更多信息,见weka.core中相应类的Javadoc.
8．与实现分类器有关的惯例

在实现Weka中的分类器时,有一些惯例用户必须遵守.否则,程序会出错.比方说,Weka的评估模块在评估分类器时可能会无法恰当地计算它的统计数据.
第一个惯例前面已经提到过,当一个分类器的buildClassifier()方法被调用时,必须令模型重新复位.类CheckClassifier进行测试,确保模型的确被复位了.当buildC`assifier()在某个数据集上被调用时,无论该分类器以前已经在同一个或其他的数据集上被调用过多少次,所得到的结果必须是一样的.还有,一些实例变量是与某些只适用于具体方案的选项相对应的,buildClassifier()方法绝对不可以将这些变量复位,因为这些变量的值一旦被设定,它们在多次调用buildClassifier()的过程中必须保持不变.还有,调用buildClassifier()绝对不可以改动输人数据.

另外两个惯例以前也提到过.一个是当某个分类器无法做出预测时,它的classifyInstance()方法必须返回Instance.missingValue(),且它的distributionForlnstance()方法必须针对所有类属性都返回0概率.图15-1中的ID3实现就是这么做的.另外一个惯例是这样的,对手用作数值性预测的分类器来说,它的classifyInstance()要返回分类器所预测出的数值性类值.还有一些分类器可以对名词性的类和类概率,以及数值性的类值做出预测,weka.classifiers.lazy.IBk就是一个例子.这些分类器实现了distributionForlnstance()方法,如果类是数值性的,它会返回一个单一组元数组,其唯一组元就含有所预测的数值性值.

另外一个惯例虽然并不是不可或缺,但不管怎么说都是有益的,即每个分类器都实现一个toString()方法,用于输出一个它自身的文本描述.

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/comlc/archive/2007/12/13/1933775.aspx

Weka3.5后增加了libsvm这个选项，在分类器中的functions下面。但是，试图运行的时候，系统提示：Problem uating classifier:libsvm classes not in CLASSPATH。这是因为Weka只是提供了Libsvm的Wrapper调用机制，必须要安装Libsvm后将附带的jar路径添加到Weka的启动路径中。怎么解决呢？我的Weka版本较新（3.5.7），不过我的方法适用于3.5以上的所有版本。

首先，在http://www.cs.iastate.edu/~yasser/wlsvm/上下载wlsvm.zip的压缩包，解压后将WLSVM \ lib 文件夹下的libsvm.jar 和wlsvm.jar 两个文件放到weka的安装目录下。

然后，在weka的安装目录下打开runweka.ini这个文件，把
cmd_default=javaw -Xmx#maxheap# -classpath "%CLASSPATH%;#weka.jar#" #mainclass#
修改为
cmd_default=javaw -Xmx#maxheap# -classpath "%CLASSPATH%;#weka.jar#;wlsvm.jar;libsvm.jar" #mainclass# （注：其实3.4版本是要将wlsvm.jar加进去的，但3.5版本就没有必要了，只用加libsvm.jar就好了）。

最后，直接运行runweka.bat，再打开Explorer，可以在Classify的Classifier-function中找到LibSVM，像使用其它Classifier一样使用它就可以了。这样LibSVM就成功的集成到Weka了。

至于还有帖子教怎么设置libsvm的路径之类的，其实刚刚修改runweka.ini文件时已经完成了这一步了，大可不必再大费周折了，我试过了，不在环境变量里设置ClassPath就按照上面三步设置就完全可以使用LibSVM了。

附：

LIBSVM简介
支持向量机所涉及到的数学知识对一般的化学研究者来说是比较难的，自己编程实现该算法难度就更大了。但是现在的网络资源非常发达，而且国际上的科学研究者把他们的研究成果已经放在网络上，免费提供给用于研究目的，这样方便大多数的研究者，不必要花费大量的时间理解SVM算法的深奥数学原理和计算机程序设计。目前有关SVM计算的相关软件有很多，如LIBSVM、mySVM、SVMLight等，这些软件大部分的免费下载地址和简单介绍都可以在http://www.kernel-machines.org/上获得。
LIBSVM是台湾大学林智仁(Lin Chih-Jen)副教授等开发设计的一个简单、易于使用和快速有效的SVM模式识别与回归的软件包，他不但提供了编译好的可在Windows系列系统的执行文件，还提供了源代码，方便改进、修改以及在其它操作系统上应用；该软件还有一个特点，就是对SVM所涉及的参数调节相对比较少，提供了很多的默认参数，利用这些默认参数就可以解决很多问题；并且提供了交互检验(Cross Validation)的功能。该软件包可以在http://www.csie.ntu.edu.tw/~cjlin/免费获得。该软件可以解决C-SVM分类、-SVM分类、-SVM回归和-SVM回归等问题，包括基于一对一算法的多类模式识别问题。在第2章中我们也介绍了该软件的一些优点，因此通过综合考虑，我们决定采用该软件作为工作软件。SVM用于模式识别或回归时，SVM方法及其参数、核函数及其参数的选择，目前国际上还没有形成一个统一的模式，也就是说最优SVM算法参数选择还只能是凭借经验、实验对比、大范围的搜寻或者利用软件包提供的交互检验功能进行寻优。

　　DBSCAN算法是常用的数据挖掘算法。所有的聚类方法分为若干类型，前面讨论过的KMEANS算法是基于划分的方法进行聚类，而这次提到的DBSCAN算法是基于密度的方法。当然其它的还有基于层次凝聚和分裂的方法、基于模型的方法等。我先对Weka中实现的DBSCAN算法进行一个介绍和分析，然后再分析自己用C#实现的DBSCAN方法。但在这之前要解释几个概念，如果之前没有了解过这个算法的话，最好是先熟悉几个概念：epsilon-邻域、核心对象、（直接）密度可达、密度相连，这些概念可以在《数据挖掘概念与技术》一书中找到，了解这些概念对理解这个算法来说是很重要的。

　　我们先来看看在Weka中是如何实现DBSCAN算法的：

　　DBSCAN算法的源代码在Weka的weka.clusterers这个包中，文件名为DBScan.java。其中buildClusterer和expandCluster这两个方法是最核心的方法。buildClusterer是所有聚类方法的接口方法，而expandCluster是用于扩展样本对象集合的高密度连接区域的。另外还有一个叫epsilonRangeQuery的方法，这个方法位置Database类中，用于查询指定对象在epsilon邻域内的样本对象集合。

　　在buildClusterer方法中，通过对每个未聚类的样本点调用expandCluster方法进行处理，查找由这个对象开始的密度相连的最大样本对象集合。在这个方法中处理的主要代码如下，当expandCluster方法返回真的时候就说明一个簇已经形成，取下一个聚类标号。

Weka.DBSCAN
while (iterator.hasNext()) {
　　　 DataObject dataObject = (DataObject) iterator.next();
　　　 if (dataObject.getClusterLabel() == DataObject.UNCLASSIFIED) {
　　　　　　　 if (expandCluster(dataObject)) {
　　　　　　　　　　　 clusterID++;
　　　　　　　　　　　 numberOfGeneratedClusters++;
　　　　　　　　 }
　　　 }
}

2.由于FuzzyCMeans是聚类算法，所以直接将FuzzyCMeans.java 源程序考到 weka.clusterers 包下。

3.再修改weka.gui.GenericObjectEditor.props ，在#Lists the Clusterers I want to choose from的weka.clusterers.Clusterer=\下加入：weka.clusterers.FuzzyCMeans。

4.相应的修改weka.gui.GenericPropertiesCreator.props ，此去不用修改，因为包weka.clusterers已经存在，若加入新的包时则必须修改这里，加入新的包。

加入之后，重新编译，运行后，可以在weka的Explorer界面上的Cluster选项卡中的聚类算法中找到刚刚新添加的FuzzyCMeans算法。

添加过程的关键问题是要弄清楚Weka的内核以及其接口标准，然后编写出符合此规范的新算法。

150M的训练集用WEKA做起来应该比较困难。我想有这么几个办法：

1 增加内存。 其实WEKA不光可以用物理内存，还可以占用虚拟内存。把JAVA的可用内存设置成2G的话，如果机器的物理内存只有1G，操作系统是会在需要时自动在硬盘上划分一块出来作为虚拟内存的。不过这时候一般会处理得比较慢，因此不推荐这个方法。

2 抽样。从训练集中随机抽取一部分数据来作训练。在二分类的时候，一般样本数量达到几千个时就能预测得比较准确了。如果几千个样本还不怎么准，那要么是所用的分类算法不适合，要么数据中的输入变量根本无法预测目标变量。
我试过了KDD 99中“kddcup.data_10_percent” 数据集，接近50万条数据，做成ARFF文件后有70多M。在Explorer中10来秒就载入了，抽取1%的样本仅花了几秒钟。

3 增量学习（Incremental Learning）。所谓增量学习简单的说就是读取一条训练数据就修正一下模型，而不是把全部训练数据都读入之后才得到模型。在WEKA KnowledgeFlow 中支持增量学习算法。目前WEKA中有5种算法可以在这种方式下工作：NaiveBayesUpdateable, IB1, IBk, LWR。另外RacedIncrementalLogitBoost可以让任意的基于回归的算法来增量地学习分类任务。

要注意的是，有时候数据不是ARFF格式的，而是C45,CSV等格式。这时手动把数据转换成ARFF，会节省很多内存，并且数据集中的错误更容易被检测出来。 
 

如果没有进行设置的话，在使用MyEclipse的经常出现如下图所示内存不足的提示。

提示中说的很明白：“MyEclipse has detected that less than 5% of the 64MB of Perm Gen (Non-heap memory) space remains.”意思是说当前只有小于5%的非堆内存是空闲的。所以我们只要将这个值设置大一些就可以了。

提示中给出了设置的参数：

这里有几个问题：
1. 各个参数的含义什么？
2. 为什么有的机器我将-Xmx和-XX:MaxPermSize都设置为512M之后Eclipse可以启动，而有些机器无法启动？
3. 为何将上面的参数写入到eclipse.ini文件Eclipse没有执行对应的设置？

下面我们一一进行回答

1. 各个参数的含义什么？

参数中-vmargs的意思是设置JVM参数，所以后面的其实都是JVM的参数了，我们首先了解一下JVM内存管理的机制，然后再解释每个参数代表的含义。

堆(Heap)和非堆(Non-heap)内存
按照官方的说法：“Java 虚拟机具有一个堆，堆是运行时数据区域，所有类实例和数组的内存均从此处分配。堆是在 Java 虚拟机启动时创建的。”“在JVM中堆之外的内存称为非堆内存(Non-heap memory)”。可以看出JVM主要管理两种类型的内存：堆和非堆。简单来说堆就是Java代码可及的内存，是留给开发人员使用的；非堆就是JVM留给自己用的，所以方法区、JVM内部处理或优化所需的内存(如JIT编译后的代码缓存)、每个类结构(如运行时常数池、字段和方法数据)以及方法和构造方法的代码都在非堆内存中。

堆内存分配
JVM初始分配的内存由-Xms指定，默认是物理内存的1/64；JVM最大分配的内存由-Xmx指定，默认是物理内存的1/4。默认空余堆内存小于40%时，JVM就会增大堆直到-Xmx的最大限制；空余堆内存大于70%时，JVM会减少堆直到-Xms的最小限制。因此服务器一般设置-Xms、-Xmx相等以避免在每次GC 后调整堆的大小。

非堆内存分配
JVM使用-XX:PermSize设置非堆内存初始值，默认是物理内存的1/64；由XX:MaxPermSize设置最大非堆内存的大小，默认是物理内存的1/4。

JVM内存限制(最大值)
首先JVM内存限制于实际的最大物理内存(废话！呵呵)，假设物理内存无限大的话，JVM内存的最大值跟操作系统有很大的关系。简单的说就32位处理器虽然可控内存空间有4GB,但是具体的操作系统会给一个限制，这个限制一般是2GB-3GB（一般来说Windows系统下为1.5G-2G，Linux系统下为2G-3G），而64bit以上的处理器就不会有限制了。

2. 为什么有的机器我将-Xmx和-XX:MaxPermSize都设置为512M之后Eclipse可以启动，而有些机器无法启动？

通过上面对JVM内存管理的介绍我们已经了解到JVM内存包含两种：堆内存和非堆内存，另外JVM最大内存首先取决于实际的物理内存和操作系统。所以说设置VM参数导致程序无法启动主要有以下几种原因：

1) 参数中-Xms的值大于-Xmx，或者-XX:PermSize的值大于-XX:MaxPermSize；

2) -Xmx的值和-XX:MaxPermSize的总和超过了JVM内存的最大限制，比如当前操作系统最大内存限制，或者实际的物理内存等等。说到实际物理内存这里需要说明一点的是，如果你的内存是1024MB，但实际系统中用到的并不可能是1024MB，因为有一部分被硬件占用了。

3. 为何将上面的参数写入到eclipse.ini文件Eclipse没有执行对应的设置？

那为什么同样的参数在快捷方式或者命令行中有效而在eclipse.ini文件中是无效的呢？这是因为我们没有遵守eclipse.ini文件的设置规则：

参数形如“项 值”这种形式，中间有空格的需要换行书写，如果值中有空格的需要用双引号包括起来。比如我们使用-vm C:\Java\jre1.6.0\bin\javaw.exe参数设置虚拟机，在eclipse.ini文件中要写成这样：

1. -vm
2. C:\Java\jre1.6.0\bin\javaw.exe

按照上面所说的，最后参数在eclipse.ini中可以写成这个样子：

实际运行的结果可以通过Eclipse中“Help”-“About Eclipse SDK”窗口里面的“Configuration Details”按钮进行查看。

另外需要说明的是，Eclipse压缩包中自带的eclipse.ini文件内容是这样的：

其中–launcher.XXMaxPermSize（注意最前面是两个连接线）跟-XX:MaxPermSize参数的含义基本是一样的，我觉得唯一的区别就是前者是eclipse.exe启动的时候设置的参数，而后者是eclipse所使用的JVM中的参数。其实二者设置一个就可以了，所以这里可以把–launcher.XXMaxPermSize和下一行使用#注释掉。

参考资料：
JDK5.0垃圾收集优化之–Don’t Pause
提问：如何超越JVM内存限制？
MemoryMXBean (Java 2 Platform SE 5.0)
MyEclipse/Eclipse的内存优化与内存不足的解决办法
eclipse.ini文件的问题
eclipse 为什么报错

背景介绍：
1）Weka：
Weka有两种意思：一种不会飞的鸟的名字，一个机器学习开源项目的简称（Waikato Environment for Knowledge Analysis，http://www.cs.waikato.ac.nz/~ml/weka/）。我们这里当然要介绍的是第二种意思啦，Weka项目从1992年开始，由新西兰政府支持，现在已在机器学习领域大名鼎鼎。Weka里有非常全面的机器学习算法，包括数据预处理、分类、回归、聚类、关联规则等。Weka的图形界面对不会写程序的人来说非常方便，而且提供“KnowledgeFlow” 功能，允许将多个步骤组成一个工作流。另外，Weka也允许在命令行执行命令。
2）R
R就不用我废话了吧，呵呵，越来越受欢迎的统计软件（http://www.r-project.org/）。
3）R与Weka：
R里有很多机器学习的函数和包，不过Weka里提供的函数更全面更集中，所以我有时候需要用到Weka。以前我是这样用R和Weka的：
在R中准备好训练的数据（如：提取数据特征……）；
整理成Weka需要的格式（*.arff）；
在Weka里做机器学习（如：特征选择、分类……）；
从Weka的预测结果计算需要的统计量（如：sensitivity, specificity, MCC……）。
来回捣腾两个软件还是挺麻烦的；为了偷懒，我没学Weka的命令行，只会用图形界面的，在数据量大的时候非常受罪，有时候还会内存不够。现在发现R竟然提供了和Weka的接口函数包RWeka，以后方便多了哦，下面介绍一下RWeka的功能：

RWeka (http://cran.r-project.org/web/packages/RWeka/index.html) ：
1) 数据输入和输出
WOW()：查看Weka函数的参数。
Weka_control()：设置Weka函数的参数。
read.arff()：读Weka Attribute-Relation File Format (ARFF)格式的数据。
write.arff：将数据写入Weka Attribute-Relation File Format (ARFF)格式的文件。
2) 数据预处理
Normalize()：无监督的标准化连续性数据。
Discretize()：用MDL(Minimum Description Length)方法，有监督的离散化连续性数值数据。
3) 分类和回归
IBk()：k最近邻分类
LBR()：naive Bayes法分类
J48()：C4.5决策树算法（决策树在分析各个属性时，是完全独立的）。
LMT()：组合树结构和Logistic回归模型，每个叶子节点是一个Logistic回归模型，准确性比单独的决策树和Logistic回归方法要好。
M5P()：M5 模型数算法，组合了树结构和线性回归模型，每个叶子节点是一个线性回归模型，因而可用于连续数据的回归。
DecisionStump()：单层决策树算法，常被作为boosting的基本学习器。
SMO()：支持向量机分类
AdaBoostM1()：Adaboost M1方法。-W参数指定弱学习器的算法。
Bagging()：通过从原始数据取样(用替换方法)，创建多个模型。
LogitBoost()：弱学习器采用了对数回归方法,学习到的是实数值
MultiBoostAB()：AdaBoost 方法的改进，可看作AdaBoost 和 “wagging”的组合。
Stacking()：用于不同的基本分类器集成的算法。
LinearRegression()：建立合适的线性回归模型。
Logistic()：建立logistic回归模型。
JRip()：一种规则学习方法。
M5Rules()：用M5方法产生回归问题的决策规则。
OneR()：简单的1-R分类法。
PART()：产生PART决策规则。
4) 聚类
Cobweb()：这是种基于模型方法，它假设每个聚类的模型并发现适合相应模型的数据。不适合对大数据库进行聚类处理。
FarthestFirst()：快速的近似的k均值聚类算法
SimpleKMeans()：k均值聚类算法
XMeans()：改进的k均值法，能自动决定类别数
DBScan()：基于密度的聚类方法，它根据对象周围的密度不断增长聚类。它能从含有噪声的空间数据库中发现任意形状的聚类。此方法将一个聚类定义为一组“密度连接”的点集。
5）关联规则
Apriori()：Apriori是关联规则领域里最具影响力的基础算法，是一种广度优先算法，通过多次扫描数据库来获取支持度大于最小支持度的频繁项集。它的理论基础是频繁项集的两个单调性原则：频繁项集的任一子集一定是频繁的；非频繁项集的任一超集一定是非频繁的。在海量数据的情况下，Apriori 算法的时间和空间成本非常高。
Tertius()：Tertius算法。
6）预测和评估：
predict()：根据分类或聚类结果预测新数据的类别
table()：比较两个因子对象
evaluate_Weka_classifier()：评估模型的执行，如：TP Rate，FP Rate，Precision，Recall，F-Measure。

来源：http://rbbs.biosino.org/Rbbs/posts/list/196.page

下文对几种流行的开源数据挖掘平台进行了介绍。如果您想找寻更多的开源数据挖掘软件，可以到KDnuggets和Open Directory上查找。

（1） R
R（http://www.r-project.org）是用于统计分析和图形化的计算机语言及分析工具，为了保证性能，其核心计算模块是用C、C++和Fortran编写的。同时为了便于使用，它提供了一种脚本语言，即R语言。R语言和贝尔实验室开发的S语言类似。R支持一系列分析技术，包括统计检验、预测建模、数据可视化等等。在CRAN（http://cran.r-project.org）上可以找到众多开源的扩展包。
R软件的首选界面是命令行界面，通过编写脚本来调用分析功能。如果缺乏编程技能，也可使用图形界面，比如使用R Commander（http://socserv.mcmaster.ca/jfox/Misc/Rcmdr）或Rattle（http://rattle.togaware.com）。

（2） Tanagra
Tanagra（http://eric.univ-lyon2.fr/wricco/tanagra）是使用图形界面的数据挖掘软件，采用了类似Windows资源管理器中的树状结构来组织分析组件。Tanagra缺乏高级的可视化能力，但它的强项是统计分析，提供了众多的有参和无参检验方法。同时它的特征选取方法也很多。

（3） WEKA
WEKA（Waikato Environment for Knowledge Analysis, http://www.cs.waikato.ac.nz/ml/weka）可能是名气最大的开源机器学习和数据挖掘软件。高级用户可以通过Java编程和命令行来调用其分析组件。同时，WEKA也为普通用户提供了图形化界面，称为WEKA Knowledge Flow、WEKA Environment和WEKA Explorer。和R相比，WEKA在统计分析方面较弱，但在机器学习方面要强得多。在WEKA论坛（http://weka.wiki.sourceforge.net/Related+Projects）可以找到很多扩展包，比如文本挖掘、可视化、网格计算等等。很多其它开源数据挖掘软件也支持调用WEKA的分析功能。

（4） YALE/RapidMiner
YALE（Yet Another Learning Environment, http://rapid-i.com）现在已经更名为RapidMiner。并且商业化。它提供了图形化界面，采用了类似Windows资源管理器中的树状结构来组织分析组件，树上每个节点表示不同的运算符（operator）。YALE中提供了大量的运算符，包括数据处理、变换、探索、建模、评估等各个环节。YALE是用Java开发的，基于WEKA来构建，也就是说它可以调用WEKA中的各种分析组件。

（5） Bow
与Weka和Yale不同，Bow（http://www.cs.cmu.edu/~mccallum/bow）是专门为文本处理设计的开源包。Bow包含三个部分：Rainbow（文本分类）、Arrow（文本检索）和Crossbow（文本聚类）。

（6） AlphaMiner
AlphaMiner（http://www.eti.hku.hk/alphaminer）是哈工大-香港大学商务智能联合实验室基于WEKA内核开发的一个通用的数据挖掘系统，它能够帮助用户建立一个完整的数据挖掘流程，并提供一系列的功能使得用户可执行其中的任意挖掘步骤。AlphaMiner系统最主要的特点是它能够把开发好的数据挖掘案例保存在它的知识库中以便于日后重用。对于一般的商业管理人员，这个功能显著地提高了AlphaMiner系统的可用性。通过配合其它的数据分析工具，如在小型商业中广泛应用的Excel软件，AlphaMiner系统还提供了除了建立数据挖掘模型以外的一些辅助功能。

（7） KNIME
KNIME（Konstanz Information Miner, http://www.knime.org）是基于Eclipse开发环境来精心开发的数据挖掘工具。无需安装，方便使用。和YALE一样，KNIME也是用Java开发的，可以扩展使用WEKA中的挖掘算法。和YALE不同点的是，KNIME采用的是类似数据流（data flow）的方式来建立分析挖掘流程。挖掘流程由一系列功能节点（node）组成，每个节点有输入/输出端口（port），用于接收数据或模型、导出结果。
KNIME中每个节点都带有交通信号灯，用于指示该节点的状态（未连接、未配置、缺乏输入数据时为红灯；准备执行为黄灯；执行完毕后为绿灯）。在KNIME中有个特色功能——HiLite，允许用户在节点结果中标记感兴趣的记录，并进一步展开后续探索。

（8） Orange
Orange（http://www.ailab.si/orange）是类似KNIME和WEKA Knowledge Flow的数据挖掘工具，它的图形环境称为Orange画布（Orange Canvas），用户可以在画布上放置分析控件（widget），然后把控件连接起来即可组成挖掘流程。这里的控件和KNIME中的节点是类似的概念。每个控件执行特定的功能，但与KNIME中的节点不同，KNIME节点的输入输出分为两种类型（模型和数据），而Orange的控件间可以传递多种不同的信号，比如learners、classifiers、evaluation results、distance matrices、dendrograms等。Orange的控件不象KNIME的节点分得那么细，也就是说要完成同样的分析挖掘任务，在Orange里使用的控件数量可以比KNIME中的节点数少一些。Orange的好处是使用更简单一些，但缺点是控制能力要比KNIME弱。
除了界面友好易于使用的优点，Orange的强项在于提供了大量可视化方法，可以对数据和模型进行多种图形化展示，并能智能搜索合适的可视化形式，支持对数据的交互式探索。
Orange的弱项在于传统统计分析能力不强，不支持统计检验，报表能力也有限。Orange的底层核心也是采用C++编写，同时允许用户使用Python脚本语言来进行扩展开发（参见http://www.scipy.org）。

（9） GGobi
数据可视化是数据挖掘的重要组成部分，GGobi（http://www.ggobi.org）就是用于交互式可视化的开源软件，它使用brushing的方法。GGobi可以用作R软件的插件，或者通过Perl、Python等脚本语言来调用。

（10） Lucene
Apache Lucene（http://lucene.apache.org）是一个开放源程序的搜寻器引擎，利用它可以轻易地为Java软件加入全文搜寻功能。Lucene的最主要工作是替文件的每一个字作索引，索引让搜寻的效率比传统的逐字比较大大提高，Lucen提供一组解读，过滤，分析文件，编排和使用索引的API，它的强大之处除了高效和简单外，是最重要的是使使用者可以随时应自已需要自订其功能。

以上介绍的几款软件都是优秀的开源数据挖掘软件，各有所长，同时也各有缺点。读者可以结合自己的需求来进行选择，或者组合使用多个软件。对于普通用户可以选用界面友好易于使用的软件，对于希望从事算法开发的用户则可以根据软件开发工具不同（Java、R、C++、Python等）来选择相应的软件。

《数据挖掘：实用机器学习技术》第2版

论坛：

WEKA中文论坛http://bbs.wekacn.org/index.php

电子书：

ExplorerGuide-3[1].5.5.rar
ExperimenterTutorial-3.5.3.rar

网上教程：

weka入门教程1 http://blogger.org.cn/blog/more.asp?name=idmer&id=21854
weka入门教程2 http://blogger.org.cn/blog/more.asp?name=idmer&id=21856
weka入门教程3 http://blogger.org.cn/blog/more.asp?name=idmer&id=21857

在转换之前，我们需要将文本数据集按照TextDirectoryLoader转换器所要求形式布局：

-----------------------------------------------------------
...
 |
 +- example
    |
    +- class1
    |  |
    |  + file1.txt
    |  |
    |  + file2.txt
    |  |
    |  ...
    |
    +- class2
    |  |
    |  + another_file1.txt
    |  |
    |  + another_file2.txt
    |  |
    |  ...
-----------------------------------------------------------
 
按照上图所示的目录布局好文本数据后，将example文件夹放置在weka根目录下，我们利用WEKA的命令行界面（Simple CLI）输入以下命令：

java weka.core.converters.TextDirectoryLoader -dir example > example.arff

此时，可以发现在weka根目录下生成了一个example.arff文件，这说明文本数据已经成功转换成了WEKA需要的ARFF文件了。

example.arff文件内容下图所示，从图中可以发现example文件夹下的子文件夹名变成了每个文档的类标记。

-----------------------------------------------------------
@relation D__workspace_weka_example
@attribute text string
@attribute class {class1,class2,class3}
@data
‘文本内容’,class1
‘文本内容’,class3
‘文本内容’,class2
‘文本内容’,class1
‘文本内容’,class3
...
-----------------------------------------------------------

该方法对于中文文本数据不适用，生成的ARFF中的中文会变成乱码，需要修改WEKA的源码才能实现对中文文本数据的处理。

参考文献：http://weka.wiki.sourceforge.net/Text+categorization+with+Weka