2.Java中一个简单的机器学习例子

这是一个“Hello World”Java机器学习的例子。 它只是给你一个Java的机器学习的味道。

环境

Java 1.6+ and Eclipse

第一步 下载 Weka 库

下载地址：: http://www.cs.waikato.ac.nz/ml/weka/snapshots/weka_snapshots.html

下载stable.XX.zip，解压缩文件，在Eclipse中将weka.jar添加到Java项目的库路径中。

第二步 准备数据

按照以下格式创建一个txt文件“weather.txt”：

@relation weather

@attribute outlook {sunny, overcast, rainy}
@attribute temperature numeric
@attribute humidity numeric
@attribute windy {TRUE, FALSE}
@attribute play {yes, no}

@data
sunny,85,85,FALSE,no
sunny,80,90,TRUE,no
overcast,83,86,FALSE,yes
rainy,70,96,FALSE,yes
rainy,68,80,FALSE,yes
rainy,65,70,TRUE,no
overcast,64,65,TRUE,yes
sunny,72,95,FALSE,no
sunny,69,70,FALSE,yes
rainy,75,80,FALSE,yes
sunny,75,70,TRUE,yes
overcast,72,90,TRUE,yes
overcast,81,75,FALSE,yes
rainy,71,91,TRUE,no

这个数据集来自weka下载包。 它位于“/data/weather.numeric.arff”。 文件扩展名是“arff”，但我们可以简单地使用“txt”。

第3步：使用Weka进行培训和测试

此代码示例使用Weka提供的一组分类器。 它在给定数据集上训练模型，并使用10分裂交叉验证进行测试。 以后我会解释每个分类器，因为这是一个更复杂的主题。

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import weka.classifiers.Classifier;
import weka.classifiers.Evaluation;
import weka.classifiers.evaluation.NominalPrediction;
import weka.classifiers.rules.DecisionTable;
import weka.classifiers.rules.PART;
import weka.classifiers.trees.DecisionStump;
import weka.classifiers.trees.J48;
import weka.core.FastVector;
import weka.core.Instances;
 
public class WekaTest {
    public static BufferedReader readDataFile(String filename) {
        BufferedReader inputReader = null;
 
        try {
            inputReader = new BufferedReader(new FileReader(filename));
        } catch (FileNotFoundException ex) {
            System.err.println("File not found: " + filename);
        }
 
        return inputReader;
    }
 
    public static Evaluation classify(Classifier model,
            Instances trainingSet, Instances testingSet) throws Exception {
        Evaluation evaluation = new Evaluation(trainingSet);
 
        model.buildClassifier(trainingSet);
        evaluation.evaluateModel(model, testingSet);
 
        return evaluation;
    }
 
    public static double calculateAccuracy(FastVector predictions) {
        double correct = 0;
 
        for (int i = 0; i < predictions.size(); i++) {
            NominalPrediction np = (NominalPrediction) predictions.elementAt(i);
            if (np.predicted() == np.actual()) {
                correct++;
            }
        }
 
        return 100 * correct / predictions.size();
    }
 
    public static Instances[][] crossValidationSplit(Instances data, int numberOfFolds) {
        Instances[][] split = new Instances[2][numberOfFolds];
 
        for (int i = 0; i < numberOfFolds; i++) {
            split[0][i] = data.trainCV(numberOfFolds, i);
            split[1][i] = data.testCV(numberOfFolds, i);
        }
 
        return split;
    }
 
    public static void main(String[] args) throws Exception {
        BufferedReader datafile = readDataFile("weather.txt");
 
        Instances data = new Instances(datafile);
        data.setClassIndex(data.numAttributes() - 1);
 
        // Do 10-split cross validation
        Instances[][] split = crossValidationSplit(data, 10);
 
        // Separate split into training and testing arrays
        Instances[] trainingSplits = split[0];
        Instances[] testingSplits = split[1];
 
        // Use a set of classifiers
        Classifier[] models = { 
                new J48(), // a decision tree
                new PART(), 
                new DecisionTable(),//decision table majority classifier
                new DecisionStump() //one-level decision tree
        };
 
        // Run for each model
        for (int j = 0; j < models.length; j++) {
 
            // Collect every group of predictions for current model in a FastVector
            FastVector predictions = new FastVector();
 
            // For each training-testing split pair, train and test the classifier
            for (int i = 0; i < trainingSplits.length; i++) {
                Evaluation validation = classify(models[j], trainingSplits[i], testingSplits[i]);
 
                predictions.appendElements(validation.predictions());
 
                // Uncomment to see the summary for each training-testing pair.
                //System.out.println(models[j].toString());
            }
 
            // Calculate overall accuracy of current classifier on all splits
            double accuracy = calculateAccuracy(predictions);
 
            // Print current classifier's name and accuracy in a complicated,
            // but nice-looking way.
            System.out.println("Accuracy of " + models[j].getClass().getSimpleName() + ": "
                    + String.format("%.2f%%", accuracy)
                    + "\n---------------------------------");
        }
 
    }
}

您的项目的包视图应该如下所示：

包示意图

参考文献：

1. http://www.cs.umb.edu/~ding/history/480_697_spring_2013/homework/WekaJavaAPITutorial.pdf
2. http://www.cs.ru.nl/P.Lucas/teaching/DM/weka.pdf