WEKA KNN Örneği

WEKA, knn java kod örneğidir. Derlemek için, weka.jar ve iris veriseti gereklidir. 

package denemeler;

import abcalgoritma.WekaTest;
import static abcalgoritma.WekaTest.calculateAccuracy;
import static abcalgoritma.WekaTest.crossValidationSplit;
import static abcalgoritma.WekaTest.featureSil;
import static abcalgoritma.WekaTest.simpleClassify;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.logging.Level;
import java.util.logging.Logger;

import weka.classifiers.Classifier;
import weka.classifiers.Evaluation;
import weka.classifiers.evaluation.NominalPrediction;
import weka.classifiers.lazy.IBk;
import weka.classifiers.trees.Id3;
import weka.core.FastVector;
import weka.core.Instance;
import weka.core.Instances;
import weka.filters.Filter;
import weka.filters.unsupervised.attribute.Remove;

public class KNNWekaOrnek {

    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 simpleClassify(Classifier model, Instances trainingSet, Instances testingSet) throws Exception {
        Evaluation validation = new Evaluation(trainingSet);

        model.buildClassifier(trainingSet);
        validation.evaluateModel(model, testingSet);

        return validation;
    }

    /**
     * Tahmin edilen sınıfların doğrulama oranı geriye döndürülür.
     * 
     * @param predictions
     * @return doğruluk oranı 
     */
    public static double calculateAccuracy(FastVector predictions) {
        double correct = 0;

        for (int i = 0; i < predictions.size(); i++) {
            NominalPrediction np = (NominalPrediction) predictions.elementAt(i);
            // doğru tahmin edilenler
            if (np.predicted() == np.actual()) {
//                System.out.println("tahmin : " + np.predicted() + " gerçek : "+ np.actual());
                correct++;
            }
            // ıskalananlar 
            else{
                System.out.println("tahmin : " + np.predicted() + " gerçek : "+ np.actual());
            }
        }
        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;
    }

    /**
     * kendisine gönderilen sutun silinyor. Dikkate alınmıyor
     *
     * @param data
     * @param sil silinecek sutunlar string olarak belirtiliyor.
     * @return
     */
    public static Instances featureSil(Instances data, String sil) {

        Instances instNew = null;
        Remove remove;
        try {

            remove = new Remove();
            // belirtilen sutunlar siliniyor
            remove.setAttributeIndices(sil);
            remove.setInputFormat(data);

            instNew = Filter.useFilter(data, remove);
            System.out.println("işte : " + instNew);
            return instNew;
        } catch (Exception ex) {
            Logger.getLogger(WekaTest.class.getName()).log(Level.SEVERE, null, ex);
        }
        return instNew;
    }

    public static void main(String[] args) throws Exception {
        // dosyadan okuma yapılıyor
        BufferedReader datafile = readDataFile("iris.arff");
        Instances data = new Instances(datafile);
        data.setClassIndex(data.numAttributes() - 1);

        Instances instNew = featureSil(data, "");

        // Choose a type of validation split
        Instances[][] split = crossValidationSplit(instNew, 10);

        // Separate split into training and testing arrays
        Instances[] trainingSplits = split[0];
        Instances[] testingSplits = split[1];

        Classifier[] models = {new IBk()};

        // birden fazla model varsa, taranıyor.
        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 = simpleClassify(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);

            System.out.println("accuracy (" + j + ") : " + accuracy);
            // Print current classifier's name and accuracy in a complicated, but nice-looking way.
            // System.out.println(models[j].getClass().getSimpleName() + ": " + String.format("%.2f%%", accuracy) + "\n=====================");
        }

    }
}

Kaynaklar

http://www.programcreek.com/2013/01/use-k-nearest-neighbors-knn-classifier-in-java/

Reklamlar

No comments yet

Bir Cevap Yazın

Aşağıya bilgilerinizi girin veya oturum açmak için bir simgeye tıklayın:

WordPress.com Logosu

WordPress.com hesabınızı kullanarak yorum yapıyorsunuz. Çıkış  Yap / Değiştir )

Twitter resmi

Twitter hesabınızı kullanarak yorum yapıyorsunuz. Çıkış  Yap / Değiştir )

Facebook fotoğrafı

Facebook hesabınızı kullanarak yorum yapıyorsunuz. Çıkış  Yap / Değiştir )

Google+ fotoğrafı

Google+ hesabınızı kullanarak yorum yapıyorsunuz. Çıkış  Yap / Değiştir )

Connecting to %s

%d blogcu bunu beğendi: