source: trunk/CrossPare/src/de/ugoe/cs/cpdp/dataselection/SeparatabilitySelection.java

// Copyright 2015 Georg-August-Universität Göttingen, Germany

//

//   Licensed under the Apache License, Version 2.0 (the "License");

//   you may not use this file except in compliance with the License.

//   You may obtain a copy of the License at

//

//       http://www.apache.org/licenses/LICENSE-2.0

//

//   Unless required by applicable law or agreed to in writing, software

//   distributed under the License is distributed on an "AS IS" BASIS,

//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

//   See the License for the specific language governing permissions and

//   limitations under the License.



package de.ugoe.cs.cpdp.dataselection;



import java.util.Arrays;

import java.util.Random;



import org.apache.commons.collections4.list.SetUniqueList;



import weka.classifiers.Evaluation;

import weka.classifiers.functions.Logistic;

import weka.core.DenseInstance;

import weka.core.Instance;

import weka.core.Instances;



/**

 * A setwise data selection strategy based on the separatability of the training data from the test

 * data after Z. He, F. Peters, T. Menzies, Y. Yang: Learning from Open-Source Projects: An

 * Empirical Study on Defect Prediction. <br>

 * <br>

 * This is calculated through the error of a logistic regression classifier that tries to separate

 * the sets.

 * 

 * @author Steffen Herbold

 */

public class SeparatabilitySelection implements ISetWiseDataselectionStrategy {



    /**

     * size of the random sample that is drawn from both test data and training data

     */

    private final int sampleSize = 500;



    /**

     * number of repetitions of the sample drawing

     */

    private final int maxRep = 10;



    /**

     * number of neighbors that are selected

     */

    private int neighbors = 10;



    /**

     * Sets the number of neighbors that are selected.

     */

    @Override

    public void setParameter(String parameters) {

        if (!"".equals(parameters)) {

            neighbors = Integer.parseInt(parameters);

        }

    }



    /**

     * @see de.ugoe.cs.cpdp.dataselection.SetWiseDataselectionStrategy#apply(weka.core.Instances,

     *      org.apache.commons.collections4.list.SetUniqueList)

     */

    @Override

    public void apply(Instances testdata, SetUniqueList<Instances> traindataSet) {

        final Random rand = new Random(1);



        // calculate distances between testdata and traindata

        final double[] distances = new double[traindataSet.size()];



        int i = 0;

        for (Instances traindata : traindataSet) {

            double distance = 0.0;

            for (int rep = 0; rep < maxRep; rep++) {

                // sample instances

                Instances sample = new Instances(testdata);

                for (int j = 0; j < sampleSize; j++) {

                    Instance inst =

                        new DenseInstance(testdata.instance(rand.nextInt(testdata.numInstances())));

                    inst.setDataset(sample);

                    inst.setClassValue(1.0);

                    sample.add(inst);

                    inst = new DenseInstance(traindata

                        .instance(rand.nextInt(traindata.numInstances())));

                    inst.setDataset(sample);

                    inst.setClassValue(0.0);

                    sample.add(inst);

                }



                // calculate separation

                Evaluation eval;

                try {

                    eval = new Evaluation(sample);

                    eval.crossValidateModel(new Logistic(), sample, 5, rand);

                }

                catch (Exception e) {

                    throw new RuntimeException("cross-validation during calculation of separatability failed",

                                               e);

                }

                distance += eval.pctCorrect() / 100.0;

            }

            distances[i++] = 2 * ((distance / maxRep) - 0.5);

        }



        // select closest neighbors

        final double[] distancesCopy = Arrays.copyOf(distances, distances.length);

        Arrays.sort(distancesCopy);

        final double cutoffDistance = distancesCopy[neighbors];



        for (i = traindataSet.size() - 1; i >= 0; i--) {

            if (distances[i] > cutoffDistance) {

                traindataSet.remove(i);

            }

        }

    }

}