Category

Development Platform
Home > SourceCode/Document > Windows Develop > View Code
EvaluationUtils.java
Package: Weka-3-2.rar　[view]
Upload User: rhdiban
Upload Date: 2013-08-09
Package Size: 15085k
Code Size: 5k
Category:

Windows Develop

Development Platform:

Java

EvaluationUtils.java：Code Content
  1. /*
  2.  *    This program is free software; you can redistribute it and/or modify
  3.  *    it under the terms of the GNU General Public License as published by
  4.  *    the Free Software Foundation; either version 2 of the License, or
  5.  *    (at your option) any later version.
  6.  *
  7.  *    This program is distributed in the hope that it will be useful,
  8.  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  9.  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10.  *    GNU General Public License for more details.
  11.  *
  12.  *    You should have received a copy of the GNU General Public License
  13.  *    along with this program; if not, write to the Free Software
  14.  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  15.  */
  17. /*
  18.  *    EvaluationUtils.java
  19.  *    Copyright (C) 2000 Intelligenesis Corp.
  20.  *
  21.  */
  23. package weka.classifiers.evaluation;
  25. import weka.core.FastVector;
  26. import weka.core.Instance;
  27. import weka.core.Instances;
  28. import weka.classifiers.DistributionClassifier;
  29. import java.util.Random;
  31. /**
  32.  * Contains utility functions for generating lists of predictions in 
  33.  * various manners.
  34.  *
  35.  * @author Len Trigg (len@intelligenesis.net)
  36.  * @version $Revision: 1.6 $
  37.  */
  38. public class EvaluationUtils {
  40.   /** Seed used to randomize data in cross-validation */
  41.   private int m_Seed = 1;
  43.   /** Sets the seed for randomization during cross-validation */
  44.   public void setSeed(int seed) { m_Seed = seed; }
  46.   /** Gets the seed for randomization during cross-validation */
  47.   public int getSeed() { return m_Seed; }
  48.   
  49.   /**
  50.    * Generate a bunch of predictions ready for processing, by performing a
  51.    * cross-validation on the supplied dataset.
  52.    *
  53.    * @param classifier the DistributionClassifier to evaluate
  54.    * @param data the dataset
  55.    * @param numFolds the number of folds in the cross-validation.
  56.    * @exception Exception if an error occurs
  57.    */
  58.   public FastVector getCVPredictions(DistributionClassifier classifier, 
  59.                                      Instances data, 
  60.                                      int numFolds) 
  61.     throws Exception {
  63.     FastVector predictions = new FastVector();
  64.     Instances runInstances = new Instances(data);
  65.     Random random = new Random(m_Seed);
  66.     runInstances.randomize(random);
  67.     if (runInstances.classAttribute().isNominal() && (numFolds > 1)) {
  68.       runInstances.stratify(numFolds);
  69.     }
  70.     int inst = 0;
  71.     for (int fold = 0; fold < numFolds; fold++) {
  72.       Instances train = runInstances.trainCV(numFolds, fold);
  73.       Instances test = runInstances.testCV(numFolds, fold);
  74.       FastVector foldPred = getTrainTestPredictions(classifier, train, test);
  75.       predictions.appendElements(foldPred);
  76.     } 
  77.     return predictions;
  78.   }
  80.   /**
  81.    * Generate a bunch of predictions ready for processing, by performing a
  82.    * evaluation on a test set after training on the given training set.
  83.    *
  84.    * @param classifier the DistributionClassifier to evaluate
  85.    * @param train the training dataset
  86.    * @param test the test dataset
  87.    * @exception Exception if an error occurs
  88.    */
  89.   public FastVector getTrainTestPredictions(DistributionClassifier classifier, 
  90.                                             Instances train, Instances test) 
  91.     throws Exception {
  92.     
  93.     classifier.buildClassifier(train);
  94.     return getTestPredictions(classifier, test);
  95.   }
  97.   /**
  98.    * Generate a bunch of predictions ready for processing, by performing a
  99.    * evaluation on a test set assuming the classifier is already trained.
  100.    *
  101.    * @param classifier the pre-trained DistributionClassifier to evaluate
  102.    * @param test the test dataset
  103.    * @exception Exception if an error occurs
  104.    */
  105.   public FastVector getTestPredictions(DistributionClassifier classifier, 
  106.                                        Instances test) 
  107.     throws Exception {
  108.     
  109.     FastVector predictions = new FastVector();
  110.     for (int i = 0; i < test.numInstances(); i++) {
  111.       if (!test.instance(i).classIsMissing()) {
  112.         predictions.addElement(getPrediction(classifier, test.instance(i)));
  113.       }
  114.     }
  115.     return predictions;
  116.   }
  118.   
  119.   /**
  120.    * Generate a single prediction for a test instance given the pre-trained
  121.    * classifier.
  122.    *
  123.    * @param classifier the pre-trained DistributionClassifier to evaluate
  124.    * @param test the test instance
  125.    * @exception Exception if an error occurs
  126.    */
  127.   public Prediction getPrediction(DistributionClassifier classifier,
  128.                                   Instance test)
  129.     throws Exception {
  130.    
  131.     double actual = test.classValue();
  132.     double [] dist = classifier.distributionForInstance(test);
  133.     if (test.classAttribute().isNominal()) {
  134.       return new NominalPrediction(actual, dist, test.weight());
  135.     } else {
  136.       return new NumericPrediction(actual, dist[0], test.weight());
  137.     }
  138.   }
  139. }