为您推荐:
精华内容
最热下载
问答
  • 5星
    216KB m0_52957036 2020-02-28 14:17:44
  • 923KB tiny__boy 2019-12-31 15:17:51
  • 你也可以参考网上文档,将如下文的KNN_lsh.java复制到某一目录并进行相关设置,进而在weka gui中测试改进。 文件目录: /weka_test/src/cug/lsh/KNN_lsh.java 如下: package cug.lsh; import weka....

    本文在weka下,主要使用高斯函数加权,选取最优K值进行优化。你也可以参考网上文档,将如下文的KNN_lsh.java复制到某一目录并进行相关设置,进而在weka gui中测试改进。


    文件目录:

    这里写图片描述

    /weka_test/src/cug/lsh/KNN_lsh.java 如下:

    package cug.lsh;
    
    import weka.classifiers.*;
    import weka.core.*;
    import java.util.*;
    
    @SuppressWarnings("serial")
    public class KNN_lsh extends Classifier {
    
    	private Instances m_Train;
    	private int m_kNN;
    	
    	public void setM_kNN(int m_kNN) {
    		this.m_kNN = m_kNN;
    	}
    	
    	public void buildClassifier(Instances data) throws Exception {
    		m_Train = new Instances(data);	
    		
    	}
    
    	public double[] distributionForInstance(Instance instance) throws Exception {
    
    		Instances instances= findNeighbors(instance, m_kNN);
    		return computeDistribution(instances, instance);
    	}
    	
    	private Instances findNeighbors(Instance instance, int kNN) {
    		double distance;	
    		List<HasDisInstances> neighborlist = new LinkedList<>();
    		
    		for (int i = 0; i < m_Train.numInstances(); i++) {
    			Instance trainInstance = m_Train.instance(i);
    			distance = distance(instance, trainInstance);
    			HasDisInstances hasDisInstances=new HasDisInstances(distance,trainInstance);
    			
    			if(i==0 || (i<kNN-1 && neighborlist.get(neighborlist.size()-1).distance<distance))
    				neighborlist.add(hasDisInstances);
    			else{
    				for (int j = 0; j < kNN && j<neighborlist.size(); j++) {
    					if(distance<neighborlist.get(j).distance){
    						neighborlist.add(j, hasDisInstances);
    						break;
    					}
    				}
    			}
    		}
    		
    		int min=Math.min(kNN, neighborlist.size());
    		Instances instances=new Instances(m_Train,min);
    		for(int i=0;i<min;i++){
    			instances.add(neighborlist.get(i).instance);
    		}
    		return instances;
    	}
    
    	private double distance(Instance first, Instance second) {
    
    		double distance = 0;
    		for (int i = 0; i < m_Train.numAttributes(); i++) {
    			if (i == m_Train.classIndex())
    				continue;
    			if((int)first.value(i)!=(int)second.value(i)){
    		        distance+=1;
    		      }
    //			//此处修改距离计算公式
    //			distance+=(second.value(i)-first.value(i))*(second.value(i)-first.value(i));//欧基米德尔公式
    //			distance+=second.value(i)*Math.log(second.value(i)/first.value(i));最大熵
    //			distance+=Math.pow((second.value(i)-first.value(i)), 2)/first.value(i);//卡方距离
    		}
    //		distance=Math.sqrt(distance);
    		return distance;
    	}
    
    	private double[] computeDistribution(Instances data, Instance instance) throws Exception {
    		
    	    double[] prob=new double[data.numClasses()];
    
    	    for (int i=0;i<data.numInstances();i++){
    	      int classVal=(int)data.instance(i).classValue();
    	      double x=distance(instance, data.instance(i));
    	      prob[classVal] +=1+Math.exp(-x*x/0.18);//c=0.3
    	    }
    		Utils.normalize(prob);
    		return prob;
    	}
    
    	private class HasDisInstances{
    		double distance;
    		Instance instance;
    		public HasDisInstances(double distance, Instance instance) {
    			this.distance = distance;
    			this.instance = instance;
    		}
    	}
    }
    

    /weka_test/src/cug/lsh/KNN_lsh_use.java(主函数) 如下:

    package cug.lsh;
    
    import weka.core.Instances;
    import weka.core.converters.ConverterUtils.DataSource;
    
    public class KNN_lsh_use {
    	public static void main(String[] args) throws Exception {
    		Instances train=DataSource.read("E:/DataLearing/data/credit-g.arff");		
            train.setClassIndex(train.numAttributes()-1);  
            
            
            int size=(int) (train.numInstances()*0.2);//构造测试集
            Instances test = new Instances(train,size);
            test.setClassIndex(test.numAttributes()-1);
            for (int i = 0; i < size; i++) {
            	test.add(train.instance(i));
    			train.delete(i);
    		}     
            
            KNN_lsh classifier=new KNN_lsh();       
          //计算最佳k值
            int optiK=0;
            int prob=0;//临时变量,正确个数
            for (int m_kNN = 3; m_kNN < Math.sqrt(train.numInstances())+3  && m_kNN<=20; m_kNN++) {
    //        	long oldTime=System.currentTimeMillis();
            	classifier.setM_kNN(m_kNN);
                classifier.buildClassifier(train);
        
                int count=0;         
                for (int i = 0; i < test.numInstances(); i++){ 
                    if (classifier.classifyInstance(test.instance(i)) == test.instance(i).classValue())            
                        count++;   
                }
                if(count>prob){
                	optiK=m_kNN;
                	prob=count;
                }
    //            long newTime=System.currentTimeMillis();
    //            System.out.println(1.0*count/test.numInstances()+","+m_kNN+","+0.001*(newTime-oldTime));
    		}
            
            System.out.println(1.0*prob/test.numInstances()+","+optiK);
            
    	}
    }
    
    
    展开全文
    nima1994 2017-12-30 22:54:31
  • 刚开始接触Weka 可能就只是拿来跑跑数据 看看结果。 如果想更深入的

    刚开始接触Weka 可能就只是拿来跑跑数据 看看结果。 如果想做更深入的研究 就需要修改里面的参数或者开发改进算法,所以在Eclipse里写java代码 然后调用 weka函数包的重要性就凸显出来。

    在网上找了些资料,把好的整理一些出来,方便以后继续阅读。


    原文地址:http://www.360doc.com/content/09/0603/16/23378_3766416.shtml


    Weka学习一(分类器算法)


    从前年开始使用weka最数据挖掘方面的研究,到现在有一年半的时间了。看到我们同组的兄弟写了关于weka方面的总结,我也想整理一下。因为网上的资料实在是太少,记得刚接手的时候,真是硬着头皮看代码。不过到现在看来,也积累了很多的代码了。希望能够在这里跟大家分享一下学习weka的乐趣与经验。

    Weka是来之新西兰怀卡托大学的一款开源软件,主要是数据挖掘方面的一些算法的集合。这款软件大概是当前数据挖掘领域最好的开源软件了,当然国外还有其它一些组织维护的有自己的开源软件,但是只有这款软件应用是比较广泛的了。具体关于weka的信息可以到官网去查看http://www.cs.waikato.ac.nz/ml/weka/ ,软件的下载也可大家到官网去。

    我是从weka1.4一直用到现在的1.6版本的,其间weka在图形界面上有一些变动,但是底层的框架结构没有太大的变化,主要是添加一些新的算法什么的。总之大家可以放心的使用。我现在积累的代码是从1.5版本积累下来的,到现在1.6版本,集成起来一点问题都没有,这大概也是我喜欢weka的一个原因。

    数据挖掘的过程一般如下:

    1.       读入训练、测试样本

    2.       初始化分类器

    3.       使用训练样本训练分类器

    4.       使用测试样本测试分类器的学习效果

    5.       打印分类结果

    我们现在看看一个简单的实例

     

    package com.csdn;

     

    import java.io.File;

     

    import weka.classifiers.Classifier;

    import weka.classifiers.Evaluation;

    import weka.core.Instance;

    import weka.core.Instances;

    import weka.core.converters.ArffLoader;

     

    /*

     * Date: 2009.4.1

     * by: Wang Yi

     * Email: wangyi19840906@yahoo.com.cn

     * QQ: 270135367

     *

     */

    public class Test {

     

        /**

         * @param args

         */

        public static void main(String[] args) {

           // TODO Auto-generated method stub

           Instances ins = null;

          

           Classifier cfs = null;

           try{

              

               /*

                * 1.读入训练、测试样本

                * 在此我们将训练样本和测试样本作为同一个样本

                */

               File file= new File("C:\\Program Files\\Weka-3-6\\data\\contact-lenses.arff");

               ArffLoader loader = new ArffLoader();

               loader.setFile(file);

               ins = loader.getDataSet();

              

               //在使用样本之前一定要首先设置instancesclassIndex,否则在使用instances对象是会抛出异常

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

              

               /*

                * 2.初始化分类器

                * 具体使用哪一种特定的分类器可以选择,请将特定分类器的class名称放入forName函数

                * 这样就构建了一个简单的分类器

                */

               cfs = (Classifier)Class.forName("weka.classifiers.bayes.NaiveBayes").newInstance();

              

               /*

                * 3.使用训练样本训练分类器

                */

               cfs.buildClassifier(ins);

              

              

               /*

                * 4.使用测试样本测试分类器的学习效果

                * 在这里我们使用的训练样本和测试样本是同一个,在实际的工作中需要读入一个特定的测试样本

                */

               Instance testInst;

               /*

                * Evaluation: Class for evaluating machine learning models

                * 即它是用于检测分类模型的类

                */

               Evaluation testingEvaluation = new Evaluation(ins);

               int length = ins.numInstances();

               for (int i =0; i < length; i++) {

                  testInst = ins.instance(i);

                  //通过这个方法来用每个测试样本测试分类器的效果

                  testingEvaluation.evaluateModelOnceAndRecordPrediction(

                      cfs, testInst);

               }

              

               /*

                * 5.打印分类结果

                * 在这里我们打印了分类器的正确率

                * 其它的一些信息我们可以通过Evaluation对象的其它方法得到

                */

               System.out.println( "分类器的正确率:" + (1- testingEvaluation.errorRate()));

           }catch(Exception e){

               e.printStackTrace();

           }

        }

     

    }

     

    通过这个实例,我们可以看到在weka上做开发非常简单的,每个模块weka都提供了很好的支持。同时,我们可以在此基础上对weka进行一个简单的封装。设计一个Util类,将数据读取,以及分类器测试等功能放在这个Util类中共以后其它的程序使用。

     

    获取样本Instances

    /*

         * .arff文件中获取样本Instances;

         * 1.fileName instances的文件名

         */

        public static Instances getInstances(String fileName) throws Exception{

           File file= new File(fileName);

           return getInstances(file);

        }

     

    /*

         * .arff文件中获取样本Instances;

         * 1.file 获得instancesFile对象

         */

        public static Instances getInstances(File file) throws Exception{

           Instances inst = null;

           try{

               ArffLoader loader = new ArffLoader();

               loader.setFile(file);

               inst = loader.getDataSet();

           }

           catch(Exception e){

               throw new Exception(e.getMessage());

           }

           return inst;

        }

     

    获得一个Evaluation对象:

    /*

         * 获得一个Evaluation对象

         * 1.h 一个已经训练过的分类器

         * 2.ins 测试样本

         */

        public static Evaluation getEvaluation(Classifier h,Instances ins){

           try{

               Instance testInst;

               /*

                * Evaluation: Class for evaluating machine learning models

                * 即它是用于检测分类模型的类

                */

               Evaluation testingEvaluation = new Evaluation(ins);

               int length = ins.numInstances();

               for (int i =0; i < length; i++) {

                  testInst = ins.instance(i);

                  //通过这个方法来用每个测试样本测试分类器的效果

                  testingEvaluation.evaluateModelOnceAndRecordPrediction(

                       h, testInst);

                }

               return testingEvaluation;

           }

           catch(Exception e){

               System.out.println("haha bug!");

               System.out.println(e);

           }

           return null;     

        }

     

    通过这几个函数我们就将读取instances对象的功能以及测试分类器的效果的功能封装到两个static函数中了,下次我们使用的时候就可以方便的调用这个接口了,可以省去我们写这些代码的时间了。

    大家明白了吗?还是比较简单的吧。



    展开全文
    yangang908 2014-09-16 20:04:12
  • Weka_control():设置Weka函数的参数。 read.arff():读Weka Attribute-Relation File Format (ARFF)格式的数据。 write.arff:将数据写入Weka Attribute-Relation File Format (ARFF)格式的文件。 2) 数据...

    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。

    参考链接:
    https://blog.csdn.net/u013422712/article/details/45394849

    展开全文
    jp_zhou256 2019-02-27 09:48:00
  • 5星
    2.45MB tjxy_20081 2012-10-09 12:31:13
  • 转载:... 1) 数据输入和输出  WOW():查看Weka函数的参数。  Weka_control():设置Weka函数的参数。  read.arff():读Weka Attribute-Relation File Format (ARFF)格式的数据。  write.arff:将数

    转载:http://blog.sina.com.cn/s/blog_8bdd25f80101ecb2.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。

     

     

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

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

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

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

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

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


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

    模型应用 
    现在我们要用生成的模型对那些待预测的数据集进行预测了,注意待预测数据集和训练用数据集各个属性的设 置必须是一致的。WEKA中并没有直接提供把模型应用到带预测数据集上的方法,我们要采取间接的办法。 
    在“Test Opion”中选择“Supplied test set”,并且“Set”成“bank-new.arff”文件。重新“Start”一次。注意这次生成的模型没有通过交叉验证来选择,“Classifier output”给出的误差分析也没有多少意义。这也是间接作预测带来的缺陷吧。 
    现在,右键点击“Result list”中刚产生的那一项,选择“Visualize classifier errors”。我们不去管新窗口中的图有什么含义,点“Save”按钮,把结果保存成“bank-predicted.arff”。这个ARFF文件中 就有我们需要的预测结果。在“Explorer”的“Preprocess”选项卡中打开这个新文件,可以看到多了两个属性 “Instance_number”和“predictedpep”。“Instance_number”是指一个实例在原“bank- new.arff”文件中的位置,“predictedpep”就是模型预测的结果。点“Edit”按钮或者在“ArffViewer”模块中打开可以查 看这个数据集的内容。比如,我们对实例0的pep预测值为“YES”,对实例4的预测值为“NO”。 

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

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



    4. 聚类分析 

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

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

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

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

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

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

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

    展开全文
    zzukun 2015-01-29 10:32:43
  • yangany1_sjtu 2013-04-24 22:07:42
  • u010976453 2017-01-12 13:39:48
  • nima1994 2017-12-01 20:43:26
  • 629KB m0_60986154 2021-08-19 23:52:56
  • 374KB m0_60986154 2021-08-20 12:37:58
  • a1041646584 2018-04-11 17:52:59
  • qiao1245 2016-03-29 15:28:26
  • mm_bit 2015-08-19 17:36:18
  • neuqxzy 2015-04-28 15:28:04
  • smilehehe110 2017-01-14 11:20:32
  • yiluohan0307 2015-04-17 11:21:53
  • MileyPriencess 2017-07-10 20:21:28
  • 25KB weixin_38733414 2021-05-22 01:02:47
  • weixin_34245169 2015-06-05 19:28:00
  • 114KB m0_52957036 2020-06-01 02:31:16
  • Fannie08 2018-01-17 21:23:31
  • 1.15MB weixin_39840515 2019-07-22 19:57:19
  • Happy__Day 2013-05-03 10:27:46

空空如也

空空如也

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

weka改进算法