Ignore:
Timestamp:
07/18/16 12:26:03 (8 years ago)
Author:
sherbold
Message:
  • code documentation and formatting
Location:
trunk/CrossPare/src/de/ugoe/cs/cpdp
Files:
75 edited

Legend:

Unmodified
Added
Removed

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/ExperimentConfiguration.java

    r98 r135  
    161161     */ 
    162162    private Boolean saveClassifier = null; 
    163      
     163 
    164164    /** 
    165165     * number of repetitions of an experiment (to account for randomness) 
    … …  
    426426        return saveClassifier; 
    427427    } 
    428      
     428 
    429429    /** 
    430430     * number of repetitions of an experiment 
    … …  
    579579                saveClassifier = true; 
    580580            } 
    581             else if( qName.equals("repetitions")) { 
     581            else if (qName.equals("repetitions")) { 
    582582                repetitions = Integer.parseInt(attributes.getValue("number")); 
    583583            } 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/Runner.java

    r100 r135  
    5353                createConfig(threadPool, file.getAbsolutePath()); 
    5454            } 
    55             else if (file.isDirectory() && file.listFiles()!=null ) { 
     55            else if (file.isDirectory() && file.listFiles() != null) { 
    5656                for (File subfile : file.listFiles()) { 
    5757                    if (subfile.isFile()) { 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/dataprocessing/CLAMIProcessor.java

    r86 r135  
    5151    @Override 
    5252    public void setParameter(String parameters) { 
    53         // TODO Auto-generated method stub 
    54  
     53        // dummy, parameters not used 
    5554    } 
    5655 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/dataprocessing/CLAProcessor.java

    r86 r135  
    4444    @Override 
    4545    public void setParameter(String parameters) { 
    46         // TODO Auto-generated method stub 
    47  
     46        // dummy, parameters not used 
    4847    } 
    4948 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/dataprocessing/LogarithmTransform.java

    r86 r135  
    112112            Instance instance = traindata.instance(i); 
    113113            for (int j = 0; j < testdata.numAttributes(); j++) { 
    114                 if (traindata.attribute(j) != classAttribute && traindata.attribute(j).isNumeric()) 
     114                if (traindata.attribute(j) != classAttribute && 
     115                    traindata.attribute(j).isNumeric()) 
    115116                { 
    116117                    if (instance.value(j) < 0) { 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/dataprocessing/MORPH.java

    r120 r135  
    2525 
    2626/** 
    27  * Implements the MORPH data privatization.  
     27 * Implements the MORPH data privatization. 
    2828 *  
    2929 *  
    … …  
    3636     */ 
    3737    Random rand = new Random(); 
    38      
     38 
    3939    /** 
    4040     * parameter alpha for MORPH, default is 0.15 
    4141     */ 
    4242    double alpha = 0.15; 
    43      
     43 
    4444    /** 
    4545     * parameter beta for MORPH, default is 0.35 
    4646     */ 
    4747    double beta = 0.35; 
    48      
     48 
    4949    /** 
    5050     * Does not have parameters. String is ignored. 
    … …  
    5757        if (parameters != null && !parameters.equals("")) { 
    5858            String[] values = parameters.split(" "); 
    59             if( values.length!=2 ) { 
     59            if (values.length != 2) { 
    6060                throw new InvalidParameterException("MORPH requires two doubles as parameter or no parameters to use default values"); 
    6161            } 
    … …  
    6363                alpha = Double.parseDouble(values[0]); 
    6464                beta = Double.parseDouble(values[1]); 
    65             } catch(NumberFormatException e) { 
     65            } 
     66            catch (NumberFormatException e) { 
    6667                throw new InvalidParameterException("MORPH requires two doubles as parameter or no parameters to use default values"); 
    6768            } 
    … …  
    7576    @Override 
    7677    public void apply(Instances testdata, SetUniqueList<Instances> traindataSet) { 
    77         for( Instances traindata : traindataSet ) { 
     78        for (Instances traindata : traindataSet) { 
    7879            applyMORPH(traindata); 
    7980        } 
    … …  
    8889        applyMORPH(traindata); 
    8990    } 
    90      
     91 
    9192    /** 
    9293     *  
    … …  
    9596     * </p> 
    9697     * 
    97      * @param data data to which the processor is applied 
     98     * @param data 
     99     *            data to which the processor is applied 
    98100     */ 
    99101    public void applyMORPH(Instances data) { 
    100         for (int i=0; i<data.numInstances(); i++ ) { 
     102        for (int i = 0; i < data.numInstances(); i++) { 
    101103            morphInstance(data.get(i), data); 
    102104        } 
    103105    } 
    104      
     106 
    105107    /** 
    106108     * <p> 
    … …  
    108110     * </p> 
    109111     * 
    110      * @param instance instance that is morphed 
    111      * @param data data based on which the instance is morphed 
     112     * @param instance 
     113     *            instance that is morphed 
     114     * @param data 
     115     *            data based on which the instance is morphed 
    112116     */ 
    113117    public void morphInstance(Instance instance, Instances data) { 
    114118        Instance nearestUnlikeNeighbor = getNearestUnlikeNeighbor(instance, data); 
    115         if( nearestUnlikeNeighbor==null ) { 
    116             throw new RuntimeException("could not find nearest unlike neighbor within the data: " + data.relationName()); 
     119        if (nearestUnlikeNeighbor == null) { 
     120            throw new RuntimeException("could not find nearest unlike neighbor within the data: " + 
     121                data.relationName()); 
    117122        } 
    118         for( int j=0; j<data.numAttributes() ; j++ ) { 
    119             if( data.attribute(j)!=data.classAttribute() && data.attribute(j).isNumeric()) { 
    120                 double randVal = rand.nextDouble()*(beta-alpha)+alpha; 
    121                 instance.setValue(j, instance.value(j) + randVal*(instance.value(j)-nearestUnlikeNeighbor.value(j)) ); 
     123        for (int j = 0; j < data.numAttributes(); j++) { 
     124            if (data.attribute(j) != data.classAttribute() && data.attribute(j).isNumeric()) { 
     125                double randVal = rand.nextDouble() * (beta - alpha) + alpha; 
     126                instance.setValue(j, instance.value(j) + 
     127                    randVal * (instance.value(j) - nearestUnlikeNeighbor.value(j))); 
    122128            } 
    123129        } 
    124130    } 
    125      
     131 
    126132    /** 
    127133     * <p> 
    128      * Determines the nearest unlike neighbor of an instance.  
     134     * Determines the nearest unlike neighbor of an instance. 
    129135     * </p> 
    130136     * 
    131      * @param instance instance to which the nearest unlike neighbor is determined 
    132      * @param data data where the nearest unlike neighbor is determined from 
     137     * @param instance 
     138     *            instance to which the nearest unlike neighbor is determined 
     139     * @param data 
     140     *            data where the nearest unlike neighbor is determined from 
    133141     * @return nearest unlike instance 
    134142     */ 
    135143    public Instance getNearestUnlikeNeighbor(Instance instance, Instances data) { 
    136144        Instance nearestUnlikeNeighbor = null; 
    137          
    138         double[] instanceVector = new double[data.numAttributes()-1]; 
     145 
     146        double[] instanceVector = new double[data.numAttributes() - 1]; 
    139147        int tmp = 0; 
    140         for( int j=0; j<data.numAttributes(); j++ ) { 
    141             if( data.attribute(j)!=data.classAttribute() && data.attribute(j).isNumeric()) { 
     148        for (int j = 0; j < data.numAttributes(); j++) { 
     149            if (data.attribute(j) != data.classAttribute() && data.attribute(j).isNumeric()) { 
    142150                instanceVector[tmp] = instance.value(j); 
    143151            } 
    144152        } 
    145          
     153 
    146154        double minDistance = Double.MAX_VALUE; 
    147         for( int i=0 ; i<data.numInstances() ; i++ ) { 
    148             if( instance.classValue() != data.instance(i).classValue() ) { 
     155        for (int i = 0; i < data.numInstances(); i++) { 
     156            if (instance.classValue() != data.instance(i).classValue()) { 
    149157                double[] otherVector = new double[data.numAttributes() - 1]; 
    150158                tmp = 0; 
    151159                for (int j = 0; j < data.numAttributes(); j++) { 
    152                     if (data.attribute(j) != data.classAttribute() && data.attribute(j).isNumeric()) { 
     160                    if (data.attribute(j) != data.classAttribute() && 
     161                        data.attribute(j).isNumeric()) 
     162                    { 
    153163                        otherVector[tmp++] = data.instance(i).value(j); 
    154164                    } 
    155165                } 
    156                 if( MathArrays.distance(instanceVector, otherVector)<minDistance) { 
     166                if (MathArrays.distance(instanceVector, otherVector) < minDistance) { 
    157167                    minDistance = MathArrays.distance(instanceVector, otherVector); 
    158168                    nearestUnlikeNeighbor = data.instance(i); 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/dataprocessing/MedianAsReference.java

    r86 r135  
    129129            Instance instance = traindata.instance(i); 
    130130            for (int j = 0; j < traindata.numAttributes(); j++) { 
    131                 if (traindata.attribute(j) != classAttribute && traindata.attribute(j).isNumeric()) 
     131                if (traindata.attribute(j) != classAttribute && 
     132                    traindata.attribute(j).isNumeric()) 
    132133                { 
    133134                    instance.setValue(j, instance.value(j) + (median[j] - currentmedian[j])); 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/dataprocessing/NominalAttributeFilter.java

    r86 r135  
    9595 
    9696            // delete all instances where nominal attribute has the value of one of the parameter 
    97             if (indexOfnominalAttributeValues.contains(wekaInstance 
    98                 .value(indexOfConfidenceAttribute))) 
     97            if (indexOfnominalAttributeValues 
     98                .contains(wekaInstance.value(indexOfConfidenceAttribute))) 
    9999            { 
    100100                traindata.delete(j); 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/dataprocessing/Oversampling.java

    r86 r135  
    8080 
    8181            Resample resample = new Resample(); 
    82             // TODO: resample.setSampleSizePercent((100.0*counts[1])/100+0.01); 
    83             // Ohne +0.01 wird bei tomcat, xerces-1.2 und jedit-4.0 ein negative 
    84             // weniger zurückgegeben 
    8582            resample.setSampleSizePercent((100.0 * counts[0]) / counts[1]); 
    8683            try { 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/dataprocessing/SynonymAttributePruning.java

    r86 r135  
    5959        double distance; 
    6060        for (int j = traindata.numAttributes() - 1; j >= 0; j--) { 
    61             if( j!=traindata.classIndex() ) { 
     61            if (j != traindata.classIndex()) { 
    6262                boolean hasClosest = false; 
    6363                for (int i1 = 0; !hasClosest && i1 < traindata.size(); i1++) { 
    … …  
    6767                            double distanceJ = Double.MAX_VALUE; 
    6868                            for (int k = 0; k < traindata.numAttributes(); k++) { 
    69                                 distance = Math.abs(traindata.get(i1).value(k) - traindata.get(i2).value(k)); 
     69                                distance = Math 
     70                                    .abs(traindata.get(i1).value(k) - traindata.get(i2).value(k)); 
    7071                                if (distance < minVal) { 
    7172                                    minVal = distance; 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/dataprocessing/TCAPlusNormalization.java

    r86 r135  
    1919import weka.core.Instances; 
    2020 
    21 // normalization selected according to TCA+ rules (TCA has to be applied separately 
     21/** 
     22 * <p> 
     23 * Normalization selected according to the TCA+ rules after Nam et al. (Transfer Defect Learning). 
     24 * </p> 
     25 *  
     26 * @author Steffen Herbold 
     27 */ 
    2228public class TCAPlusNormalization implements IProcessesingStrategy { 
    2329 
    … …  
    3036    @Override 
    3137    public void setParameter(String parameters) { 
    32         // TODO Auto-generated method stub 
    33          
     38        // dummy, paramters not used 
    3439    } 
    3540 
     41    /* 
     42     * (non-Javadoc) 
     43     *  
     44     * @see de.ugoe.cs.cpdp.dataprocessing.IProcessesingStrategy#apply(weka.core.Instances, 
     45     * weka.core.Instances) 
     46     */ 
    3647    @Override 
    3748    public void apply(Instances testdata, Instances traindata) { 
    3849        applyTCAPlus(testdata, traindata); 
    3950    } 
    40      
     51 
    4152    private void applyTCAPlus(Instances testdata, Instances traindata) { 
    4253        DistChar dcTest = WekaUtils.datasetDistance(testdata); 
    4354        DistChar dcTrain = WekaUtils.datasetDistance(traindata); 
    44          
     55 
    4556        // RULE 1: 
    46         if( 0.9*dcTrain.mean<=dcTest.mean && 1.1*dcTrain.mean>=dcTest.mean && 
    47             0.9*dcTrain.std<=dcTest.std && 1.1*dcTrain.std>=dcTest.std) { 
     57        if (0.9 * dcTrain.mean <= dcTest.mean && 1.1 * dcTrain.mean >= dcTest.mean && 
     58            0.9 * dcTrain.std <= dcTest.std && 1.1 * dcTrain.std >= dcTest.std) 
     59        { 
    4860            // do nothing 
    4961        } 
    5062        // RULE 2: 
    51         else if((0.4*dcTrain.min>dcTest.min || 1.6*dcTrain.min<dcTest.min) && 
    52                 (0.4*dcTrain.max>dcTest.max || 1.6*dcTrain.min<dcTest.max) && 
    53                 (0.4*dcTrain.min>dcTest.num || 1.6*dcTrain.min<dcTest.num)) { 
     63        else if ((0.4 * dcTrain.min > dcTest.min || 1.6 * dcTrain.min < dcTest.min) && 
     64            (0.4 * dcTrain.max > dcTest.max || 1.6 * dcTrain.min < dcTest.max) && 
     65            (0.4 * dcTrain.min > dcTest.num || 1.6 * dcTrain.min < dcTest.num)) 
     66        { 
    5467            NormalizationUtil.minMax(testdata); 
    5568            NormalizationUtil.minMax(traindata); 
    5669        } 
    5770        // RULE 3: 
    58         else if((0.4*dcTrain.std>dcTest.std && dcTrain.num<dcTest.num) ||  
    59                 (1.6*dcTrain.std<dcTest.std)&& dcTrain.num>dcTest.num) { 
     71        else if ((0.4 * dcTrain.std > dcTest.std && dcTrain.num < dcTest.num) || 
     72            (1.6 * dcTrain.std < dcTest.std) && dcTrain.num > dcTest.num) 
     73        { 
    6074            NormalizationUtil.zScoreTraining(testdata, traindata); 
    6175        } 
    6276        // RULE 4: 
    63         else if((0.4*dcTrain.std>dcTest.std && dcTrain.num>dcTest.num) ||  
    64                 (1.6*dcTrain.std<dcTest.std)&& dcTrain.num<dcTest.num) { 
     77        else if ((0.4 * dcTrain.std > dcTest.std && dcTrain.num > dcTest.num) || 
     78            (1.6 * dcTrain.std < dcTest.std) && dcTrain.num < dcTest.num) 
     79        { 
    6580            NormalizationUtil.zScoreTarget(testdata, traindata); 
    6681        } 
    67         //RULE 5: 
     82        // RULE 5: 
    6883        else { 
    6984            NormalizationUtil.zScore(testdata); 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/dataprocessing/TopMetricFilter.java

    r129 r135  
    5252     */ 
    5353    double correlationThreshold = 0.5; 
    54      
     54 
    5555    /* 
    5656     * (non-Javadoc) 
    … …  
    6060    @Override 
    6161    public void setParameter(String parameters) { 
    62         if( parameters!=null && !parameters.equals("")) { 
     62        if (parameters != null && !parameters.equals("")) { 
    6363            correlationThreshold = Double.parseDouble(parameters); 
    6464        } 
    … …  
    7676    } 
    7777 
    78     private void determineTopKAttributes(Instances testdata, SetUniqueList<Instances> traindataSet) throws Exception { 
    79         Integer[] counts = new Integer[traindataSet.get(0).numAttributes()-1]; 
    80         IntStream.range(0,counts.length).forEach(val -> counts[val] = 0); 
    81         for( Instances traindata : traindataSet ) { 
     78    private void determineTopKAttributes(Instances testdata, SetUniqueList<Instances> traindataSet) 
     79        throws Exception 
     80    { 
     81        Integer[] counts = new Integer[traindataSet.get(0).numAttributes() - 1]; 
     82        IntStream.range(0, counts.length).forEach(val -> counts[val] = 0); 
     83        for (Instances traindata : traindataSet) { 
    8284            J48 decisionTree = new J48(); 
    8385            decisionTree.buildClassifier(traindata); 
    84             int k=0; 
    85             for( int j=0; j<traindata.numAttributes(); j++) { 
    86                 if(j!=traindata.classIndex()){ 
    87                     if( decisionTree.toString().contains(traindata.attribute(j).name()) ) { 
    88                         counts[k] = counts[k]+1; 
     86            int k = 0; 
     87            for (int j = 0; j < traindata.numAttributes(); j++) { 
     88                if (j != traindata.classIndex()) { 
     89                    if (decisionTree.toString().contains(traindata.attribute(j).name())) { 
     90                        counts[k] = counts[k] + 1; 
    8991                    } 
    9092                    k++; 
    … …  
    9395        } 
    9496        int[] topkIndex = new int[counts.length]; 
    95         IntStream.range(0,counts.length).forEach(val -> topkIndex[val] = val); 
     97        IntStream.range(0, counts.length).forEach(val -> topkIndex[val] = val); 
    9698        SortUtils.quicksort(counts, topkIndex, true); 
    97          
     99 
    98100        // get CFSs for each training set 
    99101        List<Set<Integer>> cfsSets = new LinkedList<>(); 
    100         for( Instances traindata : traindataSet ) { 
     102        for (Instances traindata : traindataSet) { 
    101103            boolean selectionSuccessful = false; 
    102104            boolean secondAttempt = false; 
    … …  
    113115                        attsel.SelectAttributes(traindataCopy); 
    114116                        Set<Integer> cfsSet = new HashSet<>(); 
    115                         for( int attr : attsel.selectedAttributes() ) { 
     117                        for (int attr : attsel.selectedAttributes()) { 
    116118                            cfsSet.add(attr); 
    117119                        } 
    … …  
    128130                        attsel.SelectAttributes(traindata); 
    129131                        Set<Integer> cfsSet = new HashSet<>(); 
    130                         for( int attr : attsel.selectedAttributes() ) { 
     132                        for (int attr : attsel.selectedAttributes()) { 
    131133                            cfsSet.add(attr); 
    132134                        } 
    … …  
    160162            while (!selectionSuccessful); // dummy loop for internal continue 
    161163        } 
    162          
     164 
    163165        double[] coverages = new double[topkIndex.length]; 
    164         for( Set<Integer> cfsSet : cfsSets ) { 
     166        for (Set<Integer> cfsSet : cfsSets) { 
    165167            Set<Integer> topkSet = new HashSet<>(); 
    166             for( int k=0; k<topkIndex.length ; k++ ) { 
     168            for (int k = 0; k < topkIndex.length; k++) { 
    167169                topkSet.add(topkIndex[k]); 
    168                 coverages[k] += (coverage(topkSet, cfsSet)/traindataSet.size()); 
     170                coverages[k] += (coverage(topkSet, cfsSet) / traindataSet.size()); 
    169171            } 
    170172        } 
    171173        double bestCoverageValue = Double.MIN_VALUE; 
    172174        int bestCoverageIndex = 0; 
    173         for( int i=0; i<coverages.length; i++ ) { 
    174             if( coverages[i]>bestCoverageValue) { 
     175        for (int i = 0; i < coverages.length; i++) { 
     176            if (coverages[i] > bestCoverageValue) { 
    175177                bestCoverageValue = coverages[i]; 
    176178                bestCoverageIndex = i; 
    … …  
    180182        SpearmansCorrelation corr = new SpearmansCorrelation(); 
    181183        double[][] correlationMatrix = new double[bestCoverageIndex][bestCoverageIndex]; 
    182         for( Instances traindata : traindataSet ) { 
     184        for (Instances traindata : traindataSet) { 
    183185            double[][] vectors = new double[bestCoverageIndex][traindata.size()]; 
    184             for( int i=0; i<traindata.size(); i++ ) { 
    185                 for( int j=0; j<bestCoverageIndex; j++) { 
     186            for (int i = 0; i < traindata.size(); i++) { 
     187                for (int j = 0; j < bestCoverageIndex; j++) { 
    186188                    vectors[j][i] = traindata.get(i).value(topkIndex[j]); 
    187189                } 
    188190            } 
    189             for( int j=0; j<bestCoverageIndex; j++ ) { 
    190                 for( int k=j+1; k<bestCoverageIndex; k++ ) { 
     191            for (int j = 0; j < bestCoverageIndex; j++) { 
     192                for (int k = j + 1; k < bestCoverageIndex; k++) { 
    191193                    correlationMatrix[j][k] = Math.abs(corr.correlation(vectors[j], vectors[k])); 
    192194                } 
    … …  
    194196        } 
    195197        Set<Integer> topkSetIndexSet = new TreeSet<>(); 
    196         // j<30 ensures that the computational time does not explode since the powerset is 2^n in complexity 
    197         for( int j=0; j<bestCoverageIndex && j<30 ; j++ ) { 
     198        // j<30 ensures that the computational time does not explode since the powerset is 2^n in 
     199        // complexity 
     200        for (int j = 0; j < bestCoverageIndex && j < 30; j++) { 
    198201            topkSetIndexSet.add(j); 
    199202        } 
    … …  
    201204        double bestOptCoverage = Double.MIN_VALUE; 
    202205        Set<Integer> opttopkSetIndexSet = null; 
    203         for( Set<Integer> combination : allCombinations ) { 
    204             if( isUncorrelated(correlationMatrix, combination) ) { 
     206        for (Set<Integer> combination : allCombinations) { 
     207            if (isUncorrelated(correlationMatrix, combination)) { 
    205208                double currentCoverage = 0.0; 
    206209                Set<Integer> topkCombination = new TreeSet<>(); 
    207                 for( Integer index : combination ) { 
     210                for (Integer index : combination) { 
    208211                    topkCombination.add(topkIndex[index]); 
    209212                } 
    210                 for( Set<Integer> cfsSet : cfsSets ) { 
    211                     currentCoverage += (coverage(topkCombination, cfsSet)/traindataSet.size()); 
    212                 } 
    213                 if( currentCoverage > bestOptCoverage ) { 
     213                for (Set<Integer> cfsSet : cfsSets) { 
     214                    currentCoverage += (coverage(topkCombination, cfsSet) / traindataSet.size()); 
     215                } 
     216                if (currentCoverage > bestOptCoverage) { 
    214217                    bestOptCoverage = currentCoverage; 
    215218                    opttopkSetIndexSet = combination; 
    … …  
    218221        } 
    219222        Set<Integer> opttopkIndex = new TreeSet<>(); 
    220         for( Integer index : opttopkSetIndexSet) { 
     223        for (Integer index : opttopkSetIndexSet) { 
    221224            opttopkIndex.add(topkIndex[index]); 
    222225        } 
    223226        Console.traceln(Level.FINE, "selected the following metrics:"); 
    224         for( Integer index : opttopkIndex) { 
     227        for (Integer index : opttopkIndex) { 
    225228            Console.traceln(Level.FINE, traindataSet.get(0).attribute(index).name()); 
    226229        } 
    227230        // finally remove attributes 
    228         for( int j=testdata.numAttributes()-1; j>=0; j-- ) { 
    229             if( j!=testdata.classIndex() && !opttopkIndex.contains(j) ) { 
     231        for (int j = testdata.numAttributes() - 1; j >= 0; j--) { 
     232            if (j != testdata.classIndex() && !opttopkIndex.contains(j)) { 
    230233                testdata.deleteAttributeAt(j); 
    231                 for( Instances traindata : traindataSet ) { 
     234                for (Instances traindata : traindataSet) { 
    232235                    traindata.deleteAttributeAt(j); 
    233236                } 
    … …  
    235238        } 
    236239    } 
    237      
     240 
    238241    private boolean isUncorrelated(double[][] correlationMatrix, Set<Integer> combination) { 
    239242        Integer[] intCombination = combination.toArray(new Integer[0]); 
    240243        boolean areUncorrelated = true; 
    241         for( int i=0 ; areUncorrelated && i<intCombination.length ; i++ ) { 
    242             for( int j=i+1; areUncorrelated && j<intCombination.length ; j++ ) { 
    243                 areUncorrelated &= correlationMatrix[intCombination[i]][intCombination[j]]>correlationThreshold; 
     244        for (int i = 0; areUncorrelated && i < intCombination.length; i++) { 
     245            for (int j = i + 1; areUncorrelated && j < intCombination.length; j++) { 
     246                areUncorrelated &= 
     247                    correlationMatrix[intCombination[i]][intCombination[j]] > correlationThreshold; 
    244248            } 
    245249        } 
    246250        return areUncorrelated; 
    247251    } 
    248      
     252 
    249253    private double coverage(Set<Integer> topkSet, Set<Integer> cfsSet) { 
    250254        Set<Integer> topkSetCopy1 = new HashSet<>(topkSet); 
    … …  
    252256        Set<Integer> topkSetCopy2 = new HashSet<>(topkSet); 
    253257        topkSetCopy2.addAll(cfsSet); 
    254         return ((double) topkSetCopy1.size())/topkSetCopy2.size(); 
     258        return ((double) topkSetCopy1.size()) / topkSetCopy2.size(); 
    255259    } 
    256260} 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/dataprocessing/TransferComponentAnalysis.java

    r86 r135  
    3737 * </p> 
    3838 *  
    39  * TODO comment class 
    4039 * @author Steffen Herbold 
    4140 */ 
    4241public class TransferComponentAnalysis implements IProcessesingStrategy { 
    4342 
     43    /** 
     44     * Dimension of the reduced data. 
     45     */ 
    4446    int reducedDimension = 5; 
    4547 
     48    /* 
     49     * (non-Javadoc) 
     50     *  
     51     * @see de.ugoe.cs.cpdp.IParameterizable#setParameter(java.lang.String) 
     52     */ 
    4653    @Override 
    4754    public void setParameter(String parameters) { 
    48          
    49     } 
    50  
     55        // dummy, paramters ignored 
     56    } 
     57 
     58    /* 
     59     * (non-Javadoc) 
     60     *  
     61     * @see de.ugoe.cs.cpdp.dataprocessing.IProcessesingStrategy#apply(weka.core.Instances, 
     62     * weka.core.Instances) 
     63     */ 
    5164    @Override 
    5265    public void apply(Instances testdata, Instances traindata) { 
    … …  
    5467    } 
    5568 
     69    /** 
     70     * <p> 
     71     * calculates the linear kernel function between two instances 
     72     * </p> 
     73     * 
     74     * @param x1 
     75     *            first instance 
     76     * @param x2 
     77     *            second instance 
     78     * @return kernel value 
     79     */ 
    5680    private double linearKernel(Instance x1, Instance x2) { 
    5781        double value = 0.0d; 
    … …  
    6488    } 
    6589 
     90    /** 
     91     * <p> 
     92     * Applies TCA to the test and training data. 
     93     * </p> 
     94     * 
     95     * @param testdata 
     96     *            the test data 
     97     * @param traindata 
     98     *            the training data 
     99     */ 
    66100    private void applyTCA(Instances testdata, Instances traindata) { 
    67101        final int sizeTest = testdata.numInstances(); 
    … …  
    125159    } 
    126160 
     161    /** 
     162     * <p> 
     163     * Creates the kernel matrix of the test and training data 
     164     * </p> 
     165     * 
     166     * @param testdata 
     167     *            the test data 
     168     * @param traindata 
     169     *            the training data 
     170     * @return kernel matrix 
     171     */ 
    127172    private PrimitiveMatrix buildKernel(Instances testdata, Instances traindata) { 
    128173        final int kernelDim = traindata.numInstances() + testdata.numInstances(); 
    … …  
    162207    } 
    163208 
     209    /** 
     210     * <p> 
     211     * Calculates the kernel norm matrix, i.e., the matrix which is used for matrix multiplication 
     212     * to calculate the kernel norm. 
     213     * </p> 
     214     * 
     215     * @param dimTest 
     216     *            dimension of the test data 
     217     * @param sizeTrain 
     218     *            number of instances of the training data 
     219     * @return kernel norm matrix 
     220     */ 
    164221    private PrimitiveMatrix buildKernelNormMatrix(final int dimTest, final int sizeTrain) { 
    165222        final double trainSquared = 1.0 / (sizeTrain * (double) sizeTrain); 
    … …  
    199256    } 
    200257 
     258    /** 
     259     * <p> 
     260     * Creates the center matrix 
     261     * </p> 
     262     * 
     263     * @param sizeTest 
     264     *            number of instances of the test data 
     265     * @param sizeTrain 
     266     *            number of instances of the training data 
     267     * @return center matrix 
     268     */ 
    201269    private PrimitiveMatrix buildCenterMatrix(final int sizeTest, final int sizeTrain) { 
    202270        Builder<PrimitiveMatrix> centerMatrix = 
    … …  
    208276    } 
    209277 
     278    /** 
     279     * <p> 
     280     * Builds the mu-Matrix for offsetting values. 
     281     * </p> 
     282     * 
     283     * @param sizeTest 
     284     *            number of instances of the test data 
     285     * @param sizeTrain 
     286     *            number of instances of the training data 
     287     * @param mu 
     288     *            mu parameter 
     289     * @return mu-Matrix 
     290     */ 
    210291    private PrimitiveMatrix buildMuMatrix(final int sizeTest, 
    211292                                          final int sizeTrain, 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/dataprocessing/Undersampling.java

    r86 r135  
    8080 
    8181            Resample resample = new Resample(); 
    82             // TODO: resample.setSampleSizePercent((100.0*counts[1])/100+0.01); 
    83             // Ohne +0.01 wird bei tomcat, xerces-1.2 und jedit-4.0 ein negative weniger 
    84             // zurückgegeben 
    8582            resample.setSampleSizePercent((100.0 * counts[1]) / counts[0]); 
    8683            try { 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/dataprocessing/ZScoreTargetNormalization.java

    r86 r135  
    2424 * @author Steffen Herbold 
    2525 */ 
    26 public class ZScoreTargetNormalization implements ISetWiseProcessingStrategy, IProcessesingStrategy 
     26public class ZScoreTargetNormalization 
     27    implements ISetWiseProcessingStrategy, IProcessesingStrategy 
    2728{ 
    2829 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/dataselection/AbstractCharacteristicSelection.java

    r86 r135  
    104104                    } 
    105105                    else if ("median".equals(characteristics[j])) { 
    106                         instanceValues[i * characteristics.length + j] = Utils.kthSmallestValue(testdata.attributeToDoubleArray(i), testdata.size()/2); 
     106                        instanceValues[i * characteristics.length + j] = 
     107                            Utils.kthSmallestValue(testdata.attributeToDoubleArray(i), 
     108                                                   testdata.size() / 2); 
    107109                    } 
    108110                    else { 
    … …  
    138140                        } 
    139141                        else if ("median".equals(characteristics[j])) { 
    140                             instanceValues[i * characteristics.length + j] = Utils.kthSmallestValue(traindata.attributeToDoubleArray(i), traindata.size()/2); 
     142                            instanceValues[i * characteristics.length + j] = 
     143                                Utils.kthSmallestValue(traindata.attributeToDoubleArray(i), 
     144                                                       traindata.size() / 2); 
    141145                        } 
    142146                        else { 
    … …  
    173177        } 
    174178        catch (Exception e) { 
    175             throw new RuntimeException( 
    176                                        "Unexpected exception during normalization of distributional characteristics.", 
     179            throw new RuntimeException("Unexpected exception during normalization of distributional characteristics.", 
    177180                                       e); 
    178181        } 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/dataselection/CLIFF.java

    r120 r135  
    2828public class CLIFF implements IPointWiseDataselectionStrategy, ISetWiseDataselectionStrategy { 
    2929 
     30    /** 
     31     * percentage of data selected 
     32     */ 
    3033    private double percentage = 0.10; 
    31      
     34 
     35    /** 
     36     * number of ranges considered 
     37     */ 
    3238    private final int numRanges = 10; 
    3339 
    … …  
    4046    @Override 
    4147    public void setParameter(String parameters) { 
    42         if( parameters!=null ) { 
     48        if (parameters != null) { 
    4349            percentage = Double.parseDouble(parameters); 
    4450        } 
    4551    } 
    46      
    47     /** 
     52 
     53    /* 
    4854     * @see de.ugoe.cs.cpdp.dataselection.SetWiseDataselectionStrategy#apply(weka.core.Instances, 
    49      *      org.apache.commons.collections4.list.SetUniqueList) 
     55     * org.apache.commons.collections4.list.SetUniqueList) 
    5056     */ 
    5157    @Override 
    5258    public void apply(Instances testdata, SetUniqueList<Instances> traindataSet) { 
    53         for( Instances traindata : traindataSet ) { 
     59        for (Instances traindata : traindataSet) { 
    5460            applyCLIFF(traindata); 
    5561        } 
    5662    } 
    5763 
    58     /** 
     64    /* 
    5965     * @see de.ugoe.cs.cpdp.dataselection.PointWiseDataselectionStrategy#apply(weka.core.Instances, 
    60      *      weka.core.Instances) 
     66     * weka.core.Instances) 
    6167     */ 
    6268    @Override 
    … …  
    6571    } 
    6672 
     73    /** 
     74     * <p> 
     75     * Applies the CLIFF relevancy filter to the data. 
     76     * </p> 
     77     * 
     78     * @param data 
     79     *            the data 
     80     * @return CLIFF-filtered data 
     81     */ 
    6782    protected Instances applyCLIFF(Instances data) { 
    6883        final double[][] powerAttributes = new double[data.size()][data.numAttributes()]; 
    6984        final double[] powerEntity = new double[data.size()]; 
    70          
     85 
    7186        final int[] counts = data.attributeStats(data.classIndex()).nominalCounts; 
    7287        final double probDefect = data.numInstances() / (double) counts[1]; 
    73          
    74         for( int j=0; j<data.numAttributes(); j++ ) { 
    75             if( data.attribute(j)!=data.classAttribute()) { 
     88 
     89        for (int j = 0; j < data.numAttributes(); j++) { 
     90            if (data.attribute(j) != data.classAttribute()) { 
    7691                final double[] ranges = getRanges(data, j); 
    7792                final double[] probDefectRange = getRangeProbabilities(data, j, ranges); 
    78                  
    79                 for( int i=0 ; i<data.numInstances() ; i++ ) { 
     93 
     94                for (int i = 0; i < data.numInstances(); i++) { 
    8095                    final double value = data.instance(i).value(j); 
    8196                    final int range = determineRange(ranges, value); 
    8297                    double probClass, probNotClass, probRangeClass, probRangeNotClass; 
    83                     if( data.instance(i).classValue()==1 ) { 
     98                    if (data.instance(i).classValue() == 1) { 
    8499                        probClass = probDefect; 
    85                         probNotClass = 1.0-probDefect; 
     100                        probNotClass = 1.0 - probDefect; 
    86101                        probRangeClass = probDefectRange[range]; 
    87                         probRangeNotClass = 1.0-probDefectRange[range]; 
    88                     } else { 
    89                         probClass = 1.0-probDefect; 
     102                        probRangeNotClass = 1.0 - probDefectRange[range]; 
     103                    } 
     104                    else { 
     105                        probClass = 1.0 - probDefect; 
    90106                        probNotClass = probDefect; 
    91                         probRangeClass = 1.0-probDefectRange[range]; 
     107                        probRangeClass = 1.0 - probDefectRange[range]; 
    92108                        probRangeNotClass = probDefectRange[range]; 
    93109                    } 
    94                     powerAttributes[i][j] = Math.pow(probRangeClass, 2.0)/(probRangeClass*probClass+probRangeNotClass*probNotClass); 
     110                    powerAttributes[i][j] = Math.pow(probRangeClass, 2.0) / 
     111                        (probRangeClass * probClass + probRangeNotClass * probNotClass); 
    95112                } 
    96113            } 
    97114        } 
    98          
    99         for( int i=0; i<data.numInstances(); i++ ) { 
     115 
     116        for (int i = 0; i < data.numInstances(); i++) { 
    100117            powerEntity[i] = 1.0; 
    101             for (int j=0; j<data.numAttributes() ; j++ ) { 
     118            for (int j = 0; j < data.numAttributes(); j++) { 
    102119                powerEntity[i] *= powerAttributes[i][j]; 
    103120            } 
    … …  
    105122        double[] sortedPower = powerEntity.clone(); 
    106123        Arrays.sort(sortedPower); 
    107         double cutOff = sortedPower[(int) (data.numInstances()*(1-percentage))]; 
     124        double cutOff = sortedPower[(int) (data.numInstances() * (1 - percentage))]; 
    108125 
    109126        final Instances selected = new Instances(data); 
    110127        selected.delete(); 
    111         for (int i=0; i<data.numInstances(); i++) { 
    112             if( powerEntity[i]>=cutOff ) { 
     128        for (int i = 0; i < data.numInstances(); i++) { 
     129            if (powerEntity[i] >= cutOff) { 
    113130                selected.add(data.instance(i)); 
    114131            } 
    … …  
    116133        return selected; 
    117134    } 
    118      
     135 
     136    /** 
     137     * <p> 
     138     * Gets an array with the ranges from the data for a given attribute 
     139     * </p> 
     140     * 
     141     * @param data 
     142     *            the data 
     143     * @param j 
     144     *            index of the attribute 
     145     * @return the ranges for the attribute 
     146     */ 
    119147    private double[] getRanges(Instances data, int j) { 
    120         double[] values = new double[numRanges+1]; 
    121         for( int k=0; k<numRanges; k++ ) { 
    122             values[k] = data.kthSmallestValue(j, (int) (data.size()*(k+1.0)/numRanges)); 
     148        double[] values = new double[numRanges + 1]; 
     149        for (int k = 0; k < numRanges; k++) { 
     150            values[k] = data.kthSmallestValue(j, (int) (data.size() * (k + 1.0) / numRanges)); 
    123151        } 
    124152        values[numRanges] = data.attributeStats(j).numericStats.max; 
    125153        return values; 
    126154    } 
    127      
     155 
     156    /** 
     157     * <p> 
     158     * Gets the probabilities of a positive prediction for each range for a given attribute 
     159     * </p> 
     160     * 
     161     * @param data 
     162     *            the data 
     163     * @param j 
     164     *            index of the attribute 
     165     * @param ranges 
     166     *            the ranges 
     167     * @return probabilities for each range 
     168     */ 
    128169    private double[] getRangeProbabilities(Instances data, int j, double[] ranges) { 
    129170        double[] probDefectRange = new double[numRanges]; 
    130171        int[] countRange = new int[numRanges]; 
    131172        int[] countDefect = new int[numRanges]; 
    132         for( int i=0; i<data.numInstances() ; i++ ) { 
    133             int range = determineRange(ranges, data.instance(i).value(j));  
     173        for (int i = 0; i < data.numInstances(); i++) { 
     174            int range = determineRange(ranges, data.instance(i).value(j)); 
    134175            countRange[range]++; 
    135             if( data.instance(i).classValue()== 1 ) { 
     176            if (data.instance(i).classValue() == 1) { 
    136177                countDefect[range]++; 
    137178            } 
    138179 
    139180        } 
    140         for( int k=0; k<numRanges; k++ ) { 
     181        for (int k = 0; k < numRanges; k++) { 
    141182            probDefectRange[k] = ((double) countDefect[k]) / countRange[k]; 
    142183        } 
    143184        return probDefectRange; 
    144185    } 
    145      
     186 
     187    /** 
     188     * <p> 
     189     * Determines the range of a give value 
     190     * </p> 
     191     * 
     192     * @param ranges 
     193     *            the possible ranges 
     194     * @param value 
     195     *            the value 
     196     * @return index of the range 
     197     */ 
    146198    private int determineRange(double[] ranges, double value) { 
    147         for( int k=0; k<numRanges; k++ ) { 
    148             if( value<=ranges[k+1] ) { 
     199        for (int k = 0; k < numRanges; k++) { 
     200            if (value <= ranges[k + 1]) { 
    149201                return k; 
    150202            } 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/dataselection/DBSCANFilter.java

    r92 r135  
    9999                    .valid(); clusterIter.advance()) 
    100100                { 
    101                     int internalIndex = clusterIter.internalGetIndex() - testdata.size() - firstInternalIndex; 
     101                    int internalIndex = 
     102                        clusterIter.internalGetIndex() - testdata.size() - firstInternalIndex; 
    102103                    if (internalIndex >= 0) { 
    103104                        // index belongs to a training instance 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/dataselection/DecisionTreeSelection.java

    r116 r135  
    8484            } 
    8585            REPTree repTree = new REPTree(); 
    86             if( repTree.getNumFolds()>similarityData.size() ) { 
     86            if (repTree.getNumFolds() > similarityData.size()) { 
    8787                repTree.setNumFolds(similarityData.size()); 
    8888            } 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/dataselection/LACE2.java

    r120 r135  
    1212//   See the License for the specific language governing permissions and 
    1313//   limitations under the License. 
    14  
    1514 
    1615package de.ugoe.cs.cpdp.dataselection; 
    … …  
    3938public class LACE2 implements ISetWiseDataselectionStrategy { 
    4039 
     40    /** 
     41     * percentage of data selected by the internal CLIFF. 
     42     */ 
    4143    private double percentage = 0.10; 
    42      
     44 
     45    /* 
     46     * (non-Javadoc) 
     47     *  
     48     * @see de.ugoe.cs.cpdp.IParameterizable#setParameter(java.lang.String) 
     49     */ 
    4350    @Override 
    4451    public void setParameter(String parameters) { 
    45         if( parameters!=null && !parameters.isEmpty()) { 
     52        if (parameters != null && !parameters.isEmpty()) { 
    4653            percentage = Double.parseDouble(parameters); 
    4754        } 
    4855    } 
    4956 
     57    /* 
     58     * (non-Javadoc) 
     59     *  
     60     * @see de.ugoe.cs.cpdp.dataselection.ISetWiseDataselectionStrategy#apply(weka.core.Instances, 
     61     * org.apache.commons.collections4.list.SetUniqueList) 
     62     */ 
    5063    @Override 
    5164    public void apply(Instances testdata, SetUniqueList<Instances> traindataSet) { 
    5265        Instances selectedData = new Instances(testdata); 
    5366        selectedData.clear(); 
    54          
     67 
    5568        LinkedList<Instances> traindataCopy = new LinkedList<>(traindataSet); 
    5669        Collections.shuffle(traindataCopy); 
    57          
     70 
    5871        CLIFF cliff = new CLIFF(); 
    5972        cliff.setParameter(Double.toString(percentage)); 
    … …  
    6174        Median median = new Median(); 
    6275        double minDist = Double.MIN_VALUE; 
    63          
    64         for( Instances traindata : traindataCopy ) { 
     76 
     77        for (Instances traindata : traindataCopy) { 
    6578            Instances cliffedData = cliff.applyCLIFF(traindata); 
    66             if( minDist==Double.MIN_VALUE ) { 
     79            if (minDist == Double.MIN_VALUE) { 
    6780                // determine distance for leader-follower algorithm 
    6881                Instances sample; 
    69                 if( traindata.size()>100 ) { 
     82                if (traindata.size() > 100) { 
    7083                    Resample resample = new Resample(); 
    71                     resample.setSampleSizePercent(100.0/traindata.size()*100.0); 
     84                    resample.setSampleSizePercent(100.0 / traindata.size() * 100.0); 
    7285                    resample.setBiasToUniformClass(0.0); 
    7386                    resample.setNoReplacement(true); 
    … …  
    7992                        throw new RuntimeException(e); 
    8093                    } 
    81                 } else { 
     94                } 
     95                else { 
    8296                    sample = new Instances(traindata); 
    8397                } 
    8498                double[] distances = new double[sample.size()]; 
    85                 for( int i=0; i<sample.size(); i++ ) { 
     99                for (int i = 0; i < sample.size(); i++) { 
    86100                    Instance unlikeNeighbor = morph.getNearestUnlikeNeighbor(sample.get(i), sample); 
    87                     distances[i] = MathArrays.distance(WekaUtils.instanceValues(sample.get(i)), WekaUtils.instanceValues(unlikeNeighbor)); 
     101                    distances[i] = MathArrays.distance(WekaUtils.instanceValues(sample.get(i)), 
     102                                                       WekaUtils.instanceValues(unlikeNeighbor)); 
    88103                } 
    89104                minDist = median.evaluate(distances); 
    90105            } 
    91             for( int i=0; i<cliffedData.size(); i++ ) { 
    92                 Instance unlikeNeighbor = morph.getNearestUnlikeNeighbor(cliffedData.get(i), selectedData); 
    93                 if( unlikeNeighbor==null ) { 
     106            for (int i = 0; i < cliffedData.size(); i++) { 
     107                Instance unlikeNeighbor = 
     108                    morph.getNearestUnlikeNeighbor(cliffedData.get(i), selectedData); 
     109                if (unlikeNeighbor == null) { 
    94110                    selectedData.add(cliffedData.get(i)); 
    95                 } else { 
    96                     double distance = MathArrays.distance(WekaUtils.instanceValues(cliffedData.get(i)), WekaUtils.instanceValues(unlikeNeighbor)); 
    97                     if( distance>minDist ) { 
     111                } 
     112                else { 
     113                    double distance = 
     114                        MathArrays.distance(WekaUtils.instanceValues(cliffedData.get(i)), 
     115                                            WekaUtils.instanceValues(unlikeNeighbor)); 
     116                    if (distance > minDist) { 
    98117                        morph.morphInstance(cliffedData.get(i), cliffedData); 
    99118                        selectedData.add(cliffedData.get(i)); 
    … …  
    103122        } 
    104123    } 
    105      
     124 
    106125} 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/dataselection/MahalanobisOutlierRemoval.java

    r117 r135  
    9797        RealMatrix inverseCovariance; 
    9898        try { 
    99             inverseCovariance = 
    100             new LUDecomposition(new Covariance(values).getCovarianceMatrix()).getSolver() 
    101                 .getInverse(); 
    102         } catch(SingularMatrixException e) { 
    103             Console.traceln(Level.WARNING, "could not perform Mahalanobis outlier removal due to singular covariance matrix"); 
     99            inverseCovariance = new LUDecomposition(new Covariance(values).getCovarianceMatrix()) 
     100                .getSolver().getInverse(); 
     101        } 
     102        catch (SingularMatrixException e) { 
     103            Console 
     104                .traceln(Level.WARNING, 
     105                         "could not perform Mahalanobis outlier removal due to singular covariance matrix"); 
    104106            return; 
    105107        } 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/dataselection/NeighborhoodFilter.java

    r86 r135  
    3636    @Override 
    3737    public void setParameter(String parameters) { 
    38         // TODO Auto-generated method stub 
    39  
     38        // dummy, parameters not used 
    4039    } 
    4140 
    … …  
    5655     * </p> 
    5756     * 
    58      * @param testdata test data  
    59      * @param traindata training data 
     57     * @param testdata 
     58     *            test data 
     59     * @param traindata 
     60     *            training data 
    6061     * @return filtered trainind data 
    6162     */ 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/dataselection/PetersFilter.java

    r86 r135  
    2727 
    2828/** 
    29  * Filter according to F. Peters, T. Menzies, and A. Marcus: Better Cross Company Defect Prediction <br> 
     29 * Filter according to F. Peters, T. Menzies, and A. Marcus: Better Cross Company Defect Prediction 
     30 * <br> 
    3031 * <br> 
    3132 * This filter does not work, the paper has been withdrawn. 
    … …  
    3637public class PetersFilter implements IPointWiseDataselectionStrategy { 
    3738 
    38     /** 
     39    /* 
    3940     * @see de.ugoe.cs.cpdp.IParameterizable#setParameter(java.lang.String) 
    4041     */ 
    … …  
    4445    } 
    4546 
    46     /** 
     47    /* 
    4748     * @see de.ugoe.cs.cpdp.dataselection.IPointWiseDataselectionStrategy#apply(weka.core.Instances, 
    48      *      weka.core.Instances) 
     49     * weka.core.Instances) 
    4950     */ 
    5051    @Override 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/dataselection/PointWiseEMClusterSelection.java

    r86 r135  
    3131 * Use in Config: 
    3232 *  
    33  * Specify number of clusters -N = Num Clusters <pointwiseselector 
    34  * name="PointWiseEMClusterSelection" param="-N 10"/> 
     33 * Specify number of clusters -N = Num Clusters 
     34 * <pointwiseselector name="PointWiseEMClusterSelection" param="-N 10"/> 
    3535 *  
    3636 * Try to determine the number of clusters: -I 10 = max iterations -X 5 = 5 folds for cross 
    37  * evaluation -max = max number of clusters <pointwiseselector name="PointWiseEMClusterSelection" 
    38  * param="-I 10 -X 5 -max 300"/> 
     37 * evaluation -max = max number of clusters 
     38 * <pointwiseselector name="PointWiseEMClusterSelection" param="-I 10 -X 5 -max 300"/> 
    3939 *  
    4040 * Don't forget to add: <preprocessor name="Normalization" param=""/> 
    … …  
    4242public class PointWiseEMClusterSelection implements IPointWiseDataselectionStrategy { 
    4343 
     44    /** 
     45     * paramters passed to the selection 
     46     */ 
    4447    private String[] params; 
    4548 
     49    /* 
     50     * (non-Javadoc) 
     51     *  
     52     * @see de.ugoe.cs.cpdp.IParameterizable#setParameter(java.lang.String) 
     53     */ 
    4654    @Override 
    4755    public void setParameter(String parameters) { 
    … …  
    108116            } 
    109117 
    110             Console.traceln(Level.INFO, 
    111                             String.format("our testdata is in: " + selectedCluster.size() + 
    112                                 " different clusters")); 
     118            Console.traceln(Level.INFO, String 
     119                .format("our testdata is in: " + selectedCluster.size() + " different clusters")); 
    113120 
    114121            // 5. get cluster membership of our traindata 
    … …  
    127134            for (int j = 0; j < ctrain.numInstances(); j++) { 
    128135                // get the cluster number from the attributes 
    129                 cnumber = 
    130                     Integer.parseInt(ctrain.get(j).stringValue(ctrain.get(j).numAttributes() - 1) 
    131                         .replace("cluster", "")); 
     136                cnumber = Integer.parseInt(ctrain.get(j) 
     137                    .stringValue(ctrain.get(j).numAttributes() - 1).replace("cluster", "")); 
    132138 
    133139                // Console.traceln(Level.INFO, 
    … …  
    145151            } 
    146152 
    147             Console.traceln(Level.INFO, 
    148                             String.format("that leaves us with: " + selected.numInstances() + 
    149                                 " traindata instances from " + traindata.numInstances())); 
     153            Console.traceln(Level.INFO, String.format("that leaves us with: " + 
     154                selected.numInstances() + " traindata instances from " + traindata.numInstances())); 
    150155        } 
    151156        catch (Exception e) { 

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

    r86 r135  
    8686                    inst.setClassValue(1.0); 
    8787                    sample.add(inst); 
    88                     inst = 
    89                         new DenseInstance( 
    90                                           traindata.instance(rand.nextInt(traindata.numInstances()))); 
     88                    inst = new DenseInstance(traindata 
     89                        .instance(rand.nextInt(traindata.numInstances()))); 
    9190                    inst.setDataset(sample); 
    9291                    inst.setClassValue(0.0); 
    … …  
    101100                } 
    102101                catch (Exception e) { 
    103                     throw new RuntimeException( 
    104                                                "cross-validation during calculation of separatability failed", 
     102                    throw new RuntimeException("cross-validation during calculation of separatability failed", 
    105103                                               e); 
    106104                } 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/dataselection/SetWiseEMClusterSelection.java

    r86 r135  
    7474        } 
    7575        catch (Exception e) { 
    76             throw new RuntimeException( 
    77                                        "error applying setwise EM clustering training data selection", 
     76            throw new RuntimeException("error applying setwise EM clustering training data selection", 
    7877                                       e); 
    7978        } 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/dataselection/SetWiseEMContextSelection.java

    r86 r135  
    4141public class SetWiseEMContextSelection implements ISetWiseDataselectionStrategy { 
    4242 
     43    /** 
     44     * context factors 
     45     */ 
    4346    private String[] project_context_factors; // = new String[]{"TND", "TNC", "TNF", "TLOC"}; 
    4447 
     48    /* 
     49     * (non-Javadoc) 
     50     *  
     51     * @see de.ugoe.cs.cpdp.IParameterizable#setParameter(java.lang.String) 
     52     */ 
    4553    @Override 
    4654    public void setParameter(String parameters) { 
    … …  
    103111        } 
    104112        catch (Exception e) { 
    105             throw new RuntimeException( 
    106                                        "error applying setwise EM clustering training data selection", 
     113            throw new RuntimeException("error applying setwise EM clustering training data selection", 
    107114                                       e); 
    108115        } 
    109116    } 
    110117 
     118    /* 
     119     * (non-Javadoc) 
     120     *  
     121     * @see de.ugoe.cs.cpdp.dataselection.ISetWiseDataselectionStrategy#apply(weka.core.Instances, 
     122     * org.apache.commons.collections4.list.SetUniqueList) 
     123     */ 
    111124    @Override 
    112125    public void apply(Instances testdata, SetUniqueList<Instances> traindataSet) { 
    … …  
    131144     * @return 
    132145     */ 
    133     protected Instances getContextFactors(Instances testdata, SetUniqueList<Instances> traindataSet) 
     146    protected Instances getContextFactors(Instances testdata, 
     147                                          SetUniqueList<Instances> traindataSet) 
    134148    { 
    135149        // setup weka Instances for clustering 
    … …  
    190204                remove.add(traindata); 
    191205                // Console.traceln(Level.WARNING, 
    192                 // "rmove attribute "+attribute+" test: "+testdata.firstInstance().value(testdata.attribute(attribute))+" train: "+traindata.firstInstance().value(traindata.attribute(attribute))); 
     206                // "rmove attribute "+attribute+" test: 
     207                // "+testdata.firstInstance().value(testdata.attribute(attribute))+" train: 
     208                // "+traindata.firstInstance().value(traindata.attribute(attribute))); 
    193209            } 
    194210        } 
    … …  
    218234        } 
    219235        catch (Exception e) { 
    220             throw new RuntimeException( 
    221                                        "Unexpected exception during normalization of distributional characteristics.", 
     236            throw new RuntimeException("Unexpected exception during normalization of distributional characteristics.", 
    222237                                       e); 
    223238        } 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/dataselection/SetWiseKNNSelection.java

    r86 r135  
    7171        int closestIndex = 1; 
    7272        for (int i = 1; i < data.numInstances(); i++) { 
    73             double distance = 
    74                 MathArrays.distance(data.instance(0).toDoubleArray(), data.instance(i) 
    75                     .toDoubleArray()); 
     73            double distance = MathArrays.distance(data.instance(0).toDoubleArray(), 
     74                                                  data.instance(i).toDoubleArray()); 
    7675            if (distance < closestDistance) { 
    7776                closestDistance = distance; 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/dataselection/SynonymOutlierRemoval.java

    r86 r135  
    1919/** 
    2020 * <p> 
    21  * Synonym outlier removal after Amasaki et al. (2015).  
     21 * Synonym outlier removal after Amasaki et al. (2015). 
    2222 * </p> 
    2323 *  
    … …  
    2626public class SynonymOutlierRemoval implements IPointWiseDataselectionStrategy { 
    2727 
    28     /* (non-Javadoc) 
     28    /* 
     29     * (non-Javadoc) 
     30     *  
    2931     * @see de.ugoe.cs.cpdp.IParameterizable#setParameter(java.lang.String) 
    3032     */ 
    … …  
    3436    } 
    3537 
    36     /* (non-Javadoc) 
    37      * @see de.ugoe.cs.cpdp.dataselection.IPointWiseDataselectionStrategy#apply(weka.core.Instances, weka.core.Instances) 
     38    /* 
     39     * (non-Javadoc) 
     40     *  
     41     * @see de.ugoe.cs.cpdp.dataselection.IPointWiseDataselectionStrategy#apply(weka.core.Instances, 
     42     * weka.core.Instances) 
    3843     */ 
    3944    @Override 
    … …  
    4853     * </p> 
    4954     * 
    50      * @param traindata data from which the outliers are removed. 
     55     * @param traindata 
     56     *            data from which the outliers are removed. 
    5157     */ 
    5258    public void applySynonymRemoval(Instances traindata) { 
    53         double minDistance[][] = new double[traindata.size()][traindata.numAttributes()-1]; 
    54         double minDistanceAttribute[] = new double[traindata.numAttributes()-1]; 
     59        double minDistance[][] = new double[traindata.size()][traindata.numAttributes() - 1]; 
     60        double minDistanceAttribute[] = new double[traindata.numAttributes() - 1]; 
    5561        double distance; 
    56         for( int j=0; j<minDistanceAttribute.length; j++ ) { 
     62        for (int j = 0; j < minDistanceAttribute.length; j++) { 
    5763            minDistanceAttribute[j] = Double.MAX_VALUE; 
    5864        } 
    59         for (int i1 = traindata.size()-1; i1 < traindata.size(); i1++) { 
    60             int k=0; 
     65        for (int i1 = traindata.size() - 1; i1 < traindata.size(); i1++) { 
     66            int k = 0; 
    6167            for (int j = 0; j < traindata.numAttributes(); j++) { 
    62                 if( j!=traindata.classIndex() ) { 
     68                if (j != traindata.classIndex()) { 
    6369                    minDistance[i1][k] = Double.MAX_VALUE; 
    6470                    for (int i2 = 0; i2 < traindata.size(); i2++) { 
    6571                        if (i1 != i2) { 
    66                             distance = Math.abs(traindata.get(i1).value(j) - traindata.get(i2).value(j)); 
     72                            distance = 
     73                                Math.abs(traindata.get(i1).value(j) - traindata.get(i2).value(j)); 
    6774                            if (distance < minDistance[i1][k]) { 
    6875                                minDistance[i1][k] = distance; 
    6976                            } 
    70                             if( distance < minDistanceAttribute[k] ) { 
     77                            if (distance < minDistanceAttribute[k]) { 
    7178                                minDistanceAttribute[k] = distance; 
    7279                            } 
    … …  
    7784            } 
    7885        } 
    79         for( int i=traindata.size()-1; i>=0; i-- ) { 
     86        for (int i = traindata.size() - 1; i >= 0; i--) { 
    8087            boolean hasClosest = false; 
    81             for( int j=0; !hasClosest && j<traindata.numAttributes(); j++ ) { 
    82                 hasClosest = minDistance[i][j]<=minDistanceAttribute[j]; 
     88            for (int j = 0; !hasClosest && j < traindata.numAttributes(); j++) { 
     89                hasClosest = minDistance[i][j] <= minDistanceAttribute[j]; 
    8390            } 
    84             if( !hasClosest ) { 
     91            if (!hasClosest) { 
    8592                traindata.delete(i); 
    8693            } 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/eval/AbstractWekaEvaluation.java

    r132 r135  
    3636 * <ul> 
    3737 * <li>succHe: Success with recall>0.7, precision>0.5</li> 
    38  * <li>succZi: Success with recall>0.7, precision>0.7</li> 
     38 * <li>succZi: Success with recall>=0.75, precision>=0.7, and error<=0.25</li> 
    3939 * <li>succG75: Success with gscore>0.75</li> 
    4040 * <li>succG60: Success with gscore>0.6</li> 
    … …  
    6666    private PrintWriter output = new PrintWriter(System.out); 
    6767 
     68    /** 
     69     * flag that defines if the output is the system out 
     70     */ 
    6871    private boolean outputIsSystemOut = true; 
    69      
     72 
     73    /** 
     74     * name of the configuration 
     75     */ 
    7076    private String configurationName = "default"; 
    7177 
    … …  
    9298                      Instances traindata, 
    9399                      List<ITrainer> trainers, 
    94                       List<Double> efforts,  
     100                      List<Double> efforts, 
    95101                      boolean writeHeader, 
    96102                      List<IResultStorage> storages) 
    … …  
    99105        final List<ExperimentResult> experimentResults = new LinkedList<>(); 
    100106        String productName = testdata.relationName(); 
    101          
     107 
    102108        for (ITrainer trainer : trainers) { 
    103109            if (trainer instanceof IWekaCompatibleTrainer) { 
    104110                classifiers.add(((IWekaCompatibleTrainer) trainer).getClassifier()); 
    105                 experimentResults.add(new ExperimentResult(configurationName, productName, ((IWekaCompatibleTrainer) trainer).getName())); 
     111                experimentResults 
     112                    .add(new ExperimentResult(configurationName, productName, 
     113                                              ((IWekaCompatibleTrainer) trainer).getName())); 
    106114            } 
    107115            else { 
    … …  
    153161            double aucec = calculateReviewEffort(testdata, classifier, efforts); 
    154162            double succHe = eval.recall(1) >= 0.7 && eval.precision(1) >= 0.5 ? 1.0 : 0.0; 
    155             double succZi = eval.recall(1) >= 0.7 && eval.precision(1) >= 0.7 ? 1.0 : 0.0; 
     163            double succZi = eval.recall(1) >= 0.75 && eval.precision(1) >= 0.75 && eval.errorRate()<=0.25 ? 1.0 : 0.0; 
    156164            double succG75 = gmeasure > 0.75 ? 1.0 : 0.0; 
    157165            double succG60 = gmeasure > 0.6 ? 1.0 : 0.0; 
    158              
     166 
    159167            output.append("," + succHe); 
    160168            output.append("," + succZi); 
    161169            output.append("," + succG75); 
    162             output.append("," + succG60);             
     170            output.append("," + succG60); 
    163171            output.append("," + eval.errorRate()); 
    164172            output.append("," + eval.recall(1)); 
    … …  
    177185            output.append("," + eval.numTrueNegatives(1)); 
    178186            output.append("," + eval.numFalsePositives(1)); 
    179              
     187 
    180188            ExperimentResult result = resultIter.next(); 
    181189            result.setSizeTestData(testdata.numInstances()); 
    182190            result.setSizeTrainingData(traindata.numInstances()); 
    183             result.setSuccHe(succHe); 
    184             result.setSuccZi(succZi); 
    185             result.setSuccG75(succG75); 
    186             result.setSuccG60(succG60); 
    187191            result.setError(eval.errorRate()); 
    188192            result.setRecall(eval.recall(1)); 
    … …  
    201205            result.setTn(eval.numTrueNegatives(1)); 
    202206            result.setFp(eval.numFalsePositives(1)); 
    203             for( IResultStorage storage : storages ) { 
     207            for (IResultStorage storage : storages) { 
    204208                storage.addResult(result); 
    205209            } 
    … …  
    209213        output.flush(); 
    210214    } 
    211      
    212     private double calculateReviewEffort(Instances testdata, Classifier classifier, List<Double> efforts) { 
    213         if( efforts==null ) { 
     215 
     216    /** 
     217     * <p> 
     218     * Calculates the effort. TODO: IMPLEMENTATION BUGGY! MUST BE FIXED! 
     219     * </p> 
     220     * 
     221     * @param testdata 
     222     *            the test data 
     223     * @param classifier 
     224     *            the classifier 
     225     * @param efforts 
     226     *            the effort information for each instance in the test data 
     227     * @return 
     228     */ 
     229    private double calculateReviewEffort(Instances testdata, 
     230                                         Classifier classifier, 
     231                                         List<Double> efforts) 
     232    { 
     233        if (efforts == null) { 
    214234            return 0; 
    215235        } 
    216          
     236 
    217237        final List<Integer> bugPredicted = new ArrayList<>(); 
    218238        final List<Integer> nobugPredicted = new ArrayList<>(); 
    … …  
    229249            } 
    230250            catch (Exception e) { 
    231                 throw new RuntimeException( 
    232                                            "unexpected error during the evaluation of the review effort", 
     251                throw new RuntimeException("unexpected error during the evaluation of the review effort", 
    233252                                           e); 
    234253            } 
    … …  
    297316    } 
    298317 
     318    /** 
     319     * <p> 
     320     * Calculates effort. Deprecated. Do not use! 
     321     * </p> 
     322     * 
     323     * @param testdata 
     324     *            the test data 
     325     * @param classifier 
     326     *            the classifier 
     327     * @return 
     328     */ 
    299329    @SuppressWarnings("unused") 
    300330    @Deprecated 
    … …  
    315345            loc = testdata.attribute("CountLineCodeExe"); 
    316346        } 
    317         if( loc == null ) { 
     347        if (loc == null) { 
    318348            return 0.0; 
    319349        } 
    … …  
    333363            } 
    334364            catch (Exception e) { 
    335                 throw new RuntimeException( 
    336                                            "unexpected error during the evaluation of the review effort", 
     365                throw new RuntimeException("unexpected error during the evaluation of the review effort", 
    337366                                           e); 
    338367            } 
    … …  
    419448                output = new PrintWriter(new FileOutputStream(parameters)); 
    420449                outputIsSystemOut = false; 
    421                 int filenameStart = parameters.lastIndexOf('/')+1; 
     450                int filenameStart = parameters.lastIndexOf('/') + 1; 
    422451                int filenameEnd = parameters.lastIndexOf('.'); 
    423452                configurationName = parameters.substring(filenameStart, filenameEnd); 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/eval/CVWekaEvaluation.java

    r86 r135  
    3131public class CVWekaEvaluation extends AbstractWekaEvaluation { 
    3232 
    33     /** 
     33    /* 
    3434     * @see de.ugoe.cs.cpdp.eval.AbstractWekaEvaluation#createEvaluator(weka.core.Instances, 
    3535     *      weka.classifiers.Classifier) 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/eval/ExperimentResult.java

    r68 r135  
     1 
    12package de.ugoe.cs.cpdp.eval; 
    23 
     4/** 
     5 * <p> 
     6 * Data class to store experiment results 
     7 * </p> 
     8 *  
     9 * @author Steffen Herbold 
     10 */ 
    311public class ExperimentResult { 
    412 
     13    /** 
     14     * configuration name of the experiment 
     15     */ 
    516    private final String configurationName; 
     17 
     18    /** 
     19     * name of the target product 
     20     */ 
    621    private final String productName; 
     22 
     23    /** 
     24     * name of the classifier used 
     25     */ 
    726    private final String classifier; 
    8      
     27 
     28    /** 
     29     * number of instances of the target product 
     30     */ 
     31    int sizeTestData; 
     32 
     33    /** 
     34     * number of instances of the training data 
     35     */ 
     36    int sizeTrainingData; 
     37 
     38    /** 
     39     * error of the prediction 
     40     */ 
     41    double error = Double.NaN; 
     42 
     43    /** 
     44     * recall of the prediction 
     45     */ 
     46    double recall = Double.NaN; 
     47 
     48    /** 
     49     * precision of the prediction 
     50     */ 
     51    double precision = Double.NaN; 
     52 
     53    /** 
     54     * F1 score of the prediction 
     55     */ 
     56    double fscore = Double.NaN; 
     57 
     58    /** 
     59     * G score of the prediction 
     60     */ 
     61    double gscore = Double.NaN; 
     62 
     63    /** 
     64     * Matthews correlation coefficient of the prediction 
     65     */ 
     66    double mcc = Double.NaN; 
     67 
     68    /** 
     69     * Area under the curve of the prediction 
     70     */ 
     71    double auc = Double.NaN; 
     72 
     73    /** 
     74     * Effort of the prediction 
     75     */ 
     76    double aucec = Double.NaN; 
     77 
     78    /** 
     79     * True positive rate of the prediction 
     80     */ 
     81    double tpr = Double.NaN; 
     82 
     83    /** 
     84     * True negative rate of the prediction 
     85     */ 
     86    double tnr = Double.NaN; 
     87 
     88    /** 
     89     * false positive rate of the prediction 
     90     */ 
     91    double fpr = Double.NaN; 
     92 
     93    /** 
     94     * false negative rate of the prediction 
     95     */ 
     96    double fnr = Double.NaN; 
     97 
     98    /** 
     99     * number of true positives 
     100     */ 
     101    double tp = Double.NaN; 
     102 
     103    /** 
     104     * number of false negatives 
     105     */ 
     106    double fn = Double.NaN; 
     107 
     108    /** 
     109     * number of true negatives 
     110     */ 
     111    double tn = Double.NaN; 
     112 
     113    /** 
     114     * number of false positives 
     115     */ 
     116    double fp = Double.NaN; 
     117 
     118    /** 
     119     * <p> 
     120     * Constructor. Creates a new ExperimentResult. 
     121     * </p> 
     122     * 
     123     * @param configurationName 
     124     *            the configuration name 
     125     * @param productName 
     126     *            the product name 
     127     * @param classifier 
     128     *            the classifier name 
     129     */ 
    9130    public ExperimentResult(String configurationName, String productName, String classifier) { 
    10131        this.configurationName = configurationName; 
    … …  
    12133        this.classifier = classifier; 
    13134    } 
    14      
    15     int sizeTestData; 
    16     int sizeTrainingData; 
    17     double succHe = Double.NaN; 
    18     double succZi = Double.NaN; 
    19     double succG75 = Double.NaN; 
    20     double succG60 = Double.NaN; 
    21     double error = Double.NaN; 
    22     double recall = Double.NaN; 
    23     double precision = Double.NaN; 
    24     double fscore = Double.NaN; 
    25     double gscore = Double.NaN; 
    26     double mcc = Double.NaN; 
    27     double auc = Double.NaN; 
    28     double aucec = Double.NaN; 
    29     double tpr = Double.NaN; 
    30     double tnr = Double.NaN; 
    31     double fpr = Double.NaN; 
    32     double fnr = Double.NaN; 
    33     double tp = Double.NaN; 
    34     double fn = Double.NaN; 
    35     double tn = Double.NaN; 
    36     double fp = Double.NaN; 
    37  
     135 
     136    /** 
     137     * <p> 
     138     * returns the configuration name 
     139     * </p> 
     140     * 
     141     * @return the configuration name 
     142     */ 
    38143    public String getConfigurationName() { 
    39144        return configurationName; 
    40145    } 
     146 
     147    /** 
     148     * <p> 
     149     * returns the product name 
     150     * </p> 
     151     * 
     152     * @return the product name 
     153     */ 
    41154    public String getProductName() { 
    42155        return productName; 
    43156    } 
     157 
     158    /** 
     159     * <p> 
     160     * returns the classifier name 
     161     * </p> 
     162     * 
     163     * @return the classifier name 
     164     */ 
    44165    public String getClassifier() { 
    45166        return classifier; 
    46167    } 
     168 
     169    /** 
     170     * <p> 
     171     * returns the number of instances of the target product 
     172     * </p> 
     173     * 
     174     * @return number of instances 
     175     */ 
    47176    public int getSizeTestData() { 
    48177        return sizeTestData; 
    49178    } 
     179 
     180    /** 
     181     * <p> 
     182     * sets the number of instances of the target product 
     183     * </p> 
     184     * 
     185     * @param sizeTestData 
     186     *            number of instances 
     187     */ 
    50188    public void setSizeTestData(int sizeTestData) { 
    51189        this.sizeTestData = sizeTestData; 
    52190    } 
     191 
     192    /** 
     193     * <p> 
     194     * returns the number of instances of the training data 
     195     * </p> 
     196     * 
     197     * @return number of instances 
     198     */ 
    53199    public int getSizeTrainingData() { 
    54200        return sizeTrainingData; 
    55201    } 
     202 
     203    /** 
     204     * <p> 
     205     * sets the number of instances of the training data 
     206     * </p> 
     207     * 
     208     * @param sizeTrainingData 
     209     *            number of instances 
     210     */ 
    56211    public void setSizeTrainingData(int sizeTrainingData) { 
    57212        this.sizeTrainingData = sizeTrainingData; 
    58213    } 
    59     public double getSuccHe() { 
    60         return succHe; 
    61     } 
    62     public void setSuccHe(double succHe) { 
    63         this.succHe = succHe; 
    64     } 
    65     public double getSuccZi() { 
    66         return succZi; 
    67     } 
    68     public void setSuccZi(double succZi) { 
    69         this.succZi = succZi; 
    70     } 
    71     public double getSuccG75() { 
    72         return succG75; 
    73     } 
    74     public void setSuccG75(double succG75) { 
    75         this.succG75 = succG75; 
    76     } 
    77     public double getSuccG60() { 
    78         return succG60; 
    79     } 
    80     public void setSuccG60(double succG60) { 
    81         this.succG60 = succG60; 
    82     } 
     214 
     215    /** 
     216     * <p> 
     217     * returns the error 
     218     * </p> 
     219     * 
     220     * @return the error 
     221     */ 
    83222    public double getError() { 
    84223        return error; 
    85224    } 
     225 
     226    /** 
     227     * <p> 
     228     * sets the error 
     229     * </p> 
     230     * 
     231     * @param error 
     232     *            the error 
     233     */ 
    86234    public void setError(double error) { 
    87235        this.error = error; 
    88236    } 
     237 
     238    /** 
     239     * <p> 
     240     * returns the recall 
     241     * </p> 
     242     * 
     243     * @return the recall 
     244     */ 
    89245    public double getRecall() { 
    90246        return recall; 
    91247    } 
     248 
     249    /** 
     250     * <p> 
     251     * sets the recall 
     252     * </p> 
     253     * 
     254     * @param recall 
     255     *            the recall 
     256     */ 
    92257    public void setRecall(double recall) { 
    93258        this.recall = recall; 
    94259    } 
     260 
     261    /** 
     262     * <p> 
     263     * returns the precision 
     264     * </p> 
     265     * 
     266     * @return the precision 
     267     */ 
    95268    public double getPrecision() { 
    96269        return precision; 
    97270    } 
     271 
     272    /** 
     273     * <p> 
     274     * sets the precision 
     275     * </p> 
     276     * 
     277     * @param precision 
     278     *            the precision 
     279     */ 
    98280    public void setPrecision(double precision) { 
    99281        this.precision = precision; 
    100282    } 
     283 
     284    /** 
     285     * <p> 
     286     * returns the F1 score 
     287     * </p> 
     288     * 
     289     * @return the F1 score 
     290     */ 
    101291    public double getFscore() { 
    102292        return fscore; 
    103293    } 
     294 
     295    /** 
     296     * <p> 
     297     * sets the F1 score 
     298     * </p> 
     299     * 
     300     * @param fscore 
     301     *            the F1 score 
     302     */ 
    104303    public void setFscore(double fscore) { 
    105304        this.fscore = fscore; 
    106305    } 
     306 
     307    /** 
     308     * <p> 
     309     * returns the G score 
     310     * </p> 
     311     * 
     312     * @return the G score 
     313     */ 
    107314    public double getGscore() { 
    108315        return gscore; 
    109316    } 
     317 
     318    /** 
     319     * <p> 
     320     * sets the G score 
     321     * </p> 
     322     * 
     323     * @param gscore 
     324     *            the G score 
     325     */ 
    110326    public void setGscore(double gscore) { 
    111327        this.gscore = gscore; 
    112328    } 
     329 
     330    /** 
     331     * <p> 
     332     * returns the MCC 
     333     * </p> 
     334     * 
     335     * @return the MCC 
     336     */ 
    113337    public double getMcc() { 
    114338        return mcc; 
    115339    } 
     340 
     341    /** 
     342     * <p> 
     343     * sets the MCC 
     344     * </p> 
     345     * 
     346     * @param mcc 
     347     *            the MCC 
     348     */ 
    116349    public void setMcc(double mcc) { 
    117350        this.mcc = mcc; 
    118351    } 
     352 
     353    /** 
     354     * <p> 
     355     * returns the AUC 
     356     * </p> 
     357     * 
     358     * @return the AUC 
     359     */ 
    119360    public double getAuc() { 
    120361        return auc; 
    121362    } 
     363 
     364    /** 
     365     * <p> 
     366     * sets the AUC 
     367     * </p> 
     368     * 
     369     * @param auc 
     370     *            the AUC 
     371     */ 
    122372    public void setAuc(double auc) { 
    123373        this.auc = auc; 
    124374    } 
     375 
     376    /** 
     377     * <p> 
     378     * returns the effort as AUCEC 
     379     * </p> 
     380     * 
     381     * @return the effort 
     382     */ 
    125383    public double getAucec() { 
    126384        return aucec; 
    127385    } 
     386 
     387    /** 
     388     * <p> 
     389     * sets the effort as AUCEC 
     390     * </p> 
     391     * 
     392     * @param aucec 
     393     *            the effort 
     394     */ 
    128395    public void setAucec(double aucec) { 
    129396        this.aucec = aucec; 
    130397    } 
     398 
     399    /** 
     400     * <p> 
     401     * returns the TPR 
     402     * </p> 
     403     * 
     404     * @return the TPR 
     405     */ 
    131406    public double getTpr() { 
    132407        return tpr; 
    133408    } 
     409 
     410    /** 
     411     * <p> 
     412     * sets the TPR 
     413     * </p> 
     414     * 
     415     * @param tpr 
     416     *            the TPR 
     417     */ 
    134418    public void setTpr(double tpr) { 
    135419        this.tpr = tpr; 
    136420    } 
     421 
     422    /** 
     423     * <p> 
     424     * sets the TNR 
     425     * </p> 
     426     * 
     427     * @return the TNR 
     428     */ 
    137429    public double getTnr() { 
    138430        return tnr; 
    139431    } 
     432 
     433    /** 
     434     * <p> 
     435     * sets the TNR 
     436     * </p> 
     437     * 
     438     * @param tnr 
     439     *            the TNR 
     440     */ 
    140441    public void setTnr(double tnr) { 
    141442        this.tnr = tnr; 
    142443    } 
     444 
     445    /** 
     446     * <p> 
     447     * returns the FPR 
     448     * </p> 
     449     * 
     450     * @return the FPR 
     451     */ 
    143452    public double getFpr() { 
    144453        return fpr; 
    145454    } 
     455 
     456    /** 
     457     * <p> 
     458     * sets the FPR 
     459     * </p> 
     460     * 
     461     * @param fpr 
     462     *            the FPR 
     463     */ 
    146464    public void setFpr(double fpr) { 
    147465        this.fpr = fpr; 
    148466    } 
     467 
     468    /** 
     469     * <p> 
     470     * returns the FNR 
     471     * </p> 
     472     * 
     473     * @return the FNR 
     474     */ 
    149475    public double getFnr() { 
    150476        return fnr; 
    151477    } 
     478 
     479    /** 
     480     * <p> 
     481     * sets the FNR 
     482     * </p> 
     483     * 
     484     * @param fnr 
     485     *            the FNR 
     486     */ 
    152487    public void setFnr(double fnr) { 
    153488        this.fnr = fnr; 
    154489    } 
     490 
     491    /** 
     492     * <p> 
     493     * returns the TPs 
     494     * </p> 
     495     * 
     496     * @return the TPs 
     497     */ 
    155498    public double getTp() { 
    156499        return tp; 
    157500    } 
     501 
     502    /** 
     503     * <p> 
     504     * sets the TPs 
     505     * </p> 
     506     * 
     507     * @param tp 
     508     *            the TPs 
     509     */ 
    158510    public void setTp(double tp) { 
    159511        this.tp = tp; 
    160512    } 
     513 
     514    /** 
     515     * <p> 
     516     * returns the FNs 
     517     * </p> 
     518     * 
     519     * @return the FNs 
     520     */ 
    161521    public double getFn() { 
    162522        return fn; 
    163523    } 
     524 
     525    /** 
     526     * <p> 
     527     * sets the FNs 
     528     * </p> 
     529     * 
     530     * @param fn 
     531     */ 
    164532    public void setFn(double fn) { 
    165533        this.fn = fn; 
    166534    } 
     535 
     536    /** 
     537     * <p> 
     538     * returns the TNs 
     539     * </p> 
     540     * 
     541     * @return the TNs 
     542     */ 
    167543    public double getTn() { 
    168544        return tn; 
    169545    } 
     546 
     547    /** 
     548     * <p> 
     549     * sets the TNs 
     550     * </p> 
     551     * 
     552     * @param tn 
     553     *            the TNs 
     554     */ 
    170555    public void setTn(double tn) { 
    171556        this.tn = tn; 
    172557    } 
     558 
     559    /** 
     560     * <p> 
     561     * returns the FPs 
     562     * </p> 
     563     * 
     564     * @return the FPs 
     565     */ 
    173566    public double getFp() { 
    174567        return fp; 
    175568    } 
     569 
     570    /** 
     571     * <p> 
     572     * sets the FPs 
     573     * </p> 
     574     * 
     575     * @param fp 
     576     *            the FPs 
     577     */ 
    176578    public void setFp(double fp) { 
    177579        this.fp = fp; 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/eval/MySQLResultStorage.java

    r121 r135  
    2222import java.util.Properties; 
    2323 
    24  
    2524import com.mysql.jdbc.jdbc2.optional.MysqlDataSource; 
    2625 
    … …  
    3736public class MySQLResultStorage implements IResultStorage { 
    3837 
    39     /** 
    40      * Connection to the database 
    41      */ 
    42     //private Connection con = null; 
    43      
    4438    /** 
    4539     * Connection pool for the data base. 
    … …  
    121115        sql.append(result.getSizeTestData() + ","); 
    122116        sql.append(result.getSizeTrainingData() + ","); 
    123         sql.append(result.getSuccHe() + ","); 
    124         sql.append(result.getSuccZi() + ","); 
    125         sql.append(result.getSuccG75() + ","); 
    126         sql.append(result.getSuccG60() + ","); 
    127117        sql.append(result.getError() + ","); 
    128118        sql.append(result.getRecall() + ","); 
    … …  
    164154    public int containsResult(String experimentName, String productName, String classifierName) { 
    165155        String sql = "SELECT COUNT(*) as cnt FROM crosspare.results WHERE configurationName=\'" + 
    166             experimentName + "\' AND productName=\'" + productName + "\' AND classifier=\'" + classifierName + "\';"; 
     156            experimentName + "\' AND productName=\'" + productName + "\' AND classifier=\'" + 
     157            classifierName + "\';"; 
    167158        Statement stmt; 
    168159        try { 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/eval/NormalWekaEvaluation.java

    r86 r135  
    2727public class NormalWekaEvaluation extends AbstractWekaEvaluation { 
    2828 
    29     /** 
     29    /* 
    3030     * @see de.ugoe.cs.cpdp.eval.AbstractWekaEvaluation#createEvaluator(weka.core.Instances, 
    31      *      weka.classifiers.Classifier) 
     31     * weka.classifiers.Classifier) 
    3232     */ 
    3333    @Override 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/execution/AbstractCrossProjectExperiment.java

    r132 r135  
    155155            } 
    156156        } 
    157          
     157 
    158158        // sort versions 
    159159        Collections.sort(versions); 
    … …  
    342342    } 
    343343 
     344    /** 
     345     * <p> 
     346     * helper function that checks if the results are already in the data store 
     347     * </p> 
     348     * 
     349     * @param version 
     350     *            version for which the results are checked 
     351     * @return 
     352     */ 
    344353    private int resultsAvailable(SoftwareVersion version) { 
    345354        if (config.getResultStorages().isEmpty()) { 
    346355            return 0; 
    347356        } 
    348          
     357 
    349358        List<ITrainer> allTrainers = new LinkedList<>(); 
    350359        for (ISetWiseTrainingStrategy setwiseTrainer : config.getSetWiseTrainers()) { 
    … …  
    362371            allTrainers.add(trainer); 
    363372        } 
    364          
     373 
    365374        int available = Integer.MAX_VALUE; 
    366375        for (IResultStorage storage : config.getResultStorages()) { 
    367376            String classifierName = ((IWekaCompatibleTrainer) allTrainers.get(0)).getName(); 
    368             int curAvailable = storage.containsResult(config.getExperimentName(), version.getVersion(), classifierName); 
    369             if( curAvailable<available ) { 
     377            int curAvailable = storage.containsResult(config.getExperimentName(), 
     378                                                      version.getVersion(), classifierName); 
     379            if (curAvailable < available) { 
    370380                available = curAvailable; 
    371381            } 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/execution/ClassifierCreationExperiment.java

    r132 r135  
    107107 
    108108            for (IProcessesingStrategy processor : config.getPreProcessors()) { 
    109                 Console.traceln(Level.FINE, String 
    110                     .format("[%s] [%02d/%02d] %s: applying preprocessor %s", 
    111                             config.getExperimentName(), versionCount, versions.size(), 
    112                             testVersion.getProject(), processor.getClass().getName())); 
     109                Console.traceln(Level.FINE, 
     110                                String.format("[%s] [%02d/%02d] %s: applying preprocessor %s", 
     111                                              config.getExperimentName(), versionCount, 
     112                                              versions.size(), testVersion.getProject(), 
     113                                              processor.getClass().getName())); 
    113114                processor.apply(testdata, traindata); 
    114115            } 
    115116 
    116117            for (IPointWiseDataselectionStrategy dataselector : config.getPointWiseSelectors()) { 
    117                 Console.traceln(Level.FINE, String 
    118                     .format("[%s] [%02d/%02d] %s: applying pointwise selection %s", 
    119                             config.getExperimentName(), versionCount, versions.size(), 
    120                             testVersion.getProject(), dataselector.getClass().getName())); 
     118                Console 
     119                    .traceln(Level.FINE, 
     120                             String.format("[%s] [%02d/%02d] %s: applying pointwise selection %s", 
     121                                           config.getExperimentName(), versionCount, 
     122                                           versions.size(), testVersion.getProject(), 
     123                                           dataselector.getClass().getName())); 
    121124                traindata = dataselector.apply(testdata, traindata); 
    122125            } 
    123126 
    124127            for (IProcessesingStrategy processor : config.getPostProcessors()) { 
    125                 Console.traceln(Level.FINE, String 
    126                     .format("[%s] [%02d/%02d] %s: applying setwise postprocessor %s", 
    127                             config.getExperimentName(), versionCount, versions.size(), 
    128                             testVersion.getProject(), processor.getClass().getName())); 
     128                Console 
     129                    .traceln(Level.FINE, 
     130                             String.format("[%s] [%02d/%02d] %s: applying setwise postprocessor %s", 
     131                                           config.getExperimentName(), versionCount, 
     132                                           versions.size(), testVersion.getProject(), 
     133                                           processor.getClass().getName())); 
    129134                processor.apply(testdata, traindata); 
    130135            } 
    … …  
    148153                    try { 
    149154                        weka.core.SerializationHelper.write(resultsDir.getAbsolutePath() + "/" + 
    150                                                                 trainer.getName() + "-" + 
    151                                                                 testVersion.getProject(), 
     155                            trainer.getName() + "-" + testVersion.getProject(), 
    152156                                                            trainerToSave.getClassifier()); 
    153157                    } 
    … …  
    160164 
    161165            for (IEvaluationStrategy evaluator : config.getEvaluators()) { 
    162                 Console.traceln(Level.FINE, String 
    163                     .format("[%s] [%02d/%02d] %s: applying evaluator %s", 
    164                             config.getExperimentName(), versionCount, versions.size(), 
    165                             testVersion.getProject(), evaluator.getClass().getName())); 
     166                Console.traceln(Level.FINE, 
     167                                String.format("[%s] [%02d/%02d] %s: applying evaluator %s", 
     168                                              config.getExperimentName(), versionCount, 
     169                                              versions.size(), testVersion.getProject(), 
     170                                              evaluator.getClass().getName())); 
    166171 
    167172                if (writeHeader) { 
    … …  
    169174                        config.getExperimentName() + ".csv"); 
    170175                } 
    171                 evaluator.apply(testdata, traindata, allTrainers, efforts, writeHeader, config.getResultStorages()); 
     176                evaluator.apply(testdata, traindata, allTrainers, efforts, writeHeader, 
     177                                config.getResultStorages()); 
    172178                writeHeader = false; 
    173179            } 
    … …  
    175181            versionCount++; 
    176182 
    177             Console.traceln(Level.INFO, String.format("[%s] [%02d/%02d] %s: finished", 
    178                                                       config.getExperimentName(), versionCount, 
    179                                                       versions.size(), testVersion.getProject())); 
     183            Console.traceln(Level.INFO, 
     184                            String.format("[%s] [%02d/%02d] %s: finished", 
     185                                          config.getExperimentName(), versionCount, versions.size(), 
     186                                          testVersion.getProject())); 
    180187 
    181188        } 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/execution/CrossValidationExperiment.java

    r132 r135  
    138138            } 
    139139        } 
    140          
     140 
    141141        numTrainers += config.getSetWiseTrainers().size(); 
    142142        numTrainers += config.getSetWiseTestdataAwareTrainers().size(); 
    … …  
    154154                                              testVersionCount, testVersion.getVersion())); 
    155155                int numResultsAvailable = resultsAvailable(testVersion); 
    156                 if (numResultsAvailable >= numTrainers*config.getRepetitions()) { 
     156                if (numResultsAvailable >= numTrainers * config.getRepetitions()) { 
    157157                    Console.traceln(Level.INFO, 
    158158                                    String.format( 
    … …  
    167167                Instances testdata = testVersion.getInstances(); 
    168168                List<Double> efforts = testVersion.getEfforts(); 
    169                  
     169 
    170170                for (ITrainingStrategy trainer : config.getTrainers()) { 
    171171                    Console.traceln(Level.FINE, 
    … …  
    176176                    trainer.apply(testdata); 
    177177                } 
    178                  
     178 
    179179                File resultsDir = new File(config.getResultsPath()); 
    180180                if (!resultsDir.exists()) { 
    … …  
    236236    } 
    237237 
     238    /** 
     239     * <p> 
     240     * helper function that checks if the results are already in the data store 
     241     * </p> 
     242     * 
     243     * @param version 
     244     *            version for which the results are checked 
     245     * @return 
     246     */ 
    238247    private int resultsAvailable(SoftwareVersion version) { 
    239248        if (config.getResultStorages().isEmpty()) { 
    240249            return 0; 
    241250        } 
    242          
     251 
    243252        List<ITrainer> allTrainers = new LinkedList<>(); 
    244253        for (ISetWiseTrainingStrategy setwiseTrainer : config.getSetWiseTrainers()) { 
    … …  
    256265            allTrainers.add(trainer); 
    257266        } 
    258          
     267 
    259268        int available = Integer.MAX_VALUE; 
    260269        for (IResultStorage storage : config.getResultStorages()) { 
    261270            String classifierName = ((IWekaCompatibleTrainer) allTrainers.get(0)).getName(); 
    262             int curAvailable = storage.containsResult(config.getExperimentName(), version.getVersion(), classifierName); 
    263             if( curAvailable<available ) { 
     271            int curAvailable = storage.containsResult(config.getExperimentName(), 
     272                                                      version.getVersion(), classifierName); 
     273            if (curAvailable < available) { 
    264274                available = curAvailable; 
    265275            } 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/loader/AUDIChangeFolderLoader.java

    r86 r135  
    1515package de.ugoe.cs.cpdp.loader; 
    1616 
     17/** 
     18 * <p> 
     19 * Loads data from the automative defect data set from Audi Electronic Ventures donated by Altinger 
     20 * et al. at the MSR 2015. This loader contains the changes per commit, i.e., it is for JIT defect 
     21 * prediction. 
     22 * </p> 
     23 *  
     24 * @author Steffen Herbold 
     25 */ 
    1726public class AUDIChangeFolderLoader extends AbstractFolderLoader { 
    1827 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/loader/AUDIChangeLoader.java

    r86 r135  
    2828 
    2929/** 
    30  * TODO 
     30 * <p> 
     31 * Loads data from the automative defect data set from Audi Electronic Ventures donated by Altinger 
     32 * et al. at the MSR 2015. This loader contains the changes per commit, i.e., it is for JIT defect 
     33 * prediction. 
     34 * </p> 
    3135 *  
    32  * @author sherbold 
    33  *  
     36 * @author Steffen Herbold 
    3437 */ 
    3538class AUDIChangeLoader implements SingleVersionLoader { 
    3639 
     40    /** 
     41     * <p> 
     42     * Internal helper class. 
     43     * </p> 
     44     *  
     45     * @author Steffen Herbold 
     46     */ 
    3747    private class EntityRevisionPair implements Comparable<EntityRevisionPair> { 
     48 
     49        /** 
     50         * string that defines an entity 
     51         */ 
    3852        private final String entity; 
     53 
     54        /** 
     55         * revision number of the entity 
     56         */ 
    3957        private final int revision; 
    4058 
     59        /** 
     60         * <p> 
     61         * Constructor. Creates a new EntityRevisionPair. 
     62         * </p> 
     63         * 
     64         * @param entity 
     65         *            the entity 
     66         * @param revision 
     67         *            the revision 
     68         */ 
    4169        public EntityRevisionPair(String entity, int revision) { 
    4270            this.entity = entity; 
    … …  
    4472        } 
    4573 
     74        /* 
     75         * (non-Javadoc) 
     76         *  
     77         * @see java.lang.Object#equals(java.lang.Object) 
     78         */ 
    4679        @Override 
    4780        public boolean equals(Object other) { 
    … …  
    5487        } 
    5588 
     89        /* 
     90         * (non-Javadoc) 
     91         *  
     92         * @see java.lang.Object#hashCode() 
     93         */ 
    5694        @Override 
    5795        public int hashCode() { 
    … …  
    5997        } 
    6098 
     99        /* 
     100         * (non-Javadoc) 
     101         *  
     102         * @see java.lang.Comparable#compareTo(java.lang.Object) 
     103         */ 
    61104        @Override 
    62105        public int compareTo(EntityRevisionPair other) { 
    … …  
    68111        } 
    69112 
     113        /* 
     114         * (non-Javadoc) 
     115         *  
     116         * @see java.lang.Object#toString() 
     117         */ 
    70118        @Override 
    71119        public String toString() { 
    … …  
    74122    } 
    75123 
     124    /* 
     125     * (non-Javadoc) 
     126     *  
     127     * @see de.ugoe.cs.cpdp.loader.SingleVersionLoader#load(java.io.File) 
     128     */ 
    76129    @Override 
    77130    public Instances load(File file) { 
    … …  
    139192        for (int i = 1; i < linesBug.length; i++) { 
    140193            lineSplitBug = linesBug[i].split(";"); 
    141             entityRevisionPairs.put(new EntityRevisionPair(lineSplitBug[0], Integer 
    142                                         .parseInt(lineSplitBug[revisionIndex])), i); 
     194            entityRevisionPairs.put( 
     195                                    new EntityRevisionPair(lineSplitBug[0], 
     196                                                           Integer 
     197                                                               .parseInt(lineSplitBug[revisionIndex])), 
     198                                    i); 
    143199        } 
    144200 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/loader/AUDIDataLoader.java

    r86 r135  
    2525 
    2626/** 
    27  * TODO 
     27 * Loads data from the automative defect data set from Audi Electronic Ventures donated by Altinger 
     28 * et al. at the MSR 2015. This loader creates overall defect labels, for the final revision. 
    2829 *  
    29  * @author sherbold 
     30 * @author Steffen Herbold 
    3031 *  
    3132 */ 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/loader/AUDIFolderLoader.java

    r86 r135  
    1515package de.ugoe.cs.cpdp.loader; 
    1616 
     17/** 
     18 *  
     19 * <p> 
     20 * Loads data from the automative defect data set from Audi Electronic Ventures donated by Altinger 
     21 * et al. at the MSR 2015. This loader creates overall defect labels, for the final revision. 
     22 * </p> 
     23 *  
     24 * @author Steffen Herbold 
     25 */ 
    1726public class AUDIFolderLoader extends AbstractFolderLoader { 
    1827 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/loader/AbstractFolderLoader.java

    r132 r135  
    4646    } 
    4747 
    48     /** 
     48    /* 
    4949     * @see de.ugoe.cs.cpdp.loader.IVersionLoader#load() 
    5050     */ 
    … …  
    6868                            Instances data = instancesLoader.load(versionFile); 
    6969                            String versionName = data.relationName(); 
    70                             List<Double> efforts = getEfforts(data);  
    71                             versions.add(new SoftwareVersion(projectName, versionName, data, efforts)); 
     70                            List<Double> efforts = getEfforts(data); 
     71                            versions 
     72                                .add(new SoftwareVersion(projectName, versionName, data, efforts)); 
    7273                        } 
    7374                    } 
    … …  
    7778        return versions; 
    7879    } 
    79      
     80 
     81    /** 
     82     * <p> 
     83     * Sets the efforts for the instances 
     84     * </p> 
     85     * 
     86     * @param data 
     87     *            the data 
     88     * @return 
     89     */ 
    8090    private List<Double> getEfforts(Instances data) { 
    8191        // attribute in the JURECZKO data and default 
    … …  
    93103            effortAtt = data.attribute("CountLineCodeExe"); 
    94104        } 
    95         if( effortAtt == null ) { 
     105        if (effortAtt == null) { 
    96106            return null; 
    97107        } 
    98108        List<Double> efforts = new ArrayList<>(data.size()); 
    99         for( int i=0; i<data.size(); i++ ) { 
     109        for (int i = 0; i < data.size(); i++) { 
    100110            efforts.add(data.get(i).value(effortAtt)); 
    101111        } 
    … …  
    106116     * Returns the concrete {@link SingleVersionLoader} to be used with this folder loader. 
    107117     *  
    108      * @return 
     118     * @return the version loader 
    109119     */ 
    110120    abstract protected SingleVersionLoader getSingleLoader(); 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/loader/CSVMockusDataLoader.java

    r86 r135  
    2424import de.ugoe.cs.util.FileTools; 
    2525 
     26/** 
     27 * <p> 
     28 * Reads data from the data set provided by Mockus (and Zhang) for universal defect prediction. 
     29 * </p> 
     30 *  
     31 * @author Steffen Herbold 
     32 */ 
    2633class CSVMockusDataLoader implements SingleVersionLoader { 
    2734 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/loader/CSVMockusFolderLoader.java

    r86 r135  
    1515package de.ugoe.cs.cpdp.loader; 
    1616 
     17/** 
     18 * <p> 
     19 * Reads data from the data set provided by Mockus (and Zhang) for universal defect prediction. 
     20 * </p> 
     21 *  
     22 * @author Steffen Herbold 
     23 */ 
    1724public class CSVMockusFolderLoader extends AbstractFolderLoader { 
    1825 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/loader/DecentDataLoader.java

    r86 r135  
    237237        for (String key : EPackage.Registry.INSTANCE.keySet()) { 
    238238            metaModelCache.put(key, EPackage.Registry.INSTANCE.get(key)); 
    239         }; 
     239        } ; 
    240240 
    241241        for (String key : metaModelCache.keySet()) { 
    242242            EPackage.Registry.INSTANCE.remove(key); 
    243         }; 
     243        } ; 
    244244 
    245245        // Workaround to gernerate a usable URI. Absolute path is not 
    … …  
    445445        } 
    446446        else { 
    447             Console.printerrln("Could not determine model type, file should end with either .etl or .eol"); 
     447            Console 
     448                .printerrln("Could not determine model type, file should end with either .etl or .eol"); 
    448449            return null; 
    449450        } 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/loader/IDecentVersionLoader.java

    r86 r135  
    1919import de.ugoe.cs.cpdp.versions.SoftwareVersion; 
    2020 
     21/** 
     22 * <p> 
     23 * Extends the version load for the loading of DECENT models 
     24 * </p> 
     25 *  
     26 * @author Fabian Trautsch 
     27 */ 
    2128public interface IDecentVersionLoader extends IVersionLoader { 
    2229 
     30    /** 
     31     * <p> 
     32     * loads the versions and defines the DECENT attributes to be used 
     33     * </p> 
     34     * 
     35     * @param decentAttributes the attributes 
     36     * @return the versions 
     37     */ 
    2338    public List<SoftwareVersion> load(List<String> decentAttributes); 
    2439 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/loader/RelinkLoader.java

    r119 r135  
     1 
    12package de.ugoe.cs.cpdp.loader; 
    23 
    … …  
    1011import weka.core.Instances; 
    1112 
     13/** 
     14 * <p> 
     15 * Loads data from the RELINK data set. 
     16 * </p> 
     17 *  
     18 * @author Steffen Herbold 
     19 */ 
    1220public class RelinkLoader implements SingleVersionLoader { 
    1321 
    … …  
    6775        attrNames.add("SumEssential"); 
    6876        attrNames.add("isDefective"); 
    69          
    70         for( int j=tmpData.numAttributes()-1; j>=0 ; j-- ) { 
    71             if( !attrNames.contains(tmpData.attribute(j).name()) ) { 
     77 
     78        for (int j = tmpData.numAttributes() - 1; j >= 0; j--) { 
     79            if (!attrNames.contains(tmpData.attribute(j).name())) { 
    7280                tmpData.deleteAttributeAt(j); 
    7381            } 
    7482        } 
    75          
     83 
    7684        // setting class attribute 
    7785        tmpData.setClassIndex(tmpData.numAttributes() - 1); 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/training/FixClass.java

    r86 r135  
    2929public class FixClass extends AbstractClassifier { 
    3030 
     31    /** 
     32     * default serial ID 
     33     */ 
    3134    private static final long serialVersionUID = 1L; 
    3235 
     36    /** 
     37     * default prediction: non-defective 
     38     */ 
    3339    private double fixedClassValue = 0.0d; 
    3440 
    … …  
    6268    } 
    6369 
     70    /* 
     71     * (non-Javadoc) 
     72     *  
     73     * @see weka.classifiers.AbstractClassifier#setOptions(java.lang.String[]) 
     74     */ 
    6475    @Override 
    6576    public void setOptions(String[] options) throws Exception { 
    … …  
    6778    } 
    6879 
     80    /* 
     81     * (non-Javadoc) 
     82     *  
     83     * @see weka.classifiers.AbstractClassifier#classifyInstance(weka.core.Instance) 
     84     */ 
    6985    @Override 
    7086    public double classifyInstance(Instance instance) { 
    … …  
    7288    } 
    7389 
     90    /* 
     91     * (non-Javadoc) 
     92     *  
     93     * @see weka.classifiers.Classifier#buildClassifier(weka.core.Instances) 
     94     */ 
    7495    @Override 
    7596    public void buildClassifier(Instances traindata) throws Exception { 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/training/GPTraining.java

    r125 r135  
     1 
    12package de.ugoe.cs.cpdp.training; 
    23 
    … …  
    4546 * Genetic Programming Trainer 
    4647 *  
    47  * Implementation (mostly) according to Liu et al. Evolutionary Optimization of Software Quality Modeling with Multiple Repositories. 
     48 * Implementation (mostly) according to Liu et al. Evolutionary Optimization of Software Quality 
     49 * Modeling with Multiple Repositories. 
    4850 *  
    49  * - GPRun is a Run of a complete Genetic Programm Evolution, we want several complete runs. 
    50  * - GPVClassifier is the Validation Classifier 
    51  * - GPVVClassifier is the Validation-Voting Classifier 
     51 * - GPRun is a Run of a complete Genetic Programm Evolution, we want several complete runs. - 
     52 * GPVClassifier is the Validation Classifier - GPVVClassifier is the Validation-Voting Classifier 
    5253 *  
    53  *  config: <setwisetrainer name="GPTraining" param="populationSize:1000,numberRuns:10" /> 
     54 * config: <setwisetrainer name="GPTraining" param="populationSize:1000,numberRuns:10" /> 
     55 *  
     56 * @author Alexander Trautsch 
    5457 */ 
    55 public class GPTraining implements ISetWiseTrainingStrategy, IWekaCompatibleTrainer  { 
    56      
     58public class GPTraining implements ISetWiseTrainingStrategy, IWekaCompatibleTrainer { 
     59 
     60    /** 
     61     * the interal validation-and-voting classifier 
     62     */ 
    5763    private GPVVClassifier classifier = null; 
    58      
    59     // default values from the paper 
     64 
     65    /** 
     66     * size of the population of the genetic program; default from the paper is 1000 
     67     */ 
    6068    private int populationSize = 1000; 
     69 
     70    /** 
     71     * minimal depth of the S-expression tree at the start of the training; default from the paper 
     72     * is 2 
     73     */ 
    6174    private int initMinDepth = 2; 
     75 
     76    /** 
     77     * maximal depth of the S-expression tree at the start of the training; default from the paper 
     78     * is 6 
     79     */ 
    6280    private int initMaxDepth = 6; 
     81 
     82    /** 
     83     * size of the tournaments used for selection; default from the paper is 7 
     84     */ 
    6385    private int tournamentSize = 7; 
     86 
     87    /** 
     88     * number of genetic generations considered (i.e., number of iterations; default from the paper 
     89     * is 50 
     90     */ 
    6491    private int maxGenerations = 50; 
     92 
     93    /** 
     94     * weight factor for the prediction errors for cost estimation; default from the paper is 15 
     95     */ 
    6596    private double errorType2Weight = 15; 
    66     private int numberRuns = 20;  // im paper 20 per errorType2Weight then additional 20 
    67     private int maxDepth = 20;  // max depth within one program 
    68     private int maxNodes = 100;  // max nodes within one program 
    69  
     97 
     98    /** 
     99     * number of internal replications from which the best result is picked; default from the paper 
     100     * is 20 
     101     */ 
     102    private int numberRuns = 20; 
     103 
     104    /** 
     105     * maximal depth of the S-expression tree; default from the paper is 20 
     106     */ 
     107    private int maxDepth = 20; 
     108 
     109    /** 
     110     * maximal number of nodes of the S-expression tree; default from the paper is 100 
     111     */ 
     112    private int maxNodes = 100; 
     113 
     114    /* 
     115     * (non-Javadoc) 
     116     *  
     117     * @see de.ugoe.cs.cpdp.IParameterizable#setParameter(java.lang.String) 
     118     */ 
    70119    @Override 
    71120    public void setParameter(String parameters) { 
    72          
     121 
    73122        String[] params = parameters.split(","); 
    74123        String[] keyvalue = new String[2]; 
    75124 
    76         for(int i=0; i < params.length; i++) { 
     125        for (int i = 0; i < params.length; i++) { 
    77126            keyvalue = params[i].split(":"); 
    78              
    79             switch(keyvalue[0]) { 
     127 
     128            switch (keyvalue[0]) 
     129            { 
    80130                case "populationSize": 
    81131                    this.populationSize = Integer.parseInt(keyvalue[1]); 
    82                 break; 
    83                  
     132                    break; 
     133 
    84134                case "initMinDepth": 
    85135                    this.initMinDepth = Integer.parseInt(keyvalue[1]); 
    86                 break; 
    87                  
     136                    break; 
     137 
    88138                case "tournamentSize": 
    89139                    this.tournamentSize = Integer.parseInt(keyvalue[1]); 
    90                 break; 
    91                  
     140                    break; 
     141 
    92142                case "maxGenerations": 
    93143                    this.maxGenerations = Integer.parseInt(keyvalue[1]); 
    94                 break; 
    95                  
     144                    break; 
     145 
    96146                case "errorType2Weight": 
    97147                    this.errorType2Weight = Double.parseDouble(keyvalue[1]); 
    98                 break; 
    99                  
     148                    break; 
     149 
    100150                case "numberRuns": 
    101151                    this.numberRuns = Integer.parseInt(keyvalue[1]); 
    102                 break; 
    103                  
     152                    break; 
     153 
    104154                case "maxDepth": 
    105155                    this.maxDepth = Integer.parseInt(keyvalue[1]); 
    106                 break; 
    107                  
     156                    break; 
     157 
    108158                case "maxNodes": 
    109159                    this.maxNodes = Integer.parseInt(keyvalue[1]); 
    110                 break; 
    111             } 
    112         } 
    113          
     160                    break; 
     161            } 
     162        } 
     163 
    114164        this.classifier = new GPVVClassifier(); 
    115         ((GPVClassifier)this.classifier).configure(populationSize, initMinDepth, initMaxDepth, tournamentSize, maxGenerations, errorType2Weight, numberRuns, maxDepth, maxNodes); 
     165        ((GPVClassifier) this.classifier) 
     166            .configure(populationSize, initMinDepth, initMaxDepth, tournamentSize, maxGenerations, 
     167                       errorType2Weight, numberRuns, maxDepth, maxNodes); 
    116168    } 
    117169 
     170    /* 
     171     * (non-Javadoc) 
     172     *  
     173     * @see 
     174     * de.ugoe.cs.cpdp.training.ISetWiseTrainingStrategy#apply(org.apache.commons.collections4.list. 
     175     * SetUniqueList) 
     176     */ 
    118177    @Override 
    119178    public void apply(SetUniqueList<Instances> traindataSet) { 
    120179        try { 
    121180            classifier.buildClassifier(traindataSet); 
    122         }catch(Exception e) { 
     181        } 
     182        catch (Exception e) { 
    123183            throw new RuntimeException(e); 
    124184        } 
    125185    } 
    126186 
     187    /* 
     188     * (non-Javadoc) 
     189     *  
     190     * @see de.ugoe.cs.cpdp.training.ISetWiseTrainingStrategy#getName() 
     191     */ 
    127192    @Override 
    128193    public String getName() { 
    … …  
    130195    } 
    131196 
     197    /* 
     198     * (non-Javadoc) 
     199     *  
     200     * @see de.ugoe.cs.cpdp.training.IWekaCompatibleTrainer#getClassifier() 
     201     */ 
    132202    @Override 
    133203    public Classifier getClassifier() { 
    134204        return this.classifier; 
    135205    } 
    136      
     206 
     207    /** 
     208     * <p> 
     209     * Internal helper class that stores the data in a format that can be used by the genetic 
     210     * program. 
     211     * </p> 
     212     *  
     213     * @author Alexander Trautsch 
     214     */ 
    137215    public class InstanceData { 
     216 
     217        /** 
     218         * instances values 
     219         */ 
    138220        private double[][] instances_x; 
     221 
     222        /** 
     223         * class labels 
     224         */ 
    139225        private boolean[] instances_y; 
    140          
     226 
     227        /** 
     228         * <p> 
     229         * Constructor. Creates the internal data representation. 
     230         * </p> 
     231         * 
     232         * @param instances 
     233         */ 
    141234        public InstanceData(Instances instances) { 
    142             this.instances_x = new double[instances.numInstances()][instances.numAttributes()-1]; 
     235            this.instances_x = new double[instances.numInstances()][instances.numAttributes() - 1]; 
    143236            this.instances_y = new boolean[instances.numInstances()]; 
    144              
     237 
    145238            Instance current; 
    146             for(int i=0; i < this.instances_x.length; i++) { 
     239            for (int i = 0; i < this.instances_x.length; i++) { 
    147240                current = instances.get(i); 
    148241                this.instances_x[i] = WekaUtils.instanceValues(current); 
    … …  
    150243            } 
    151244        } 
    152          
     245 
     246        /** 
     247         * <p> 
     248         * returns the instance values 
     249         * </p> 
     250         * 
     251         * @return 
     252         */ 
    153253        public double[][] getX() { 
    154254            return instances_x; 
    155255        } 
     256 
     257        /** 
     258         * <p> 
     259         * returns the instance labels 
     260         * </p> 
     261         * 
     262         * @return 
     263         */ 
    156264        public boolean[] getY() { 
    157265            return instances_y; 
    158266        } 
    159267    } 
    160      
     268 
    161269    /** 
    162270     * One Run executed by a GP Classifier 
    163271     */ 
    164272    public class GPRun extends AbstractClassifier { 
     273 
     274        /** 
     275         * generated serialization ID 
     276         */ 
    165277        private static final long serialVersionUID = -4250422550107888789L; 
    166278 
     279        /** 
     280         * size of the population of the genetic program 
     281         */ 
    167282        private int populationSize; 
     283 
     284        /** 
     285         * minimal depth of the S-expression tree at the start of the training 
     286         */ 
    168287        private int initMinDepth; 
     288 
     289        /** 
     290         * maximal depth of the S-expression tree at the start of the training 
     291         */ 
    169292        private int initMaxDepth; 
     293 
     294        /** 
     295         * size of the tournaments used for selection 
     296         */ 
    170297        private int tournamentSize; 
     298 
     299        /** 
     300         * number of genetic generations considered (i.e., number of iterations 
     301         */ 
    171302        private int maxGenerations; 
     303 
     304        /** 
     305         * weight factor for the prediction errors for cost estimation 
     306         */ 
    172307        private double errorType2Weight; 
     308 
     309        /** 
     310         * maximal depth of the S-expression tree 
     311         */ 
    173312        private int maxDepth; 
     313 
     314        /** 
     315         * maximal number of nodes of the S-expression tree 
     316         */ 
    174317        private int maxNodes; 
    175          
     318 
     319        /** 
     320         * genetic program 
     321         */ 
    176322        private GPGenotype gp; 
     323 
     324        /** 
     325         * description of the problem to be solved by the genetic program 
     326         */ 
    177327        private GPProblem problem; 
    178          
    179         public void configure(int populationSize, int initMinDepth, int initMaxDepth, int tournamentSize, int maxGenerations, double errorType2Weight, int maxDepth, int maxNodes) { 
     328 
     329        /** 
     330         * <p> 
     331         * Configures the runner 
     332         * </p> 
     333         * 
     334         * @param populationSize 
     335         *            the population size 
     336         * @param initMinDepth 
     337         *            the initial minimal depth of the S-expression tree 
     338         * @param initMaxDepth 
     339         *            the initial maximal depth of the S-expression tree 
     340         * @param tournamentSize 
     341         *            the tournament size for selection 
     342         * @param maxGenerations 
     343         *            the number of generations created 
     344         * @param errorType2Weight 
     345         *            weigth factor for the prediction errors 
     346         * @param maxDepth 
     347         *            maximal depth of the S-expression tree 
     348         * @param maxNodes 
     349         *            maximal number of nodes of the S-expression tree 
     350         */ 
     351        public void configure(int populationSize, 
     352                              int initMinDepth, 
     353                              int initMaxDepth, 
     354                              int tournamentSize, 
     355                              int maxGenerations, 
     356                              double errorType2Weight, 
     357                              int maxDepth, 
     358                              int maxNodes) 
     359        { 
    180360            this.populationSize = populationSize; 
    181361            this.initMinDepth = initMinDepth; 
    … …  
    187367            this.maxNodes = maxNodes; 
    188368        } 
    189          
     369 
     370        /** 
     371         * <p> 
     372         * returns the genetic program 
     373         * </p> 
     374         * 
     375         * @return the genetic program 
     376         */ 
    190377        public GPGenotype getGp() { 
    191378            return this.gp; 
    192379        } 
    193          
     380 
     381        /** 
     382         * <p> 
     383         * returns the variables of the genetic program 
     384         * </p> 
     385         * 
     386         * @return the variables 
     387         */ 
    194388        public Variable[] getVariables() { 
    195             return ((CrossPareGP)this.problem).getVariables(); 
    196         } 
    197  
     389            return ((CrossPareGP) this.problem).getVariables(); 
     390        } 
     391 
     392        /* 
     393         * (non-Javadoc) 
     394         *  
     395         * @see weka.classifiers.Classifier#buildClassifier(weka.core.Instances) 
     396         */ 
    198397        @Override 
    199398        public void buildClassifier(Instances traindata) throws Exception { 
    200             InstanceData train = new InstanceData(traindata);             
    201             this.problem = new CrossPareGP(train.getX(), train.getY(), this.populationSize, this.initMinDepth, this.initMaxDepth, this.tournamentSize, this.errorType2Weight, this.maxDepth, this.maxNodes); 
     399            InstanceData train = new InstanceData(traindata); 
     400            this.problem = 
     401                new CrossPareGP(train.getX(), train.getY(), this.populationSize, this.initMinDepth, 
     402                                this.initMaxDepth, this.tournamentSize, this.errorType2Weight, 
     403                                this.maxDepth, this.maxNodes); 
    202404            this.gp = problem.create(); 
    203405            this.gp.evolve(this.maxGenerations); 
    204406        } 
    205          
     407 
    206408        /** 
    207409         * GPProblem implementation 
     410         *  
     411         * @author Alexander Trautsch 
    208412         */ 
    209413        class CrossPareGP extends GPProblem { 
     414 
     415            /** 
     416             * Instance values of the training data 
     417             */ 
    210418            private double[][] instances; 
     419 
     420            /** 
     421             * Classifications of the training data 
     422             */ 
    211423            private boolean[] output; 
    212424 
     425            /** 
     426             * maximal depth of the S-expression tree 
     427             */ 
    213428            private int maxDepth; 
     429 
     430            /** 
     431             * maximal number of nodes of the S-expression tree 
     432             */ 
    214433            private int maxNodes; 
    215              
     434 
     435            /** 
     436             * variables of the genetic program 
     437             */ 
    216438            private Variable[] x; 
    217439 
    218             public CrossPareGP(double[][] instances, boolean[] output, int populationSize, int minInitDept, int maxInitDepth, int tournamentSize, double errorType2Weight, int maxDepth, int maxNodes) throws InvalidConfigurationException { 
     440            /** 
     441             *  
     442             * <p> 
     443             * Constructor. Creates a new genetic program. 
     444             * </p> 
     445             * 
     446             * @param instances 
     447             *            instance values of the training data 
     448             * @param output 
     449             *            classifications of the training data 
     450             * @param populationSize 
     451             *            the population size 
     452             * @param initMinDepth 
     453             *            the initial minimal depth of the S-expression tree 
     454             * @param initMaxDepth 
     455             *            the initial maximal depth of the S-expression tree 
     456             * @param tournamentSize 
     457             *            the tournament size for selection 
     458             * @param maxGenerations 
     459             *            the number of generations created 
     460             * @param errorType2Weight 
     461             *            weigth factor for the prediction errors 
     462             * @param maxDepth 
     463             *            maximal depth of the S-expression tree 
     464             * @param maxNodes 
     465             *            maximal number of nodes of the S-expression tree 
     466             * @throws InvalidConfigurationException 
     467             *             thrown in case the problem cannot be created 
     468             */ 
     469            public CrossPareGP(double[][] instances, 
     470                               boolean[] output, 
     471                               int populationSize, 
     472                               int minInitDept, 
     473                               int maxInitDepth, 
     474                               int tournamentSize, 
     475                               double errorType2Weight, 
     476                               int maxDepth, 
     477                               int maxNodes) 
     478                throws InvalidConfigurationException 
     479            { 
    219480                super(new GPConfiguration()); 
    220                  
     481 
    221482                this.instances = instances; 
    222483                this.output = output; 
    … …  
    226487                Configuration.reset(); 
    227488                GPConfiguration config = this.getGPConfiguration(); 
    228                  
     489 
    229490                this.x = new Variable[this.instances[0].length]; 
    230                 
    231                 for(int j=0; j < this.x.length; j++) { 
    232                     this.x[j] = Variable.create(config, "X"+j, CommandGene.DoubleClass);     
    233                 } 
    234  
    235                 config.setGPFitnessEvaluator(new DeltaGPFitnessEvaluator()); // smaller fitness is better 
    236                 //config.setGPFitnessEvaluator(new DefaultGPFitnessEvaluator()); // bigger fitness is better 
     491 
     492                for (int j = 0; j < this.x.length; j++) { 
     493                    this.x[j] = Variable.create(config, "X" + j, CommandGene.DoubleClass); 
     494                } 
     495 
     496                config.setGPFitnessEvaluator(new DeltaGPFitnessEvaluator()); // smaller fitness is 
     497                                                                             // better 
     498                // config.setGPFitnessEvaluator(new DefaultGPFitnessEvaluator()); // bigger fitness 
     499                // is better 
    237500 
    238501                config.setMinInitDepth(minInitDept); 
    239502                config.setMaxInitDepth(maxInitDepth); 
    240                  
    241                 config.setCrossoverProb((float)0.60); 
    242                 config.setReproductionProb((float)0.10); 
    243                 config.setMutationProb((float)0.30); 
     503 
     504                config.setCrossoverProb((float) 0.60); 
     505                config.setReproductionProb((float) 0.10); 
     506                config.setMutationProb((float) 0.30); 
    244507 
    245508                config.setSelectionMethod(new TournamentSelector(tournamentSize)); 
    … …  
    248511 
    249512                config.setMaxCrossoverDepth(4); 
    250                 config.setFitnessFunction(new CrossPareFitness(this.x, this.instances, this.output, errorType2Weight)); 
     513                config.setFitnessFunction(new CrossPareFitness(this.x, this.instances, this.output, 
     514                                                               errorType2Weight)); 
    251515                config.setStrictProgramCreation(true); 
    252516            } 
    253517 
    254             // used for running the fitness function again for testing 
     518            /** 
     519             * <p> 
     520             * Returns the variables of the problem. Used for running the fitness function again for 
     521             * testing. 
     522             * </p> 
     523             * 
     524             * @return the variables 
     525             */ 
    255526            public Variable[] getVariables() { 
    256527                return this.x; 
    257528            } 
    258529 
    259  
     530            /** 
     531             * creates the genetic program 
     532             */ 
     533            @SuppressWarnings("rawtypes") 
    260534            public GPGenotype create() throws InvalidConfigurationException { 
    261535                GPConfiguration config = this.getGPConfiguration(); 
    262536 
    263537                // return type 
    264                 Class[] types = {CommandGene.DoubleClass}; 
     538                Class[] types = 
     539                    { CommandGene.DoubleClass }; 
    265540 
    266541                // Arguments of result-producing chromosome: none 
    267                 Class[][] argTypes = { {} }; 
     542                Class[][] argTypes = 
     543                    { { } }; 
    268544 
    269545                // variables + functions, we set the variables with the values of the instances here 
    270546                CommandGene[] vars = new CommandGene[this.instances[0].length]; 
    271                 for(int j=0; j < this.instances[0].length; j++) { 
     547                for (int j = 0; j < this.instances[0].length; j++) { 
    272548                    vars[j] = this.x[j]; 
    273549                } 
    274                 CommandGene[] funcs = { 
    275                     new Add(config, CommandGene.DoubleClass), 
    276                     new Subtract(config, CommandGene.DoubleClass), 
    277                     new Multiply(config, CommandGene.DoubleClass), 
    278                     new Divide(config, CommandGene.DoubleClass), 
    279                     new Sine(config, CommandGene.DoubleClass), 
    280                     new Cosine(config, CommandGene.DoubleClass), 
    281                     new Exp(config, CommandGene.DoubleClass), 
    282                     new Log(config, CommandGene.DoubleClass), 
    283                     new GT(config, CommandGene.DoubleClass), 
    284                     new Max(config, CommandGene.DoubleClass), 
    285                     new Terminal(config, CommandGene.DoubleClass, -100.0, 100.0, true), // min, max, whole numbers 
    286                 }; 
    287  
    288                 CommandGene[] comb = (CommandGene[])ArrayUtils.addAll(vars, funcs); 
    289                 CommandGene[][] nodeSets = { 
    290                     comb, 
    291                 }; 
    292                  
     550                CommandGene[] funcs = 
     551                    { new Add(config, CommandGene.DoubleClass), 
     552                        new Subtract(config, CommandGene.DoubleClass), 
     553                        new Multiply(config, CommandGene.DoubleClass), 
     554                        new Divide(config, CommandGene.DoubleClass), 
     555                        new Sine(config, CommandGene.DoubleClass), 
     556                        new Cosine(config, CommandGene.DoubleClass), 
     557                        new Exp(config, CommandGene.DoubleClass), 
     558                        new Log(config, CommandGene.DoubleClass), 
     559                        new GT(config, CommandGene.DoubleClass), 
     560                        new Max(config, CommandGene.DoubleClass), 
     561                        new Terminal(config, CommandGene.DoubleClass, -100.0, 100.0, true), // min, 
     562                                                                                            // max, 
     563                                                                                            // whole 
     564                                                                                            // numbers 
     565                    }; 
     566 
     567                CommandGene[] comb = (CommandGene[]) ArrayUtils.addAll(vars, funcs); 
     568                CommandGene[][] nodeSets = 
     569                    { comb, }; 
     570 
    293571                // we only have one chromosome so this suffices 
    294                 int minDepths[] = {config.getMinInitDepth()}; 
    295                 int maxDepths[] = {this.maxDepth}; 
    296                 GPGenotype result = GPGenotype.randomInitialGenotype(config, types, argTypes, nodeSets, minDepths, maxDepths, this.maxNodes, false); // 40 = maxNodes, true = verbose output 
     572                int minDepths[] = 
     573                    { config.getMinInitDepth() }; 
     574                int maxDepths[] = 
     575                    { this.maxDepth }; 
     576                GPGenotype result = 
     577                    GPGenotype.randomInitialGenotype(config, types, argTypes, nodeSets, minDepths, 
     578                                                     maxDepths, this.maxNodes, false); // 40 = 
     579                                                                                       // maxNodes, 
     580                                                                                       // true = 
     581                                                                                       // verbose 
     582                                                                                       // output 
    297583 
    298584                return result; 
    … …  
    300586        } 
    301587 
    302          
    303         /** 
    304          * Fitness function 
     588        /** 
     589         * Internal helper class for the fitness function. 
     590         *  
     591         * @author Alexander Trautsch 
    305592         */ 
    306593        class CrossPareFitness extends GPFitnessFunction { 
    307              
     594 
     595            /** 
     596             * generated serialization ID 
     597             */ 
    308598            private static final long serialVersionUID = 75234832484387L; 
    309599 
     600            /** 
     601             * variables of the genetic program 
     602             */ 
    310603            private Variable[] x; 
    311604 
     605            /** 
     606             * instance values of the training data 
     607             */ 
    312608            private double[][] instances; 
     609 
     610            /** 
     611             * classifications of the training data 
     612             */ 
    313613            private boolean[] output; 
    314614 
     615            /** 
     616             * weight of the error costs 
     617             */ 
    315618            private double errorType2Weight = 1.0; 
    316619 
    317620            // needed in evaluate 
    318             //private Object[] NO_ARGS = new Object[0]; 
    319  
     621            // private Object[] NO_ARGS = new Object[0]; 
     622 
     623            /** 
     624             * fitness value 
     625             */ 
    320626            private double sfitness = 0.0f; 
     627 
     628            /** 
     629             * type I error 
     630             */ 
    321631            private int errorType1 = 0; 
     632 
     633            /** 
     634             * type II error 
     635             */ 
    322636            private int errorType2 = 0; 
    323637 
    324             public CrossPareFitness(Variable[] x, double[][] instances, boolean[] output, double errorType2Weight) { 
     638            /** 
     639             * <p> 
     640             * Constructor. Creates a new fitness function. 
     641             * </p> 
     642             * 
     643             * @param x 
     644             *            variables of the genetic program 
     645             * @param instances 
     646             *            instance values of the training data 
     647             * @param output 
     648             *            classification of the training data 
     649             * @param errorType2Weight 
     650             *            weight of the error costs 
     651             */ 
     652            public CrossPareFitness(Variable[] x, 
     653                                    double[][] instances, 
     654                                    boolean[] output, 
     655                                    double errorType2Weight) 
     656            { 
    325657                this.x = x; 
    326658                this.instances = instances; 
    … …  
    329661            } 
    330662 
     663            /** 
     664             * <p> 
     665             * returns the type I error 
     666             * </p> 
     667             * 
     668             * @return type I error 
     669             */ 
    331670            public int getErrorType1() { 
    332671                return this.errorType1; 
    333672            } 
    334673 
     674            /** 
     675             * <p> 
     676             * returns the type II error 
     677             * </p> 
     678             * 
     679             * @return type II error 
     680             */ 
    335681            public int getErrorType2() { 
    336682                return this.errorType2; 
    337683            } 
    338684 
     685            /** 
     686             * <p> 
     687             * returns the value of the secondary fitness function 
     688             * </p> 
     689             * 
     690             * @return secondary fitness 
     691             */ 
    339692            public double getSecondFitness() { 
    340693                return this.sfitness; 
    341694            } 
    342695 
     696            /** 
     697             * <p> 
     698             * returns the number of training instances 
     699             * </p> 
     700             * 
     701             * @return number of instances 
     702             */ 
    343703            public int getNumInstances() { 
    344704                return this.instances.length; 
    … …  
    346706 
    347707            /** 
    348              * This is the fitness function 
     708             * <p> 
     709             * The fitness function. Our fitness is best if we have the less wrong classifications, 
     710             * this includes a weight for type2 errors. 
     711             * </p> 
    349712             *  
    350              * Our fitness is best if we have the less wrong classifications, this includes a weight for type2 errors 
     713             * @param program 
     714             *            the genetic program whose fitness is evaluated. 
     715             *  
     716             * @see org.jgap.gp.GPFitnessFunction#evaluate(org.jgap.gp.IGPProgram) 
    351717             */ 
    352718            @Override 
    … …  
    360726                this.errorType2 = 0; 
    361727 
    362                 for(int i=0; i < this.instances.length; i++) { 
    363  
    364                     // requires that we have a variable for each column of our dataset (attribute of instance) 
    365                     for(int j=0; j < this.x.length; j++) { 
     728                for (int i = 0; i < this.instances.length; i++) { 
     729 
     730                    // requires that we have a variable for each column of our dataset (attribute of 
     731                    // instance) 
     732                    for (int j = 0; j < this.x.length; j++) { 
    366733                        this.x[j].set(this.instances[i][j]); 
    367734                    } 
    … …  
    370737                    value = program.execute_double(0, this.x); 
    371738 
    372                     if(value < 0.5) { 
    373                         if(this.output[i] != true) { 
     739                    if (value < 0.5) { 
     740                        if (this.output[i] != true) { 
    374741                            this.errorType1 += 1; 
    375742                        } 
    376                     }else { 
    377                         if(this.output[i] == true) { 
     743                    } 
     744                    else { 
     745                        if (this.output[i] == true) { 
    378746                            this.errorType2 += 1; 
    379747                        } 
    … …  
    382750 
    383751                // now calc pfitness 
    384                 pfitness = (this.errorType1 + this.errorType2Weight * this.errorType2) / this.instances.length; 
     752                pfitness = (this.errorType1 + this.errorType2Weight * this.errorType2) / 
     753                    this.instances.length; 
    385754 
    386755                // number of nodes in the programm, if lower then 10 we assign sFitness of 10 
    387756                // we can set metadata with setProgramData to save this 
    388                 if(program.getChromosome(0).getSize(0) < 10) { 
     757                if (program.getChromosome(0).getSize(0) < 10) { 
    389758                    program.setApplicationData(10.0f); 
    390759                } 
    … …  
    393762            } 
    394763        } 
    395          
     764 
    396765        /** 
    397766         * Custom GT implementation used in the GP Algorithm. 
    398          */ 
    399          public class GT extends MathCommand implements ICloneable { 
    400               
    401              private static final long serialVersionUID = 113454184817L; 
    402  
    403              public GT(final GPConfiguration a_conf, java.lang.Class a_returnType) throws InvalidConfigurationException { 
    404                  super(a_conf, 2, a_returnType); 
    405              } 
    406  
    407              public String toString() { 
    408                  return "GT(&1, &2)"; 
    409              } 
    410  
    411              public String getName() { 
    412                  return "GT"; 
    413              }    
    414  
    415              public float execute_float(ProgramChromosome c, int n, Object[] args) { 
    416                  float f1 = c.execute_float(n, 0, args); 
    417                  float f2 = c.execute_float(n, 1, args); 
    418  
    419                  float ret = 1.0f; 
    420                  if(f1 > f2) { 
    421                      ret = 0.0f; 
    422                  } 
    423  
    424                  return ret; 
    425              } 
    426  
    427              public double execute_double(ProgramChromosome c, int n, Object[] args) { 
    428                  double f1 = c.execute_double(n, 0, args); 
    429                  double f2 = c.execute_double(n, 1, args); 
    430  
    431                  double ret = 1; 
    432                  if(f1 > f2)  { 
    433                      ret = 0; 
    434                  } 
    435                  return ret; 
    436              } 
    437  
    438              public Object clone() { 
    439                  try { 
    440                      GT result = new GT(getGPConfiguration(), getReturnType()); 
    441                      return result; 
    442                  }catch(Exception ex) { 
    443                      throw new CloneException(ex); 
    444                  } 
    445              } 
    446          } 
     767         *  
     768         * @author Alexander Trautsch 
     769         */ 
     770        public class GT extends MathCommand implements ICloneable { 
     771 
     772            /** 
     773             * generated serialization ID. 
     774             */ 
     775            private static final long serialVersionUID = 113454184817L; 
     776 
     777            /** 
     778             * <p> 
     779             * Constructor. Creates a new GT. 
     780             * </p> 
     781             * 
     782             * @param a_conf 
     783             *            the configuration of the genetic program 
     784             * @param a_returnType 
     785             *            the return type 
     786             * @throws InvalidConfigurationException 
     787             *             thrown is there is a problem during the initialization of the super class 
     788             *  
     789             * @see MathCommand 
     790             */ 
     791            public GT(final GPConfiguration a_conf, @SuppressWarnings("rawtypes") java.lang.Class a_returnType) 
     792                throws InvalidConfigurationException 
     793            { 
     794                super(a_conf, 2, a_returnType); 
     795            } 
     796 
     797            /* 
     798             * (non-Javadoc) 
     799             *  
     800             * @see org.jgap.gp.CommandGene#toString() 
     801             */ 
     802            @Override 
     803            public String toString() { 
     804                return "GT(&1, &2)"; 
     805            } 
     806 
     807            /* 
     808             * (non-Javadoc) 
     809             *  
     810             * @see org.jgap.gp.CommandGene#getName() 
     811             */ 
     812            @Override 
     813            public String getName() { 
     814                return "GT"; 
     815            } 
     816 
     817            /* 
     818             * (non-Javadoc) 
     819             *  
     820             * @see org.jgap.gp.CommandGene#execute_float(org.jgap.gp.impl.ProgramChromosome, int, 
     821             * java.lang.Object[]) 
     822             */ 
     823            @Override 
     824            public float execute_float(ProgramChromosome c, int n, Object[] args) { 
     825                float f1 = c.execute_float(n, 0, args); 
     826                float f2 = c.execute_float(n, 1, args); 
     827 
     828                float ret = 1.0f; 
     829                if (f1 > f2) { 
     830                    ret = 0.0f; 
     831                } 
     832 
     833                return ret; 
     834            } 
     835 
     836            /* 
     837             * (non-Javadoc) 
     838             *  
     839             * @see org.jgap.gp.CommandGene#execute_double(org.jgap.gp.impl.ProgramChromosome, int, 
     840             * java.lang.Object[]) 
     841             */ 
     842            @Override 
     843            public double execute_double(ProgramChromosome c, int n, Object[] args) { 
     844                double f1 = c.execute_double(n, 0, args); 
     845                double f2 = c.execute_double(n, 1, args); 
     846 
     847                double ret = 1; 
     848                if (f1 > f2) { 
     849                    ret = 0; 
     850                } 
     851                return ret; 
     852            } 
     853 
     854            /* 
     855             * (non-Javadoc) 
     856             *  
     857             * @see java.lang.Object#clone() 
     858             */ 
     859            @Override 
     860            public Object clone() { 
     861                try { 
     862                    GT result = new GT(getGPConfiguration(), getReturnType()); 
     863                    return result; 
     864                } 
     865                catch (Exception ex) { 
     866                    throw new CloneException(ex); 
     867                } 
     868            } 
     869        } 
    447870    } 
    448      
     871 
    449872    /** 
    450873     * GP Multiple Data Sets Validation-Voting Classifier 
    451874     *  
    452      * Basically the same as the GP Multiple Data Sets Validation Classifier. 
    453      * But here we do keep a model candidate for each training set which may later vote 
     875     * Basically the same as the GP Multiple Data Sets Validation Classifier. But here we do keep a 
     876     * model candidate for each training set which may later vote 
    454877     * 
    455878     */ 
    456879    public class GPVVClassifier extends GPVClassifier { 
    457880 
     881        /** 
     882         * generated serialization ID 
     883         */ 
    458884        private static final long serialVersionUID = -654710583852839901L; 
     885 
     886        /** 
     887         * classifiers for each validation set 
     888         */ 
    459889        private List<Classifier> classifiers = null; 
    460          
     890 
     891        /* 
     892         * (non-Javadoc) 
     893         *  
     894         * @see 
     895         * de.ugoe.cs.cpdp.training.GPTraining.GPVClassifier#buildClassifier(weka.core.Instances) 
     896         */ 
    461897        @Override 
    462898        public void buildClassifier(Instances arg0) throws Exception { 
    463899            // TODO Auto-generated method stub 
    464              
    465         } 
    466          
    467         /** Build the GP Multiple Data Sets Validation-Voting Classifier 
    468          *  
    469          * This is according to Section 6 of the Paper by Liu et al. 
    470          * It is basically the Multiple Data Sets Validation Classifier but here we keep the best models an let them vote. 
     900        } 
     901 
     902        /** 
     903         * Build the GP Multiple Data Sets Validation-Voting Classifier 
     904         *  
     905         * This is according to Section 6 of the Paper by Liu et al. It is basically the Multiple 
     906         * Data Sets Validation Classifier but here we keep the best models an let them vote. 
    471907         *  
    472908         * @param traindataSet 
     909         *            the training data 
    473910         * @throws Exception 
     911         *             thrown in case of a problem with the training 
    474912         */ 
    475913        public void buildClassifier(SetUniqueList<Instances> traindataSet) throws Exception { 
    … …  
    478916            // then is evaluated on the rest 
    479917            classifiers = new LinkedList<>(); 
    480             for(int i=0; i < traindataSet.size(); i++) { 
     918            for (int i = 0; i < traindataSet.size(); i++) { 
    481919 
    482920                // candidates we get out of evaluation 
    483921                LinkedList<Classifier> candidates = new LinkedList<>(); 
    484                  
     922 
    485923                // number of runs, yields the best of these 
    486                 double smallest_error_count_train = Double.MAX_VALUE;  
     924                double smallest_error_count_train = Double.MAX_VALUE; 
    487925                Classifier bestTrain = null; 
    488                 for(int k=0; k < this.numberRuns; k++) { 
    489                     double[] errors_eval = {0.0, 0.0}; 
     926                for (int k = 0; k < this.numberRuns; k++) { 
     927                    double[] errors_eval = 
     928                        { 0.0, 0.0 }; 
    490929                    Classifier classifier = new GPRun(); 
    491                     ((GPRun)classifier).configure(this.populationSize, this.initMinDepth, this.initMaxDepth, this.tournamentSize, this.maxGenerations, this.errorType2Weight, this.maxDepth, this.maxNodes); 
    492                      
     930                    ((GPRun) classifier).configure(this.populationSize, this.initMinDepth, 
     931                                                   this.initMaxDepth, this.tournamentSize, 
     932                                                   this.maxGenerations, this.errorType2Weight, 
     933                                                   this.maxDepth, this.maxNodes); 
     934 
    493935                    // one project is training data 
    494936                    classifier.buildClassifier(traindataSet.get(i)); 
    495                      
     937 
    496938                    double[] errors; 
    497939                    // rest of the set is evaluation data, we evaluate now 
    498                     for(int j=0; j < traindataSet.size(); j++) { 
    499                         if(j != i) { 
    500                             // if type1 and type2 errors are < 0.5 we allow the model in the candidates 
    501                             errors = this.evaluate((GPRun)classifier, traindataSet.get(j)); 
     940                    for (int j = 0; j < traindataSet.size(); j++) { 
     941                        if (j != i) { 
     942                            // if type1 and type2 errors are < 0.5 we allow the model in the 
     943                            // candidates 
     944                            errors = this.evaluate((GPRun) classifier, traindataSet.get(j)); 
    502945                            errors_eval[0] += errors[0]; 
    503946                            errors_eval[1] += errors[1]; 
    504                             if((errors[0] < 0.5) && (errors[1] < 0.5)) { 
     947                            if ((errors[0] < 0.5) && (errors[1] < 0.5)) { 
    505948                                candidates.add(classifier); 
    506949                            } 
    507950                        } 
    508951                    } 
    509                      
     952 
    510953                    // if the candidate made fewer errors it is now the best 
    511                     if(errors_eval[0] + errors_eval[1] < smallest_error_count_train) { 
     954                    if (errors_eval[0] + errors_eval[1] < smallest_error_count_train) { 
    512955                        bestTrain = classifier; 
    513956                        smallest_error_count_train = errors_eval[0] + errors_eval[1]; 
    … …  
    515958                } 
    516959 
    517                 // now after the evaluation we do a model selection where only one model remains for the given training data 
     960                // now after the evaluation we do a model selection where only one model remains for 
     961                // the given training data 
    518962                // we select the model which is best on all evaluation data 
    519963                double smallest_error_count = Double.MAX_VALUE; 
    520964                double[] errors; 
    521965                Classifier best = null; 
    522                 for(int ii=0; ii < candidates.size(); ii++) { 
    523                     double[] errors_eval = {0.0, 0.0}; 
    524                      
     966                for (int ii = 0; ii < candidates.size(); ii++) { 
     967                    double[] errors_eval = 
     968                        { 0.0, 0.0 }; 
     969 
    525970                    // we add the errors the candidate makes over the evaldata 
    526                     for(int j=0; j < traindataSet.size(); j++) { 
    527                         if(j != i) { 
    528                             errors = this.evaluate((GPRun)candidates.get(ii), traindataSet.get(j)); 
     971                    for (int j = 0; j < traindataSet.size(); j++) { 
     972                        if (j != i) { 
     973                            errors = this.evaluate((GPRun) candidates.get(ii), traindataSet.get(j)); 
    529974                            errors_eval[0] += errors[0]; 
    530975                            errors_eval[1] += errors[1]; 
    531976                        } 
    532977                    } 
    533                      
     978 
    534979                    // if the candidate made fewer errors it is now the best 
    535                     if(errors_eval[0] + errors_eval[1] < smallest_error_count) { 
     980                    if (errors_eval[0] + errors_eval[1] < smallest_error_count) { 
    536981                        best = candidates.get(ii); 
    537982                        smallest_error_count = errors_eval[0] + errors_eval[1]; 
    538983                    } 
    539984                } 
    540                  
    541                 if( best==null ) { 
     985 
     986                if (best == null) { 
    542987                    best = bestTrain; 
    543988                } 
    … …  
    546991            } 
    547992        } 
    548          
     993 
    549994        /** 
    550995         * Use the best classifiers for each training data in a majority voting 
     996         *  
     997         * @param instance 
     998         *            instance that is classified 
     999         *  
     1000         * @see de.ugoe.cs.cpdp.training.GPTraining.GPVClassifier#classifyInstance(weka.core.Instance) 
    5511001         */ 
    5521002        @Override 
    5531003        public double classifyInstance(Instance instance) { 
    554              
     1004 
    5551005            int vote_positive = 0; 
    556              
     1006 
    5571007            for (int i = 0; i < classifiers.size(); i++) { 
    5581008                Classifier classifier = classifiers.get(i); 
    559                  
    560                 GPGenotype gp = ((GPRun)classifier).getGp(); 
    561                 Variable[] vars = ((GPRun)classifier).getVariables(); 
    562                  
    563                 IGPProgram fitest = gp.getAllTimeBest();  // all time fitest 
    564                 for(int j = 0; j < instance.numAttributes()-1; j++) { 
    565                    vars[j].set(instance.value(j)); 
    566                 } 
    567                  
    568                 if(fitest.execute_double(0, vars) < 0.5) { 
     1009 
     1010                GPGenotype gp = ((GPRun) classifier).getGp(); 
     1011                Variable[] vars = ((GPRun) classifier).getVariables(); 
     1012 
     1013                IGPProgram fitest = gp.getAllTimeBest(); // all time fitest 
     1014                for (int j = 0; j < instance.numAttributes() - 1; j++) { 
     1015                    vars[j].set(instance.value(j)); 
     1016                } 
     1017 
     1018                if (fitest.execute_double(0, vars) < 0.5) { 
    5691019                    vote_positive += 1; 
    5701020                } 
    5711021            } 
    572              
    573             if(vote_positive >= (classifiers.size()/2)) { 
     1022 
     1023            if (vote_positive >= (classifiers.size() / 2)) { 
    5741024                return 1.0; 
    575             }else { 
     1025            } 
     1026            else { 
    5761027                return 0.0; 
    5771028            } 
    5781029        } 
    5791030    } 
    580      
     1031 
    5811032    /** 
    5821033     * GP Multiple Data Sets Validation Classifier 
    5831034     *  
    584      * We train a Classifier with one training project $numberRun times. 
    585      * Then we evaluate the classifier on the rest of the training projects and keep the best classifier. 
    586      * After that we have for each training project the best classifier as per the evaluation on the rest of the data set. 
    587      * Then we determine the best classifier from these candidates and keep it to be used later. 
     1035     * We train a Classifier with one training project $numberRun times. Then we evaluate the 
     1036     * classifier on the rest of the training projects and keep the best classifier. After that we 
     1037     * have for each training project the best classifier as per the evaluation on the rest of the 
     1038     * data set. Then we determine the best classifier from these candidates and keep it to be used 
     1039     * later. 
     1040     *  
     1041     * @author sherbold Alexander Trautsch 
    5881042     */ 
    5891043    public class GPVClassifier extends AbstractClassifier { 
    590          
     1044 
    5911045        private List<Classifier> classifiers = null; 
    5921046        private Classifier best = null; 
    … …  
    5941048        private static final long serialVersionUID = 3708714057579101522L; 
    5951049 
     1050        /** 
     1051         * size of the population of the genetic program 
     1052         */ 
    5961053        protected int populationSize; 
     1054 
     1055        /** 
     1056         * minimal depth of the S-expression tree at the start of the training 
     1057         */ 
    5971058        protected int initMinDepth; 
     1059 
     1060        /** 
     1061         * maximal depth of the S-expression tree at the start of the training 
     1062         */ 
    5981063        protected int initMaxDepth; 
     1064 
     1065        /** 
     1066         * size of the tournaments used for selection 
     1067         */ 
    5991068        protected int tournamentSize; 
     1069 
     1070        /** 
     1071         * number of genetic generations considered (i.e., number of iterations 
     1072         */ 
    6001073        protected int maxGenerations; 
     1074 
     1075        /** 
     1076         * weight factor for the prediction errors for cost estimation 
     1077         */ 
    6011078        protected double errorType2Weight; 
    602         protected int numberRuns; 
     1079 
     1080        /** 
     1081         * number of internal replications from which the best result is picked 
     1082         */ 
     1083        protected int numberRuns = 20; 
     1084 
     1085        /** 
     1086         * maximal depth of the S-expression tree 
     1087         */ 
    6031088        protected int maxDepth; 
     1089 
     1090        /** 
     1091         * maximal number of nodes of the S-expression tree 
     1092         */ 
    6041093        protected int maxNodes; 
    6051094 
    6061095        /** 
     1096         *  
     1097         * <p> 
    6071098         * Configure the GP Params and number of Runs 
     1099         * </p> 
    6081100         *  
    6091101         * @param populationSize 
     1102         *            the population size 
    6101103         * @param initMinDepth 
     1104         *            the initial minimal depth of the S-expression tree 
    6111105         * @param initMaxDepth 
     1106         *            the initial maximal depth of the S-expression tree 
    6121107         * @param tournamentSize 
     1108         *            the tournament size for selection 
    6131109         * @param maxGenerations 
     1110         *            the number of generations created 
    6141111         * @param errorType2Weight 
    615          */ 
    616         public void configure(int populationSize, int initMinDepth, int initMaxDepth, int tournamentSize, int maxGenerations, double errorType2Weight, int numberRuns, int maxDepth, int maxNodes) { 
     1112         *            weigth factor for the prediction errors 
     1113         * @param numberRuns 
     1114         *            number of internal replications from which the best result is picked 
     1115         * @param maxDepth 
     1116         *            maximal depth of the S-expression tree 
     1117         * @param maxNodes 
     1118         *            maximal number of nodes of the S-expression tree 
     1119         */ 
     1120        public void configure(int populationSize, 
     1121                              int initMinDepth, 
     1122                              int initMaxDepth, 
     1123                              int tournamentSize, 
     1124                              int maxGenerations, 
     1125                              double errorType2Weight, 
     1126                              int numberRuns, 
     1127                              int maxDepth, 
     1128                              int maxNodes) 
     1129        { 
    6171130            this.populationSize = populationSize; 
    6181131            this.initMinDepth = initMinDepth; 
    … …  
    6251138            this.maxNodes = maxNodes; 
    6261139        } 
    627          
    628         /** Build the GP Multiple Data Sets Validation Classifier 
    629          *  
    630          * This is according to Section 6 of the Paper by Liu et al. except for the selection of the best model. 
    631          * Section 4 describes a slightly different approach. 
     1140 
     1141        /** 
     1142         * Build the GP Multiple Data Sets Validation Classifier 
     1143         *  
     1144         * This is according to Section 6 of the Paper by Liu et al. except for the selection of the 
     1145         * best model. Section 4 describes a slightly different approach. 
    6321146         *  
    6331147         * @param traindataSet 
     1148         *            the training data 
    6341149         * @throws Exception 
     1150         *             thrown in case of a problem with the training 
    6351151         */ 
    6361152        public void buildClassifier(SetUniqueList<Instances> traindataSet) throws Exception { 
    … …  
    6381154            // each classifier is trained with one project from the set 
    6391155            // then is evaluated on the rest 
    640             for(int i=0; i < traindataSet.size(); i++) { 
    641                  
     1156            for (int i = 0; i < traindataSet.size(); i++) { 
     1157 
    6421158                // candidates we get out of evaluation 
    6431159                LinkedList<Classifier> candidates = new LinkedList<>(); 
    644                  
     1160 
    6451161                // numberRuns full GPRuns, we generate numberRuns models for each traindata 
    646                 for(int k=0; k < this.numberRuns; k++) { 
     1162                for (int k = 0; k < this.numberRuns; k++) { 
    6471163                    Classifier classifier = new GPRun(); 
    648                     ((GPRun)classifier).configure(this.populationSize, this.initMinDepth, this.initMaxDepth, this.tournamentSize, this.maxGenerations, this.errorType2Weight, this.maxDepth, this.maxNodes); 
    649                      
     1164                    ((GPRun) classifier).configure(this.populationSize, this.initMinDepth, 
     1165                                                   this.initMaxDepth, this.tournamentSize, 
     1166                                                   this.maxGenerations, this.errorType2Weight, 
     1167                                                   this.maxDepth, this.maxNodes); 
     1168 
    6501169                    classifier.buildClassifier(traindataSet.get(i)); 
    651                      
     1170 
    6521171                    double[] errors; 
    6531172 
    6541173                    // rest of the set is evaluation data, we evaluate now 
    655                     for(int j=0; j < traindataSet.size(); j++) { 
    656                         if(j != i) { 
    657                             // if type1 and type2 errors are < 0.5 we allow the model in the candidate list 
    658                             errors = this.evaluate((GPRun)classifier, traindataSet.get(j)); 
    659                             if((errors[0] < 0.5) && (errors[1] < 0.5)) { 
     1174                    for (int j = 0; j < traindataSet.size(); j++) { 
     1175                        if (j != i) { 
     1176                            // if type1 and type2 errors are < 0.5 we allow the model in the 
     1177                            // candidate list 
     1178                            errors = this.evaluate((GPRun) classifier, traindataSet.get(j)); 
     1179                            if ((errors[0] < 0.5) && (errors[1] < 0.5)) { 
    6601180                                candidates.add(classifier); 
    6611181                            } 
    … …  
    6631183                    } 
    6641184                } 
    665                  
    666                 // now after the evaluation we do a model selection where only one model remains for the given training data 
     1185 
     1186                // now after the evaluation we do a model selection where only one model remains for 
     1187                // the given training data 
    6671188                // we select the model which is best on all evaluation data 
    6681189                double smallest_error_count = Double.MAX_VALUE; 
    6691190                double[] errors; 
    6701191                Classifier best = null; 
    671                 for(int ii=0; ii < candidates.size(); ii++) { 
    672                     double[] errors_eval = {0.0, 0.0}; 
    673                      
     1192                for (int ii = 0; ii < candidates.size(); ii++) { 
     1193                    double[] errors_eval = 
     1194                        { 0.0, 0.0 }; 
     1195 
    6741196                    // we add the errors the candidate makes over the evaldata 
    675                     for(int j=0; j < traindataSet.size(); j++) { 
    676                         if(j != i) { 
    677                             errors = this.evaluate((GPRun)candidates.get(ii), traindataSet.get(j)); 
     1197                    for (int j = 0; j < traindataSet.size(); j++) { 
     1198                        if (j != i) { 
     1199                            errors = this.evaluate((GPRun) candidates.get(ii), traindataSet.get(j)); 
    6781200                            errors_eval[0] += errors[0]; 
    6791201                            errors_eval[1] += errors[1]; 
    6801202                        } 
    6811203                    } 
    682                      
     1204 
    6831205                    // if the candidate made fewer errors it is now the best 
    684                     if(errors_eval[0] + errors_eval[1] < smallest_error_count) { 
     1206                    if (errors_eval[0] + errors_eval[1] < smallest_error_count) { 
    6851207                        best = candidates.get(ii); 
    6861208                        smallest_error_count = errors_eval[0] + errors_eval[1]; 
    6871209                    } 
    6881210                } 
    689                  
    690                  
     1211 
    6911212                // now we have the best classifier for this training data 
    6921213                classifiers.add(best); 
    6931214 
    6941215            } /* endfor trainData */ 
    695              
    696             // now we have one best classifier for each trainData  
     1216 
     1217            // now we have one best classifier for each trainData 
    6971218            // we evaluate again to find the best classifier of all time 
    698             // this selection is now according to section 4 of the paper and not 6 where an average of the 6 models is build  
     1219            // this selection is now according to section 4 of the paper and not 6 where an average 
     1220            // of the 6 models is build 
    6991221            double smallest_error_count = Double.MAX_VALUE; 
    7001222            double error_count; 
    7011223            double errors[]; 
    702             for(int j=0; j < classifiers.size(); j++) { 
     1224            for (int j = 0; j < classifiers.size(); j++) { 
    7031225                error_count = 0; 
    7041226                Classifier current = classifiers.get(j); 
    705                 for(int i=0; i < traindataSet.size(); i++) { 
    706                     errors = this.evaluate((GPRun)current, traindataSet.get(i)); 
     1227                for (int i = 0; i < traindataSet.size(); i++) { 
     1228                    errors = this.evaluate((GPRun) current, traindataSet.get(i)); 
    7071229                    error_count = errors[0] + errors[1]; 
    7081230                } 
    709                  
    710                 if(error_count < smallest_error_count) { 
     1231 
     1232                if (error_count < smallest_error_count) { 
    7111233                    best = current; 
    7121234                } 
    7131235            } 
    7141236        } 
    715          
     1237 
     1238        /* 
     1239         * (non-Javadoc) 
     1240         *  
     1241         * @see weka.classifiers.Classifier#buildClassifier(weka.core.Instances) 
     1242         */ 
    7161243        @Override 
    7171244        public void buildClassifier(Instances traindata) throws Exception { 
    7181245            final Classifier classifier = new GPRun(); 
    719             ((GPRun)classifier).configure(populationSize, initMinDepth, initMaxDepth, tournamentSize, maxGenerations, errorType2Weight, this.maxDepth, this.maxNodes); 
     1246            ((GPRun) classifier).configure(populationSize, initMinDepth, initMaxDepth, 
     1247                                           tournamentSize, maxGenerations, errorType2Weight, 
     1248                                           this.maxDepth, this.maxNodes); 
    7201249            classifier.buildClassifier(traindata); 
    7211250            classifiers.add(classifier); 
    7221251        } 
    723          
    724         /** 
    725          * Evaluation of the Classifier 
    726          *  
    727          * We evaluate the classifier with the Instances of the evalData. 
    728          * It basically assigns the instance attribute values to the variables of the s-expression-tree and  
    729          * then counts the missclassifications.  
     1252 
     1253        /** 
     1254         * <p> 
     1255         * Evaluation of the Classifier. 
     1256         * </p> 
     1257         * <p> 
     1258         * We evaluate the classifier with the Instances of the evalData. It basically assigns the 
     1259         * instance attribute values to the variables of the s-expression-tree and then counts the 
     1260         * missclassifications. 
     1261         * </p> 
    7301262         *  
    7311263         * @param classifier 
     1264         *            the classifier that is evaluated 
    7321265         * @param evalData 
     1266         *            the validation data 
    7331267         * @return 
    7341268         */ 
    … …  
    7361270            GPGenotype gp = classifier.getGp(); 
    7371271            Variable[] vars = classifier.getVariables(); 
    738              
    739             IGPProgram fitest = gp.getAllTimeBest();  // selects the fitest of all not just the last generation 
    740              
     1272 
     1273            IGPProgram fitest = gp.getAllTimeBest(); // selects the fitest of all not just the last 
     1274                                                     // generation 
     1275 
    7411276            double classification; 
    7421277            int error_type1 = 0; 
    … …  
    7441279            int positive = 0; 
    7451280            int negative = 0; 
    746              
    747             for(Instance instance: evalData) { 
    748                  
     1281 
     1282            for (Instance instance : evalData) { 
     1283 
    7491284                // assign instance attribute values to the variables of the s-expression-tree 
    7501285                double[] tmp = WekaUtils.instanceValues(instance); 
    751                 for(int i = 0; i < tmp.length; i++) { 
     1286                for (int i = 0; i < tmp.length; i++) { 
    7521287                    vars[i].set(tmp[i]); 
    7531288                } 
    754                  
     1289 
    7551290                classification = fitest.execute_double(0, vars); 
    756                  
     1291 
    7571292                // we need to count the absolutes of positives for percentage 
    758                 if(instance.classValue() == 1.0) { 
    759                     positive +=1; 
    760                 }else { 
    761                     negative +=1; 
    762                 } 
    763                  
     1293                if (instance.classValue() == 1.0) { 
     1294                    positive += 1; 
     1295                } 
     1296                else { 
     1297                    negative += 1; 
     1298                } 
     1299 
    7641300                // classification < 0.5 we say defective 
    765                 if(classification < 0.5) { 
    766                     if(instance.classValue() != 1.0) { 
     1301                if (classification < 0.5) { 
     1302                    if (instance.classValue() != 1.0) { 
    7671303                        error_type1 += 1; 
    7681304                    } 
    769                 }else { 
    770                     if(instance.classValue() == 1.0) { 
     1305                } 
     1306                else { 
     1307                    if (instance.classValue() == 1.0) { 
    7711308                        error_type2 += 1; 
    7721309                    } 
    7731310                } 
    7741311            } 
    775              
    776             // return error types percentages for the types  
     1312 
     1313            // return error types percentages for the types 
    7771314            double et1_per = error_type1 / negative; 
    778             double et2_per = error_type2 / positive;  
    779             return new double[]{et1_per, et2_per}; 
    780         } 
    781          
     1315            double et2_per = error_type2 / positive; 
     1316            return new double[] 
     1317                { et1_per, et2_per }; 
     1318        } 
     1319 
    7821320        /** 
    7831321         * Use only the best classifier from our evaluation phase 
     1322         *  
     1323         * @param instance 
     1324         *            instance that is classified 
     1325         *  
     1326         * @see weka.classifiers.AbstractClassifier#classifyInstance(weka.core.Instance) 
    7841327         */ 
    7851328        @Override 
    7861329        public double classifyInstance(Instance instance) { 
    787             GPGenotype gp = ((GPRun)best).getGp(); 
    788             Variable[] vars = ((GPRun)best).getVariables(); 
    789              
    790             IGPProgram fitest = gp.getAllTimeBest();  // all time fitest 
    791             for(int i = 0; i < instance.numAttributes()-1; i++) { 
    792                vars[i].set(instance.value(i)); 
    793             } 
    794              
     1330            GPGenotype gp = ((GPRun) best).getGp(); 
     1331            Variable[] vars = ((GPRun) best).getVariables(); 
     1332 
     1333            IGPProgram fitest = gp.getAllTimeBest(); // all time fitest 
     1334            for (int i = 0; i < instance.numAttributes() - 1; i++) { 
     1335                vars[i].set(instance.value(i)); 
     1336            } 
     1337 
    7951338            double classification = fitest.execute_double(0, vars); 
    796              
    797             if(classification < 0.5) { 
     1339 
     1340            if (classification < 0.5) { 
    7981341                return 1.0; 
    799             }else { 
     1342            } 
     1343            else { 
    8001344                return 0.0; 
    8011345            } 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/training/ISetWiseTestdataAwareTrainingStrategy.java

    r45 r135  
     1 
    12package de.ugoe.cs.cpdp.training; 
    23 
    … …  
    45import weka.core.Instances; 
    56 
     7/** 
     8 * <p> 
     9 * Training strategy for training with access to the target data and one data set per input product. 
     10 * </p> 
     11 *  
     12 * @author Steffen Herbold 
     13 */ 
    614public interface ISetWiseTestdataAwareTrainingStrategy extends ITrainer { 
    715 
     16    /** 
     17     * <p> 
     18     * Applies the training strategy. 
     19     * </p> 
     20     * 
     21     * @param traindataSet 
     22     *            the training data per product 
     23     * @param testdata 
     24     *            the test data from the target product 
     25     */ 
    826    void apply(SetUniqueList<Instances> traindataSet, Instances testdata); 
    927 
     28    /** 
     29     * <p> 
     30     * returns the name of the training strategy 
     31     * </p> 
     32     * 
     33     * @return the name 
     34     */ 
    1035    String getName(); 
    11      
     36 
     37    // TODO: these two methods look like they should be removed and instead be handled using the parameters 
    1238    void setMethod(String method); 
     39 
    1340    void setThreshold(String threshold); 
    1441} 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/training/ISetWiseTrainingStrategy.java

    r86 r135  
    1919import weka.core.Instances; 
    2020 
    21 // Bagging Strategy: separate models for each training data set 
     21/** 
     22 * <p> 
     23 * Training strategy for training with one data set per input product. 
     24 * </p> 
     25 *  
     26 * @author Steffen Herbold 
     27 */ 
    2228public interface ISetWiseTrainingStrategy extends ITrainer { 
    2329 
     30    /** 
     31     * <p> 
     32     * Applies the training strategy. 
     33     * </p> 
     34     * 
     35     * @param traindataSet 
     36     *            the training data per product 
     37     */ 
    2438    void apply(SetUniqueList<Instances> traindataSet); 
    2539 
     40    /** 
     41     * <p> 
     42     * returns the name of the training strategy 
     43     * </p> 
     44     * 
     45     * @return the name 
     46     */ 
    2647    String getName(); 
    2748} 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/training/ITestAwareTrainingStrategy.java

    r65 r135  
    33import weka.core.Instances; 
    44 
     5/** 
     6 * <p> 
     7 * Training strategy for training with access to the target data and the training data as a single data set. 
     8 * </p> 
     9 *  
     10 * @author Steffen Herbold 
     11 */ 
    512public interface ITestAwareTrainingStrategy extends ITrainer { 
    613     
     14    /** 
     15     * <p> 
     16     * Applies the training strategy. 
     17     * </p> 
     18     * 
     19     * @param traindata 
     20     *            the training data for all products 
     21     * @param testdata 
     22     *            the test data from the target product 
     23     */ 
    724    void apply(Instances testdata, Instances traindata); 
    825 
     26    /** 
     27     * <p> 
     28     * returns the name of the training strategy 
     29     * </p> 
     30     * 
     31     * @return the name 
     32     */ 
    933    String getName(); 
    1034} 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/training/ITrainer.java

    r86 r135  
    1717import de.ugoe.cs.cpdp.IParameterizable; 
    1818 
     19/** 
     20 * <p> 
     21 * Marker interface for all CrossPare trainers. 
     22 * </p> 
     23 *  
     24 * @author Steffen Herbold 
     25 */ 
    1926public interface ITrainer extends IParameterizable { 
    2027 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/training/ITrainingStrategy.java

    r86 r135  
    1717import weka.core.Instances; 
    1818 
     19/** 
     20 * <p> 
     21 * Training strategy for training with the training data as a single data set. 
     22 * </p> 
     23 *  
     24 * @author Steffen Herbold 
     25 */ 
    1926public interface ITrainingStrategy extends ITrainer { 
    2027 
     28    /** 
     29     * <p> 
     30     * Applies the training strategy. 
     31     * </p> 
     32     * 
     33     * @param traindata 
     34     *            the training data for all target products 
     35     */ 
    2136    void apply(Instances traindata); 
    2237 
     38    /** 
     39     * <p> 
     40     * returns the name of the training strategy 
     41     * </p> 
     42     * 
     43     * @return the name 
     44     */ 
    2345    String getName(); 
    2446} 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/training/IWekaCompatibleTrainer.java

    r86 r135  
    1717import weka.classifiers.Classifier; 
    1818 
     19/** 
     20 * <p> 
     21 * Common interface for all training strategies that internally use the {@link Classifier} from WEKA.  
     22 * </p> 
     23 *  
     24 * @author Steffen Herbold 
     25 */ 
    1926public interface IWekaCompatibleTrainer extends ITrainer { 
    2027 
     28    /** 
     29     * <p> 
     30     * returns the WEKA classifier 
     31     * </p> 
     32     * 
     33     * @return the classifier 
     34     */ 
    2135    Classifier getClassifier(); 
    2236 
     37    /** 
     38     * <p> 
     39     * returns the name of the training strategy 
     40     * </p> 
     41     * 
     42     * @return the name 
     43     */ 
    2344    String getName(); 
    2445} 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/training/QuadTree.java

    r86 r135  
    2424 
    2525/** 
    26  * QuadTree implementation 
     26 * <p> 
     27 * QuadTree implementation. 
     28 * </p> 
     29 * <p> 
     30 * QuadTree gets a list of instances and then recursively split them into 4 children For this it 
     31 * uses the median of the 2 values x,y. 
     32 * </p> 
    2733 *  
    28  * QuadTree gets a list of instances and then recursively split them into 4 childs For this it uses 
    29  * the median of the 2 values x,y 
     34 * @author Alexander Trautsch 
    3035 */ 
    3136public class QuadTree { 
    3237 
    33     /* 1 parent or null */ 
     38    /** 
     39     * 1 parent or null 
     40     */ 
    3441    private QuadTree parent = null; 
    3542 
    36     /* 4 childs, 1 per quadrant */ 
     43    /** 
     44     * north-west quadrant 
     45     */ 
    3746    private QuadTree child_nw; 
     47 
     48    /** 
     49     * north-east quadrant 
     50     */ 
    3851    private QuadTree child_ne; 
     52 
     53    /** 
     54     * south-east quadrant 
     55     */ 
    3956    private QuadTree child_se; 
     57 
     58    /** 
     59     * south-west quadrant 
     60     */ 
    4061    private QuadTree child_sw; 
    4162 
    42     /* list (only helps with generation of list of childs!) */ 
     63    /** 
     64     * helper list for child quadrant generation 
     65     */ 
    4366    private ArrayList<QuadTree> l = new ArrayList<QuadTree>(); 
    4467 
    45     /* level only used for debugging */ 
     68    /** 
     69     * debugging attribute 
     70     */ 
    4671    public int level = 0; 
    4772 
    48     /* size of the quadrant */ 
     73    /** 
     74     * size of the quadrant in x-dimension 
     75     */ 
    4976    private double[] x; 
     77 
     78    /** 
     79     * size of the quadrant in y-dimension 
     80     */ 
    5081    private double[] y; 
    5182 
     83    /** 
     84     * debugging parameter 
     85     */ 
    5286    public static boolean verbose = false; 
     87 
     88    /** 
     89     * global size of the QuadTree. 
     90     */ 
    5391    public static int size = 0; 
     92 
     93    /** 
     94     * recursion parameter alpha 
     95     */ 
    5496    public static double alpha = 0; 
    5597 
    56     /* cluster payloads */ 
     98    /** 
     99     * data for each cluster 
     100     */ 
    57101    public static ArrayList<ArrayList<QuadTreePayload<Instance>>> ccluster = 
    58102        new ArrayList<ArrayList<QuadTreePayload<Instance>>>(); 
    59103 
    60     /* cluster sizes (index is cluster number, arraylist is list of boxes (x0,y0,x1,y1) */ 
     104    /** 
     105     * cluster sizes (index is cluster number, {@link ArrayList} is list of boxes (x0,y0,x1,y1 
     106     */ 
    61107    public static HashMap<Integer, ArrayList<Double[][]>> csize = 
    62108        new HashMap<Integer, ArrayList<Double[][]>>(); 
    63109 
    64     /* payload of this instance */ 
     110    /** 
     111     * data within this quadrant 
     112     */ 
    65113    private ArrayList<QuadTreePayload<Instance>> payload; 
    66114 
     115    /** 
     116     * <p> 
     117     * Constructor. Creates a new QuadTree. 
     118     * </p> 
     119     * 
     120     * @param parent 
     121     *            parent of this tree 
     122     * @param payload 
     123     *            data within the quadrant 
     124     */ 
    67125    public QuadTree(QuadTree parent, ArrayList<QuadTreePayload<Instance>> payload) { 
    68126        this.parent = parent; 
    … …  
    70128    } 
    71129 
     130    /* 
     131     * (non-Javadoc) 
     132     *  
     133     * @see java.lang.Object#toString() 
     134     */ 
     135    @Override 
    72136    public String toString() { 
    73137        String n = ""; 
    … …  
    81145 
    82146    /** 
     147     * <p> 
    83148     * Returns the payload, used for clustering in the clustering list we only have children with 
    84      * paylod 
    85      *  
    86      * @return payload 
     149     * payload 
     150     * </p> 
     151     *  
     152     * @return payload the payload 
    87153     */ 
    88154    public ArrayList<QuadTreePayload<Instance>> getPayload() { 
    … …  
    91157 
    92158    /** 
    93      * Calculate the density of this quadrant 
    94      *  
    95      * density = number of instances / global size (all instances) 
    96      *  
    97      * @return density 
     159     * <p> 
     160     * Calculate the density of this quadrant as 
     161     * <ul> 
     162     * <li>density = number of instances / global size (all instances)</li> 
     163     * </ul> 
     164     *  
     165     * @return density the density 
    98166     */ 
    99167    public double getDensity() { 
    … …  
    103171    } 
    104172 
     173    /** 
     174     * <p> 
     175     * sets the size coordinates of the quadrant 
     176     * </p> 
     177     * 
     178     * @param x 
     179     *            x-dimension 
     180     * @param y 
     181     *            y-dimension 
     182     */ 
    105183    public void setSize(double[] x, double[] y) { 
    106184        this.x = x; 
    … …  
    108186    } 
    109187 
     188    /** 
     189     * <p> 
     190     * returns the size of the quadrant 
     191     * </p> 
     192     * 
     193     * @return size of the current quadrant 
     194     */ 
    110195    public double[][] getSize() { 
    111196        return new double[][] 
    … …  
    113198    } 
    114199 
     200    /** 
     201     * <p> 
     202     * returns the size of the quadrant 
     203     * </p> 
     204     * 
     205     * @return size of the current quadrant 
     206     */ 
    115207    public Double[][] getSizeDouble() { 
    116208        Double[] tmpX = new Double[2]; 
    … …  
    128220 
    129221    /** 
    130      * TODO: DRY, median ist immer dasselbe 
     222     * <p> 
     223     * calculates the median for the x axis 
     224     * </p> 
    131225     *  
    132226     * @return median for x 
    … …  
    161255    } 
    162256 
     257    /** 
     258     * <p> 
     259     * calculates the median for the y axis 
     260     * </p> 
     261     *  
     262     * @return median for y 
     263     */ 
    163264    private double getMedianForY() { 
    164265        double med_y = 0; 
    … …  
    191292 
    192293    /** 
    193      * Reurns the number of instances in the payload 
    194      *  
    195      * @return int number of instances 
     294     * <p> 
     295     * Returns the number of instances in the payload 
     296     * </p> 
     297     *  
     298     * @return number of instances 
    196299     */ 
    197300    public int getNumbers() { 
    … …  
    204307 
    205308    /** 
     309     * <p> 
    206310     * Calculate median values of payload for x, y and split into 4 sectors 
     311     * </p> 
    207312     *  
    208313     * @return Array of QuadTree nodes (4 childs) 
    … …  
    295400 
    296401    /** 
    297      * TODO: static method 
    298      *  
     402     * <p> 
     403     * creates the children of a QuadTree and recursively splits them as well 
     404     * </p> 
     405     * 
    299406     * @param q 
    300      */ 
    301     public void recursiveSplit(QuadTree q) { 
     407     *            tree that is split 
     408     */ 
     409    public static void recursiveSplit(QuadTree q) { 
    302410        if (QuadTree.verbose) { 
    303411            System.out.println("splitting: " + q); 
    … …  
    310418            try { 
    311419                QuadTree[] childs = q.split(); 
    312                 this.recursiveSplit(childs[0]); 
    313                 this.recursiveSplit(childs[1]); 
    314                 this.recursiveSplit(childs[2]); 
    315                 this.recursiveSplit(childs[3]); 
     420                recursiveSplit(childs[0]); 
     421                recursiveSplit(childs[1]); 
     422                recursiveSplit(childs[2]); 
     423                recursiveSplit(childs[3]); 
    316424            } 
    317425            catch (Exception e) { 
    … …  
    322430 
    323431    /** 
    324      * returns an list of childs sorted by density 
     432     * <p> 
     433     * returns an list of children sorted by density 
     434     * </p> 
    325435     *  
    326436     * @param q 
    327437     *            QuadTree 
    328      * @return list of QuadTrees 
    329438     */ 
    330439    private void generateList(QuadTree q) { 
    … …  
    350459 
    351460    /** 
     461     * <p> 
    352462     * Checks if passed QuadTree is neighboring to us 
     463     * </p> 
    353464     *  
    354465     * @param q 
    … …  
    396507 
    397508    /** 
     509     * <p> 
    398510     * Perform pruning and clustering of the quadtree 
    399      *  
     511     * </p> 
     512     * <p> 
    400513     * Pruning according to: Tim Menzies, Andrew Butcher, David Cok, Andrian Marcus, Lucas Layman, 
    401514     * Forrest Shull, Burak Turhan, Thomas Zimmermann, 
    402515     * "Local versus Global Lessons for Defect Prediction and Effort Estimation," IEEE Transactions 
    403516     * on Software Engineering, vol. 39, no. 6, pp. 822-834, June, 2013 
    404      *  
    405      * 1) get list of leaf quadrants 2) sort by their density 3) set stop_rule to 0.5 * highest 
    406      * Density in the list 4) merge all nodes with a density > stop_rule to the new cluster and 
    407      * remove all from list 5) repeat 
     517     * </p> 
     518     * <ol> 
     519     * <li>get list of leaf quadrants</li> 
     520     * <li>sort by their density</li> 
     521     * <li>set stop_rule to 0.5*highest Density in the list</li> 
     522     * <li>merge all nodes with a density > stop_rule to the new cluster and remove all from list 
     523     * </li> 
     524     * <li>repeat</li> 
     525     * </ol> 
    408526     *  
    409527     * @param q 
    … …  
    479597    } 
    480598 
     599    /** 
     600     * <p> 
     601     * debugging function that prints information about the QuadTree 
     602     * </p> 
     603     * 
     604     */ 
    481605    public void printInfo() { 
    482606        System.out.println("we have " + ccluster.size() + " clusters"); 
    … …  
    488612 
    489613    /** 
     614     * <p> 
    490615     * Helper Method to get a sorted list (by density) for all children 
     616     * </p> 
    491617     *  
    492618     * @param q 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/training/WekaBaggingTraining.java

    r99 r135  
    2929 
    3030/** 
    31  * Programmatic WekaBaggingTraining 
    32  *  
    33  * first parameter is Trainer Name. second parameter is class name 
    34  *  
    35  * all subsequent parameters are configuration params (for example for trees) Cross Validation 
    36  * params always come last and are prepended with -CVPARAM 
    37  *  
     31 * <p> 
     32 * The first parameter is the trainer name, second parameter is class name. All subsequent 
     33 * parameters are configuration parameters of the algorithms. Cross validation parameters always 
     34 * come last and are prepended with -CVPARAM 
     35 * </p> 
     36 * <p> 
    3837 * XML Configurations for Weka Classifiers: 
    3938 *  
    … …  
    4544 * } 
    4645 * </pre> 
     46 * </p> 
    4747 *  
     48 * @author Alexander Trautsch 
    4849 */ 
    4950public class WekaBaggingTraining extends WekaBaseTraining implements ISetWiseTrainingStrategy { 
    5051 
     52    /** 
     53     * the classifier 
     54     */ 
    5155    private final TraindatasetBagging classifier = new TraindatasetBagging(); 
    5256 
     57    /* 
     58     * (non-Javadoc) 
     59     *  
     60     * @see de.ugoe.cs.cpdp.training.WekaBaseTraining#getClassifier() 
     61     */ 
    5362    @Override 
    5463    public Classifier getClassifier() { 
    … …  
    5665    } 
    5766 
     67    /* 
     68     * (non-Javadoc) 
     69     *  
     70     * @see 
     71     * de.ugoe.cs.cpdp.training.ISetWiseTrainingStrategy#apply(org.apache.commons.collections4.list. 
     72     * SetUniqueList) 
     73     */ 
    5874    @Override 
    5975    public void apply(SetUniqueList<Instances> traindataSet) { 
    … …  
    6682    } 
    6783 
     84    /** 
     85     * <p> 
     86     * Helper class for bagging classifiers. 
     87     * </p> 
     88     *  
     89     * @author Steffen Herbold 
     90     */ 
    6891    public class TraindatasetBagging extends AbstractClassifier { 
    6992 
     93        /** 
     94         * default serialization ID. 
     95         */ 
    7096        private static final long serialVersionUID = 1L; 
    7197 
     98        /** 
     99         * internal storage of the training data 
     100         */ 
    72101        private List<Instances> trainingData = null; 
    73102 
     103        /** 
     104         * bagging classifier for each training data set 
     105         */ 
    74106        private List<Classifier> classifiers = null; 
    75107 
     108        /* 
     109         * (non-Javadoc) 
     110         *  
     111         * @see weka.classifiers.AbstractClassifier#classifyInstance(weka.core.Instance) 
     112         */ 
    76113        @Override 
    77114        public double classifyInstance(Instance instance) { 
    … …  
    115152        } 
    116153 
     154        /** 
     155         * <p> 
     156         * trains a new dataset wise bagging classifier 
     157         * </p> 
     158         * 
     159         * @param traindataSet 
     160         *            the training data per prodcut 
     161         * @throws Exception 
     162         *             thrown if an error occurs during the training of the classifiers for any 
     163         *             product 
     164         */ 
    117165        public void buildClassifier(SetUniqueList<Instances> traindataSet) throws Exception { 
    118166            classifiers = new LinkedList<>(); 
    … …  
    126174        } 
    127175 
     176        /* 
     177         * (non-Javadoc) 
     178         *  
     179         * @see weka.classifiers.Classifier#buildClassifier(weka.core.Instances) 
     180         */ 
    128181        @Override 
    129182        public void buildClassifier(Instances traindata) throws Exception { 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/training/WekaBaseTraining.java

    r131 r135  
    2727 
    2828/** 
    29  * WekaBaseTraining2 
     29 * <p> 
     30 * Allows specification of the Weka classifier and its params in the XML experiment configuration. 
     31 * </p> 
     32 * <p> 
     33 * Important conventions of the XML format: Cross Validation params always come last and are 
     34 * prepended with -CVPARAM.<br> 
     35 * Example: 
    3036 *  
    31  * Allows specification of the Weka classifier and its params in the XML experiment configuration. 
     37 * <pre> 
     38 * {@code 
     39 * <trainer name="WekaTraining" param="RandomForestLocal weka.classifiers.trees.RandomForest -CVPARAM I 5 25 5"/> 
     40 * } 
     41 * </pre> 
    3242 *  
    33  * Important conventions of the XML format: Cross Validation params always come last and are 
    34  * prepended with -CVPARAM Example: <trainer name="WekaTraining" 
    35  * param="RandomForestLocal weka.classifiers.trees.RandomForest -CVPARAM I 5 25 5"/> 
     43 * @author Alexander Trautsch 
    3644 */ 
    3745public abstract class WekaBaseTraining implements IWekaCompatibleTrainer { 
    3846 
     47    /** 
     48     * reference to the Weka classifier 
     49     */ 
    3950    protected Classifier classifier = null; 
     51 
     52    /** 
     53     * qualified class name of the weka classifier 
     54     */ 
    4055    protected String classifierClassName; 
     56 
     57    /** 
     58     * name of the classifier 
     59     */ 
    4160    protected String classifierName; 
     61 
     62    /** 
     63     * parameters of the training 
     64     */ 
    4265    protected String[] classifierParams; 
    4366 
     67    /* 
     68     * (non-Javadoc) 
     69     *  
     70     * @see de.ugoe.cs.cpdp.IParameterizable#setParameter(java.lang.String) 
     71     */ 
    4472    @Override 
    4573    public void setParameter(String parameters) { 
    … …  
    5886        classifierParams = Arrays.copyOfRange(params, 2, params.length); 
    5987 
    60         //classifier = setupClassifier(); 
     88        // classifier = setupClassifier(); 
    6189    } 
    6290 
     91    /* 
     92     * (non-Javadoc) 
     93     *  
     94     * @see de.ugoe.cs.cpdp.training.IWekaCompatibleTrainer#getClassifier() 
     95     */ 
    6396    @Override 
    6497    public Classifier getClassifier() { 
    … …  
    6699    } 
    67100 
     101    /** 
     102     * <p> 
     103     * helper function that sets up the Weka classifier including its parameters 
     104     * </p> 
     105     * 
     106     * @return 
     107     */ 
    68108    protected Classifier setupClassifier() { 
    69109        Classifier cl = null; 
    … …  
    95135            cl = obj; 
    96136 
    97             if( cl instanceof Vote ) { 
     137            if (cl instanceof Vote) { 
    98138                Vote votingClassifier = (Vote) cl; 
    99                 for( Classifier classifier : votingClassifier.getClassifiers() ) { 
    100                     if( classifier instanceof BayesNet ) { 
     139                for (Classifier classifier : votingClassifier.getClassifiers()) { 
     140                    if (classifier instanceof BayesNet) { 
    101141                        ((BayesNet) classifier).setUseADTree(false); 
    102142                    } 
    … …  
    141181    } 
    142182 
     183    /* 
     184     * (non-Javadoc) 
     185     *  
     186     * @see de.ugoe.cs.cpdp.training.IWekaCompatibleTrainer#getName() 
     187     */ 
    143188    @Override 
    144189    public String getName() { 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/training/WekaLASERTraining.java

    r91 r135  
    2424import weka.core.Instances; 
    2525 
    26  
    2726/** 
    2827 * <p> 
    29  * TODO comment 
     28 * Implements training following the LASER classification scheme. 
    3029 * </p> 
    3130 *  
    … …  
    3433public class WekaLASERTraining extends WekaBaseTraining implements ITrainingStrategy { 
    3534 
     35    /** 
     36     * Internal classifier used for LASER. 
     37     */ 
    3638    private final LASERClassifier internalClassifier = new LASERClassifier(); 
    3739 
     40    /* 
     41     * (non-Javadoc) 
     42     *  
     43     * @see de.ugoe.cs.cpdp.training.WekaBaseTraining#getClassifier() 
     44     */ 
    3845    @Override 
    3946    public Classifier getClassifier() { 
    … …  
    4148    } 
    4249 
     50    /* 
     51     * (non-Javadoc) 
     52     *  
     53     * @see de.ugoe.cs.cpdp.training.ITrainingStrategy#apply(weka.core.Instances) 
     54     */ 
    4355    @Override 
    4456    public void apply(Instances traindata) { 
    … …  
    5163    } 
    5264 
     65    /** 
     66     * <p> 
     67     * Internal helper class that defines the laser classifier. 
     68     * </p> 
     69     *  
     70     * @author Steffen Herbold 
     71     */ 
    5372    public class LASERClassifier extends AbstractClassifier { 
    5473 
     74        /** 
     75         * Default serial ID. 
     76         */ 
    5577        private static final long serialVersionUID = 1L; 
    56          
     78 
     79        /** 
     80         * Internal reference to the classifier. 
     81         */ 
    5782        private Classifier laserClassifier = null; 
     83 
     84        /** 
     85         * Internal storage of the training data required for NN analysis. 
     86         */ 
    5887        private Instances traindata = null; 
    5988 
     89        /* 
     90         * (non-Javadoc) 
     91         *  
     92         * @see weka.classifiers.AbstractClassifier#classifyInstance(weka.core.Instance) 
     93         */ 
    6094        @Override 
    6195        public double classifyInstance(Instance instance) throws Exception { 
    6296            List<Integer> closestInstances = new LinkedList<>(); 
    6397            double minDistance = Double.MAX_VALUE; 
    64             for( int i=0; i<traindata.size(); i++ ) { 
     98            for (int i = 0; i < traindata.size(); i++) { 
    6599                double distance = WekaUtils.hammingDistance(instance, traindata.get(i)); 
    66                 if( distance<minDistance) { 
     100                if (distance < minDistance) { 
    67101                    minDistance = distance; 
    68102                } 
    69103            } 
    70             for( int i=0; i<traindata.size(); i++ ) { 
     104            for (int i = 0; i < traindata.size(); i++) { 
    71105                double distance = WekaUtils.hammingDistance(instance, traindata.get(i)); 
    72                 if( distance<=minDistance ) { 
     106                if (distance <= minDistance) { 
    73107                    closestInstances.add(i); 
    74108                } 
    75109            } 
    76             if( closestInstances.size()==1 ) { 
     110            if (closestInstances.size() == 1) { 
    77111                int closestIndex = closestInstances.get(0); 
    78112                Instance closestTrainingInstance = traindata.get(closestIndex); 
    79113                List<Integer> closestToTrainingInstance = new LinkedList<>(); 
    80114                double minTrainingDistance = Double.MAX_VALUE; 
    81                 for( int i=0; i<traindata.size(); i++ ) { 
    82                     if( closestIndex!=i ) { 
    83                         double distance = WekaUtils.hammingDistance(closestTrainingInstance, traindata.get(i)); 
    84                         if( distance<minTrainingDistance ) { 
     115                for (int i = 0; i < traindata.size(); i++) { 
     116                    if (closestIndex != i) { 
     117                        double distance = 
     118                            WekaUtils.hammingDistance(closestTrainingInstance, traindata.get(i)); 
     119                        if (distance < minTrainingDistance) { 
    85120                            minTrainingDistance = distance; 
    86121                        } 
    87122                    } 
    88123                } 
    89                 for( int i=0; i<traindata.size(); i++ ) { 
    90                     if( closestIndex!=i ) { 
    91                         double distance = WekaUtils.hammingDistance(closestTrainingInstance, traindata.get(i)); 
    92                         if( distance<=minTrainingDistance ) { 
     124                for (int i = 0; i < traindata.size(); i++) { 
     125                    if (closestIndex != i) { 
     126                        double distance = 
     127                            WekaUtils.hammingDistance(closestTrainingInstance, traindata.get(i)); 
     128                        if (distance <= minTrainingDistance) { 
    93129                            closestToTrainingInstance.add(i); 
    94130                        } 
    95131                    } 
    96132                } 
    97                 if( closestToTrainingInstance.size()==1 ) { 
     133                if (closestToTrainingInstance.size() == 1) { 
    98134                    return laserClassifier.classifyInstance(instance); 
    99135                } 
    … …  
    101137                    double label = Double.NaN; 
    102138                    boolean allEqual = true; 
    103                     for( Integer index : closestToTrainingInstance ) { 
    104                         if( Double.isNaN(label) ) { 
     139                    for (Integer index : closestToTrainingInstance) { 
     140                        if (Double.isNaN(label)) { 
    105141                            label = traindata.get(index).classValue(); 
    106142                        } 
    107                         else if( label!=traindata.get(index).classValue() ) { 
     143                        else if (label != traindata.get(index).classValue()) { 
    108144                            allEqual = false; 
    109145                            break; 
    110146                        } 
    111147                    } 
    112                     if( allEqual ) { 
     148                    if (allEqual) { 
    113149                        return label; 
    114150                    } 
    … …  
    117153                    } 
    118154                } 
    119             } else { 
     155            } 
     156            else { 
    120157                double label = Double.NaN; 
    121158                boolean allEqual = true; 
    122                 for( Integer index : closestInstances ) { 
    123                     if( Double.isNaN(label) ) { 
     159                for (Integer index : closestInstances) { 
     160                    if (Double.isNaN(label)) { 
    124161                        label = traindata.get(index).classValue(); 
    125162                    } 
    126                     else if( label!=traindata.get(index).classValue() ) { 
     163                    else if (label != traindata.get(index).classValue()) { 
    127164                        allEqual = false; 
    128165                        break; 
    129166                    } 
    130167                } 
    131                 if( allEqual ) { 
     168                if (allEqual) { 
    132169                    return label; 
    133170                } 
    … …  
    138175        } 
    139176 
     177        /* 
     178         * (non-Javadoc) 
     179         *  
     180         * @see weka.classifiers.Classifier#buildClassifier(weka.core.Instances) 
     181         */ 
    140182        @Override 
    141183        public void buildClassifier(Instances traindata) throws Exception { 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/training/WekaLocalEMTraining.java

    r99 r135  
    3333 
    3434/** 
    35  * WekaLocalEMTraining 
     35 * <p> 
     36 * Local Trainer with EM Clustering for data partitioning. Currently supports only EM Clustering. 
     37 * </p> 
     38 * <ol> 
     39 * <li>Cluster training data</li> 
     40 * <li>for each cluster train a classifier with training data from cluster</li> 
     41 * <li>match test data instance to a cluster, then classify with classifier from the cluster</li> 
     42 * </ol> 
    3643 *  
    37  * Local Trainer with EM Clustering for data partitioning. Currently supports only EM Clustering. 
     44 * XML configuration: 
    3845 *  
    39  * 1. Cluster training data 2. for each cluster train a classifier with training data from cluster 
    40  * 3. match test data instance to a cluster, then classify with classifier from the cluster 
    41  *  
    42  * XML configuration: <!-- because of clustering --> <preprocessor name="Normalization" param=""/> 
    43  *  
    44  * <!-- cluster trainer --> <trainer name="WekaLocalEMTraining" 
    45  * param="NaiveBayes weka.classifiers.bayes.NaiveBayes" /> 
     46 * <pre> 
     47 * {@code 
     48 * <trainer name="WekaLocalEMTraining" param="NaiveBayes weka.classifiers.bayes.NaiveBayes" /> 
     49 * } 
     50 * </pre> 
    4651 */ 
    4752public class WekaLocalEMTraining extends WekaBaseTraining implements ITrainingStrategy { 
    4853 
     54    /** 
     55     * the classifier 
     56     */ 
    4957    private final TraindatasetCluster classifier = new TraindatasetCluster(); 
    5058 
     59    /* 
     60     * (non-Javadoc) 
     61     *  
     62     * @see de.ugoe.cs.cpdp.training.WekaBaseTraining#getClassifier() 
     63     */ 
    5164    @Override 
    5265    public Classifier getClassifier() { 
    … …  
    5467    } 
    5568 
     69    /* 
     70     * (non-Javadoc) 
     71     *  
     72     * @see de.ugoe.cs.cpdp.training.ITrainingStrategy#apply(weka.core.Instances) 
     73     */ 
    5674    @Override 
    5775    public void apply(Instances traindata) { 
    … …  
    6482    } 
    6583 
     84    /** 
     85     * <p> 
     86     * Weka classifier for the local model with EM clustering. 
     87     * </p> 
     88     *  
     89     * @author Alexander Trautsch 
     90     */ 
    6691    public class TraindatasetCluster extends AbstractClassifier { 
    6792 
     93        /** 
     94         * default serializtion ID 
     95         */ 
    6896        private static final long serialVersionUID = 1L; 
    6997 
     98        /** 
     99         * EM clusterer used 
     100         */ 
    70101        private EM clusterer = null; 
    71102 
     103        /** 
     104         * classifiers for each cluster 
     105         */ 
    72106        private HashMap<Integer, Classifier> cclassifier; 
     107 
     108        /** 
     109         * training data for each cluster 
     110         */ 
    73111        private HashMap<Integer, Instances> ctraindata; 
    74112 
    … …  
    107145        } 
    108146 
     147        /* 
     148         * (non-Javadoc) 
     149         *  
     150         * @see weka.classifiers.AbstractClassifier#classifyInstance(weka.core.Instance) 
     151         */ 
    109152        @Override 
    110153        public double classifyInstance(Instance instance) { 
    … …  
    139182        } 
    140183 
     184        /* 
     185         * (non-Javadoc) 
     186         *  
     187         * @see weka.classifiers.Classifier#buildClassifier(weka.core.Instances) 
     188         */ 
    141189        @Override 
    142190        public void buildClassifier(Instances traindata) throws Exception { 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/training/WekaLocalFQTraining.java

    r99 r135  
    3535 
    3636/** 
     37 * <p> 
    3738 * Trainer with reimplementation of WHERE clustering algorithm from: Tim Menzies, Andrew Butcher, 
    3839 * David Cok, Andrian Marcus, Lucas Layman, Forrest Shull, Burak Turhan, Thomas Zimmermann, 
    3940 * "Local versus Global Lessons for Defect Prediction and Effort Estimation," IEEE Transactions on 
    4041 * Software Engineering, vol. 39, no. 6, pp. 822-834, June, 2013 
    41  *  
    42  * With WekaLocalFQTraining we do the following: 1) Run the Fastmap algorithm on all training data, 
    43  * let it calculate the 2 most significant dimensions and projections of each instance to these 
    44  * dimensions 2) With these 2 dimensions we span a QuadTree which gets recursively split on 
    45  * median(x) and median(y) values. 3) We cluster the QuadTree nodes together if they have similar 
    46  * density (50%) 4) We save the clusters and their training data 5) We only use clusters with > 
    47  * ALPHA instances (currently Math.sqrt(SIZE)), rest is discarded with the training data of this 
    48  * cluster 6) We train a Weka classifier for each cluster with the clusters training data 7) We 
    49  * recalculate Fastmap distances for a single instance with the old pivots and then try to find a 
    50  * cluster containing the coords of the instance. 7.1.) If we can not find a cluster (due to coords 
    51  * outside of all clusters) we find the nearest cluster. 8) We classify the Instance with the 
    52  * classifier and traindata from the Cluster we found in 7. 
     42 * </p> 
     43 * <p> 
     44 * With WekaLocalFQTraining we do the following: 
     45 * <ol> 
     46 * <li>Run the Fastmap algorithm on all training data, let it calculate the 2 most significant 
     47 * dimensions and projections of each instance to these dimensions</li> 
     48 * <li>With these 2 dimensions we span a QuadTree which gets recursively split on median(x) and 
     49 * median(y) values.</li> 
     50 * <li>We cluster the QuadTree nodes together if they have similar density (50%)</li> 
     51 * <li>We save the clusters and their training data</li> 
     52 * <li>We only use clusters with > ALPHA instances (currently Math.sqrt(SIZE)), the rest is 
     53 * discarded with the training data of this cluster</li> 
     54 * <li>We train a Weka classifier for each cluster with the clusters training data</li> 
     55 * <li>We recalculate Fastmap distances for a single instance with the old pivots and then try to 
     56 * find a cluster containing the coords of the instance. If we can not find a cluster (due to coords 
     57 * outside of all clusters) we find the nearest cluster.</li> 
     58 * <li>We classify the Instance with the classifier and traindata from the Cluster we found in 7. 
     59 * </li> 
     60 * </p> 
    5361 */ 
    5462public class WekaLocalFQTraining extends WekaBaseTraining implements ITrainingStrategy { 
    5563 
     64    /** 
     65     * the classifier 
     66     */ 
    5667    private final TraindatasetCluster classifier = new TraindatasetCluster(); 
    5768 
     69    /* 
     70     * (non-Javadoc) 
     71     *  
     72     * @see de.ugoe.cs.cpdp.training.WekaBaseTraining#getClassifier() 
     73     */ 
    5874    @Override 
    5975    public Classifier getClassifier() { 
    … …  
    6177    } 
    6278 
     79    /* 
     80     * (non-Javadoc) 
     81     *  
     82     * @see de.ugoe.cs.cpdp.training.ITrainingStrategy#apply(weka.core.Instances) 
     83     */ 
    6384    @Override 
    6485    public void apply(Instances traindata) { 
    … …  
    7192    } 
    7293 
     94    /** 
     95     * <p> 
     96     * Weka classifier for the local model with WHERE clustering 
     97     * </p> 
     98     *  
     99     * @author Alexander Trautsch 
     100     */ 
    73101    public class TraindatasetCluster extends AbstractClassifier { 
    74102 
     103        /** 
     104         * default serialization ID 
     105         */ 
    75106        private static final long serialVersionUID = 1L; 
    76107 
    77         /* classifier per cluster */ 
     108        /** 
     109         * classifiers for each cluster 
     110         */ 
    78111        private HashMap<Integer, Classifier> cclassifier; 
    79112 
    80         /* instances per cluster */ 
     113        /** 
     114         * training data for each cluster 
     115         */ 
    81116        private HashMap<Integer, Instances> ctraindata; 
    82117 
    83         /* 
     118        /** 
    84119         * holds the instances and indices of the pivot objects of the Fastmap calculation in 
    85120         * buildClassifier 
    … …  
    87122        private HashMap<Integer, Instance> cpivots; 
    88123 
    89         /* holds the indices of the pivot objects for x,y and the dimension [x,y][dimension] */ 
     124        /** 
     125         * holds the indices of the pivot objects for x,y and the dimension [x,y][dimension] 
     126         */ 
    90127        private int[][] cpivotindices; 
    91128 
    92         /* holds the sizes of the cluster multiple "boxes" per cluster */ 
     129        /** 
     130         * holds the sizes of the cluster multiple "boxes" per cluster 
     131         */ 
    93132        private HashMap<Integer, ArrayList<Double[][]>> csize; 
    94133 
    95         /* debug vars */ 
     134        /** 
     135         * debug variable 
     136         */ 
    96137        @SuppressWarnings("unused") 
    97138        private boolean show_biggest = true; 
    98139 
     140        /** 
     141         * debug variable 
     142         */ 
    99143        @SuppressWarnings("unused") 
    100144        private int CFOUND = 0; 
     145 
     146        /** 
     147         * debug variable 
     148         */ 
    101149        @SuppressWarnings("unused") 
    102150        private int CNOTFOUND = 0; 
    103151 
     152        /** 
     153         * <p> 
     154         * copies an instance such that is is compatible with the local model 
     155         * </p> 
     156         * 
     157         * @param instances 
     158         *            instance format 
     159         * @param instance 
     160         *            instance that is copied 
     161         * @return 
     162         */ 
    104163        private Instance createInstance(Instances instances, Instance instance) { 
    105164            // attributes for feeding instance to classifier 
    … …  
    127186 
    128187        /** 
     188         * <p> 
    129189         * Because Fastmap saves only the image not the values of the attributes it used we can not 
    130190         * use the old data directly to classify single instances to clusters. 
     191         * </p> 
     192         * <p> 
     193         * To classify a single instance we do a new Fastmap computation with only the instance and 
     194         * the old pivot elements. 
     195         * </p> 
     196         * </p> 
     197         * After that we find the cluster with our Fastmap result for x and y. 
     198         * </p> 
    131199         *  
    132          * To classify a single instance we do a new fastmap computation with only the instance and 
    133          * the old pivot elements. 
    134          *  
    135          * After that we find the cluster with our fastmap result for x and y. 
     200         * @param instance 
     201         *            instance that is classified 
     202         * @see weka.classifiers.AbstractClassifier#classifyInstance(weka.core.Instance) 
    136203         */ 
    137204        @Override 
    … …  
    169236                double[][] distmat = new double[2 * FMAP.target_dims + 1][2 * FMAP.target_dims + 1]; 
    170237                distmat[0][0] = 0; 
    171                 distmat[0][1] = 
    172                     dist.distance(clusterInstance, 
    173                                   this.cpivots.get((Integer) this.cpivotindices[0][0])); 
    174                 distmat[0][2] = 
    175                     dist.distance(clusterInstance, 
    176                                   this.cpivots.get((Integer) this.cpivotindices[1][0])); 
    177                 distmat[0][3] = 
    178                     dist.distance(clusterInstance, 
    179                                   this.cpivots.get((Integer) this.cpivotindices[0][1])); 
    180                 distmat[0][4] = 
    181                     dist.distance(clusterInstance, 
    182                                   this.cpivots.get((Integer) this.cpivotindices[1][1])); 
    183  
    184                 distmat[1][0] = 
    185                     dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][0]), 
    186                                   clusterInstance); 
     238                distmat[0][1] = dist.distance(clusterInstance, 
     239                                              this.cpivots.get((Integer) this.cpivotindices[0][0])); 
     240                distmat[0][2] = dist.distance(clusterInstance, 
     241                                              this.cpivots.get((Integer) this.cpivotindices[1][0])); 
     242                distmat[0][3] = dist.distance(clusterInstance, 
     243                                              this.cpivots.get((Integer) this.cpivotindices[0][1])); 
     244                distmat[0][4] = dist.distance(clusterInstance, 
     245                                              this.cpivots.get((Integer) this.cpivotindices[1][1])); 
     246 
     247                distmat[1][0] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][0]), 
     248                                              clusterInstance); 
    187249                distmat[1][1] = 0; 
    188                 distmat[1][2] = 
    189                     dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][0]), 
    190                                   this.cpivots.get((Integer) this.cpivotindices[1][0])); 
    191                 distmat[1][3] = 
    192                     dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][0]), 
    193                                   this.cpivots.get((Integer) this.cpivotindices[0][1])); 
    194                 distmat[1][4] = 
    195                     dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][0]), 
    196                                   this.cpivots.get((Integer) this.cpivotindices[1][1])); 
    197  
    198                 distmat[2][0] = 
    199                     dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][0]), 
    200                                   clusterInstance); 
    201                 distmat[2][1] = 
    202                     dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][0]), 
    203                                   this.cpivots.get((Integer) this.cpivotindices[0][0])); 
     250                distmat[1][2] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][0]), 
     251                                              this.cpivots.get((Integer) this.cpivotindices[1][0])); 
     252                distmat[1][3] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][0]), 
     253                                              this.cpivots.get((Integer) this.cpivotindices[0][1])); 
     254                distmat[1][4] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][0]), 
     255                                              this.cpivots.get((Integer) this.cpivotindices[1][1])); 
     256 
     257                distmat[2][0] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][0]), 
     258                                              clusterInstance); 
     259                distmat[2][1] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][0]), 
     260                                              this.cpivots.get((Integer) this.cpivotindices[0][0])); 
    204261                distmat[2][2] = 0; 
    205                 distmat[2][3] = 
    206                     dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][0]), 
    207                                   this.cpivots.get((Integer) this.cpivotindices[0][1])); 
    208                 distmat[2][4] = 
    209                     dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][0]), 
    210                                   this.cpivots.get((Integer) this.cpivotindices[1][1])); 
    211  
    212                 distmat[3][0] = 
    213                     dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][1]), 
    214                                   clusterInstance); 
    215                 distmat[3][1] = 
    216                     dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][1]), 
    217                                   this.cpivots.get((Integer) this.cpivotindices[0][0])); 
    218                 distmat[3][2] = 
    219                     dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][1]), 
    220                                   this.cpivots.get((Integer) this.cpivotindices[1][0])); 
     262                distmat[2][3] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][0]), 
     263                                              this.cpivots.get((Integer) this.cpivotindices[0][1])); 
     264                distmat[2][4] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][0]), 
     265                                              this.cpivots.get((Integer) this.cpivotindices[1][1])); 
     266 
     267                distmat[3][0] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][1]), 
     268                                              clusterInstance); 
     269                distmat[3][1] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][1]), 
     270                                              this.cpivots.get((Integer) this.cpivotindices[0][0])); 
     271                distmat[3][2] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][1]), 
     272                                              this.cpivots.get((Integer) this.cpivotindices[1][0])); 
    221273                distmat[3][3] = 0; 
    222                 distmat[3][4] = 
    223                     dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][1]), 
    224                                   this.cpivots.get((Integer) this.cpivotindices[1][1])); 
    225  
    226                 distmat[4][0] = 
    227                     dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][1]), 
    228                                   clusterInstance); 
    229                 distmat[4][1] = 
    230                     dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][1]), 
    231                                   this.cpivots.get((Integer) this.cpivotindices[0][0])); 
    232                 distmat[4][2] = 
    233                     dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][1]), 
    234                                   this.cpivots.get((Integer) this.cpivotindices[1][0])); 
    235                 distmat[4][3] = 
    236                     dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][1]), 
    237                                   this.cpivots.get((Integer) this.cpivotindices[0][1])); 
     274                distmat[3][4] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][1]), 
     275                                              this.cpivots.get((Integer) this.cpivotindices[1][1])); 
     276 
     277                distmat[4][0] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][1]), 
     278                                              clusterInstance); 
     279                distmat[4][1] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][1]), 
     280                                              this.cpivots.get((Integer) this.cpivotindices[0][0])); 
     281                distmat[4][2] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][1]), 
     282                                              this.cpivots.get((Integer) this.cpivotindices[1][0])); 
     283                distmat[4][3] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][1]), 
     284                                              this.cpivots.get((Integer) this.cpivotindices[0][1])); 
    238285                distmat[4][4] = 0; 
    239286 
    … …  
    243290                 * distmat[0].length; j++) { if(biggest < distmat[i][j]) { biggest = distmat[i][j]; 
    244291                 * } } } if(this.show_biggest) { Console.traceln(Level.INFO, 
    245                  * String.format(""+clusterInstance)); Console.traceln(Level.INFO, 
    246                  * String.format("biggest distances: "+ biggest)); this.show_biggest = false; } 
     292                 * String.format(""+clusterInstance)); Console.traceln(Level.INFO, String.format( 
     293                 * "biggest distances: "+ biggest)); this.show_biggest = false; } 
    247294                 */ 
    248295 
    … …  
    316363                        cnumber = clusternumber.next(); 
    317364                        for (int i = 0; i < ctraindata.get(cnumber).size(); i++) { 
    318                             if (dist.distance(instance, ctraindata.get(cnumber).get(i)) <= min_distance) 
     365                            if (dist.distance(instance, 
     366                                              ctraindata.get(cnumber).get(i)) <= min_distance) 
    319367                            { 
    320368                                found_cnumber = cnumber; 
    … …  
    347395        } 
    348396 
     397        /* 
     398         * (non-Javadoc) 
     399         *  
     400         * @see weka.classifiers.Classifier#buildClassifier(weka.core.Instances) 
     401         */ 
    349402        @Override 
    350403        public void buildClassifier(Instances traindata) throws Exception { 
    … …  
    421474 
    422475            // Console.traceln(Level.INFO, 
    423             // String.format("size for cluster ("+small[0]+","+small[1]+") - ("+big[0]+","+big[1]+")")); 
     476            // String.format("size for cluster ("+small[0]+","+small[1]+") - 
     477            // ("+big[0]+","+big[1]+")")); 
    424478 
    425479            // 5. generate quadtree 
    … …  
    439493 
    440494            // recursive split und grid clustering eher static 
    441             TREE.recursiveSplit(TREE); 
     495            QuadTree.recursiveSplit(TREE); 
    442496 
    443497            // generate list of nodes sorted by density (childs only) 
    … …  
    465519                } 
    466520                else { 
    467                     Console.traceln(Level.INFO, 
    468                                     String.format("drop cluster, only: " + current.size() + 
    469                                         " instances")); 
     521                    Console.traceln(Level.INFO, String 
     522                        .format("drop cluster, only: " + current.size() + " instances")); 
    470523                } 
    471524            } 
    … …  
    505558                // traindata_count += ctraindata.get(cnumber).size(); 
    506559                // Console.traceln(Level.INFO, 
    507                 // String.format("building classifier in cluster "+cnumber +"  with "+ 
     560                // String.format("building classifier in cluster "+cnumber +" with "+ 
    508561                // ctraindata.get(cnumber).size() +" traindata instances")); 
    509562            } 
    … …  
    516569 
    517570    /** 
    518      * Payload for the QuadTree. x and y are the calculated Fastmap values. T is a weka instance. 
     571     * <p> 
     572     * Payload for the QuadTree. x and y are the calculated Fastmap values. T is a Weka instance. 
     573     * </p> 
     574     *  
     575     * @author Alexander Trautsch 
    519576     */ 
    520577    public class QuadTreePayload<T> { 
    521578 
    522         public double x; 
    523         public double y; 
     579        /** 
     580         * x-value 
     581         */ 
     582        public final double x; 
     583 
     584        /** 
     585         * y-value 
     586         */ 
     587        public final double y; 
     588 
     589        /** 
     590         * associated instance 
     591         */ 
    524592        private T inst; 
    525593 
     594        /** 
     595         * <p> 
     596         * Constructor. Creates the payload. 
     597         * </p> 
     598         * 
     599         * @param x 
     600         *            x-value 
     601         * @param y 
     602         *            y-value 
     603         * @param value 
     604         *            associated instace 
     605         */ 
    526606        public QuadTreePayload(double x, double y, T value) { 
    527607            this.x = x; 
    … …  
    530610        } 
    531611 
     612        /** 
     613         * <p> 
     614         * returns the instance 
     615         * </p> 
     616         * 
     617         * @return 
     618         */ 
    532619        public T getInst() { 
    533620            return this.inst; 
    … …  
    536623 
    537624    /** 
    538      * Fastmap implementation 
    539      *  
    540      * Faloutsos, C., & Lin, K. I. (1995). FastMap: A fast algorithm for indexing, data-mining and 
     625     * <p> 
     626     * Fastmap implementation after:<br> 
     627     * * Faloutsos, C., & Lin, K. I. (1995). FastMap: A fast algorithm for indexing, data-mining and 
    541628     * visualization of traditional and multimedia datasets (Vol. 24, No. 2, pp. 163-174). ACM. 
     629     * </p> 
    542630     */ 
    543631    public class Fastmap { 
    544632 
    545         /* N x k Array, at the end, the i-th row will be the image of the i-th object */ 
     633        /** 
     634         * N x k Array, at the end, the i-th row will be the image of the i-th object 
     635         */ 
    546636        private double[][] X; 
    547637 
    548         /* 2 x k pivot Array one pair per recursive call */ 
     638        /** 
     639         * 2 x k pivot Array one pair per recursive call 
     640         */ 
    549641        private int[][] PA; 
    550642 
    551         /* Objects we got (distance matrix) */ 
     643        /** 
     644         * Objects we got (distance matrix) 
     645         */ 
    552646        private double[][] O; 
    553647 
    554         /* column of X currently updated (also the dimension) */ 
     648        /** 
     649         * column of X currently updated (also the dimension) 
     650         */ 
    555651        private int col = 0; 
    556652 
    557         /* number of dimensions we want */ 
     653        /** 
     654         * number of dimensions we want 
     655         */ 
    558656        private int target_dims = 0; 
    559657 
    560         // if we already have the pivot elements 
     658        /** 
     659         * if we already have the pivot elements 
     660         */ 
    561661        private boolean pivot_set = false; 
    562662 
     663        /** 
     664         * <p> 
     665         * Constructor. Creates a new Fastmap object. 
     666         * </p> 
     667         * 
     668         * @param k 
     669         */ 
    563670        public Fastmap(int k) { 
    564671            this.target_dims = k; 
    … …  
    566673 
    567674        /** 
    568          * Sets the distance matrix and params that depend on this 
     675         * <p> 
     676         * Sets the distance matrix and params that depend on this. 
     677         * </p> 
    569678         *  
    570679         * @param O 
     680         *            distance matrix 
    571681         */ 
    572682        public void setDistmat(double[][] O) { 
    … …  
    578688 
    579689        /** 
     690         * <p> 
    580691         * Set pivot elements, we need that to classify instances after the calculation is complete 
    581692         * (because we then want to reuse only the pivot elements). 
     693         * </p> 
    582694         *  
    583695         * @param pi 
     696         *            the pivots 
    584697         */ 
    585698        public void setPivots(int[][] pi) { 
    … …  
    589702 
    590703        /** 
     704         * <p> 
    591705         * Return the pivot elements that were chosen during the calculation 
     706         * </p> 
    592707         *  
    593          * @return 
     708         * @return the pivots 
    594709         */ 
    595710        public int[][] getPivots() { 
    … …  
    598713 
    599714        /** 
    600          * The distance function for euclidean distance 
    601          *  
    602          * Acts according to equation 4 of the fastmap paper 
     715         * <p> 
     716         * The distance function for euclidean distance. Acts according to equation 4 of the Fastmap 
     717         * paper. 
     718         * </p> 
    603719         *  
    604720         * @param x 
    … …  
    606722         * @param y 
    607723         *            y index of y image (if k==0 y object) 
    608          * @param kdimensionality 
    609          * @return distance 
     724         * @param k 
     725         *            dimensionality 
     726         * @return the distance 
    610727         */ 
    611728        private double dist(int x, int y, int k) { 
    … …  
    624741 
    625742        /** 
    626          * Find the object farthest from the given index This method is a helper Method for 
    627          * findDistandObjects 
     743         * <p> 
     744         * Find the object farthest from the given index. This method is a helper Method for 
     745         * findDistandObjects. 
     746         * </p> 
    628747         *  
    629748         * @param index 
    … …  
    646765 
    647766        /** 
    648          * Finds the pivot objects 
     767         * <p> 
     768         * Finds the pivot objects. This method is basically algorithm 1 of the Fastmap paper. 
     769         * </p> 
    649770         *  
    650          * This method is basically algorithm 1 of the fastmap paper. 
    651          *  
    652          * @return 2 indexes of the choosen pivot objects 
     771         * @return 2 indexes of the chosen pivot objects 
    653772         */ 
    654773        private int[] findDistantObjects() { 
    … …  
    668787 
    669788        /** 
    670          * Calculates the new k-vector values (projections) 
    671          *  
    672          * This is basically algorithm 2 of the fastmap paper. We just added the possibility to 
    673          * pre-set the pivot elements because we need to classify single instances after the 
    674          * computation is already done. 
    675          *  
    676          * @param dims 
    677          *            dimensionality 
     789         * <p> 
     790         * Calculates the new k-vector values (projections) This is basically algorithm 2 of the 
     791         * fastmap paper. We just added the possibility to pre-set the pivot elements because we 
     792         * need to classify single instances after the computation is already done. 
     793         * </p> 
    678794         */ 
    679795        public void calculate() { 
    … …  
    713829 
    714830        /** 
     831         * <p> 
    715832         * returns the result matrix of the projections 
     833         * </p> 
    716834         *  
    717835         * @return calculated result 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/training/WekaTestAwareTraining.java

    r99 r135  
    2222import weka.core.Instances; 
    2323 
    24 // TODO comment 
     24/** 
     25 * <p> 
     26 * Trainer that allows classifiers access to the training data. Classifiers need to make sure that 
     27 * they do not use the classification. 
     28 * </p> 
     29 *  
     30 * @author Steffen Herbold 
     31 */ 
    2532public class WekaTestAwareTraining extends WekaBaseTraining implements ITestAwareTrainingStrategy { 
    2633 
     34    /* 
     35     * (non-Javadoc) 
     36     *  
     37     * @see de.ugoe.cs.cpdp.training.ITestAwareTrainingStrategy#apply(weka.core.Instances, 
     38     * weka.core.Instances) 
     39     */ 
    2740    @Override 
    2841    public void apply(Instances testdata, Instances traindata) { 
    2942        classifier = setupClassifier(); 
    30         if( !(classifier instanceof ITestAwareClassifier) ) { 
     43        if (!(classifier instanceof ITestAwareClassifier)) { 
    3144            throw new RuntimeException("classifier must implement the ITestAwareClassifier interface in order to be used as TestAwareTrainingStrategy"); 
    3245        } 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/training/WekaTraining.java

    r99 r135  
    2222 
    2323/** 
    24  * Programmatic WekaTraining 
    25  *  
    26  * first parameter is Trainer Name. second parameter is class name 
    27  *  
    28  * all subsequent parameters are configuration params (for example for trees) Cross Validation 
    29  * params always come last and are prepended with -CVPARAM 
    30  *  
    31  * XML Configurations for Weka Classifiers: 
    32  *  
     24 * <p> 
     25 * The first parameter is the trainer name, second parameter is class name. All subsequent 
     26 * parameters are configuration parameters of the algorithms. Cross validation parameters always 
     27 * come last and are prepended with -CVPARAM 
     28 * </p> 
     29 * XML Configurations for Weka Classifiers:  
    3330 * <pre> 
    3431 * {@code 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/util/SortUtils.java

    r61 r135  
     1 
    12package de.ugoe.cs.cpdp.util; 
    23 
     4/** 
     5 * <p> 
     6 * Utility functions for sorting. 
     7 * </p> 
     8 *  
     9 * @author Steffen Herbold 
     10 */ 
    311public class SortUtils { 
    412 
     13    /** 
     14     * <p> 
     15     * Implements a quick sort that sorts an index set together with the array. 
     16     * </p> 
     17     * 
     18     * @param main 
     19     *            the array that is sorted 
     20     * @param index 
     21     *            the index set for the array 
     22     */ 
    523    public static <T extends Comparable<T>> void quicksort(T[] main, int[] index) { 
    624        quicksort(main, index, 0, index.length - 1, false); 
    725    } 
    8      
    9     public static <T extends Comparable<T>> void quicksort(T[] main, int[] index, boolean descending) { 
     26 
     27    /** 
     28     * <p> 
     29     * Implements a quick sort that sorts an index set together with the array. 
     30     * </p> 
     31     * 
     32     * @param main 
     33     *            the array that is sorted 
     34     * @param index 
     35     *            the index set for the array 
     36     * @param descending 
     37     *            defines the sorting order 
     38     */ 
     39    public static <T extends Comparable<T>> void quicksort(T[] main, 
     40                                                           int[] index, 
     41                                                           boolean descending) 
     42    { 
    1043        quicksort(main, index, 0, index.length - 1, descending); 
    1144    } 
    1245 
    13     // quicksort a[left] to a[right] 
    14     private static <T extends Comparable<T>> void quicksort(T[] a, int[] index, int left, int right, boolean descending) { 
     46    /** 
     47     * <p> 
     48     * internal quicksort implementation 
     49     * </p> 
     50     * 
     51     * @param main 
     52     *            the array that is sorted 
     53     * @param index 
     54     *            the index set for the array 
     55     * @param left 
     56     *            defines the current partition 
     57     * @param right 
     58     *            defines the current partition 
     59     * @param descending 
     60     *            defines the sorting order 
     61     */ 
     62    private static <T extends Comparable<T>> void quicksort(T[] main, 
     63                                                            int[] index, 
     64                                                            int left, 
     65                                                            int right, 
     66                                                            boolean descending) 
     67    { 
    1568        if (right <= left) 
    1669            return; 
    17         int i = partition(a, index, left, right, descending); 
    18         quicksort(a, index, left, i - 1, descending); 
    19         quicksort(a, index, i + 1, right, descending); 
     70        int i = partition(main, index, left, right, descending); 
     71        quicksort(main, index, left, i - 1, descending); 
     72        quicksort(main, index, i + 1, right, descending); 
    2073    } 
    2174 
    22     // partition a[left] to a[right], assumes left < right 
    23     private static <T extends Comparable<T>> int partition(T[] a, int[] index, int left, int right, boolean descending) { 
     75    /** 
     76     * <p> 
     77     * internal partitioning of the quicksort implementation 
     78     * </p> 
     79     * 
     80     * @param main 
     81     *            the array that is sorted 
     82     * @param index 
     83     *            the index set for the array 
     84     * @param left 
     85     *            defines the current partition 
     86     * @param right 
     87     *            defines the current partition 
     88     * @param descending 
     89     *            defines the sorting order 
     90     */ 
     91    private static <T extends Comparable<T>> int partition(T[] main, 
     92                                                           int[] index, 
     93                                                           int left, 
     94                                                           int right, 
     95                                                           boolean descending) 
     96    { 
    2497        int i = left - 1; 
    2598        int j = right; 
    2699        while (true) { 
    27             while (compare(a[++i], a[right], descending)) // find item on left to swap 
     100            while (compare(main[++i], main[right], descending)) // find item on left to swap 
    28101            ; // a[right] acts as sentinel 
    29             while (compare(a[right], a[--j], descending)) // find item on right to swap 
     102            while (compare(main[right], main[--j], descending)) // find item on right to swap 
    30103                if (j == left) 
    31104                    break; // don't go out-of-bounds 
    32105            if (i >= j) 
    33106                break; // check if pointers cross 
    34             exch(a, index, i, j); // swap two elements into place 
     107            swap(main, index, i, j); // swap two elements into place 
    35108        } 
    36         exch(a, index, i, right); // swap with partition element 
     109        swap(main, index, i, right); // swap with partition element 
    37110        return i; 
    38111    } 
    39112 
    40     // is x < y ? 
     113    /** 
     114     * <p> 
     115     * helper function for comparator evaluation 
     116     * </p> 
     117     * 
     118     * @param x 
     119     *            first element that is compared 
     120     * @param y 
     121     *            second element that is compared 
     122     * @param descending 
     123     *            defines the sorting order 
     124     * @return true if x is larger than y and descending is true or y is larger than x and 
     125     *         descending is false 
     126     */ 
    41127    private static <T extends Comparable<T>> boolean compare(T x, T y, boolean descending) { 
    42         if( descending ) { 
    43             return x.compareTo(y)>0; 
    44         } else { 
    45             return x.compareTo(y)<0; 
     128        if (descending) { 
     129            return x.compareTo(y) > 0; 
     130        } 
     131        else { 
     132            return x.compareTo(y) < 0; 
    46133        } 
    47134    } 
    48135 
    49     // exchange a[i] and a[j] 
    50     private static <T extends Comparable<T>> void exch(T[] a, int[] index, int i, int j) { 
    51         T swap = a[i]; 
    52         a[i] = a[j]; 
    53         a[j] = swap; 
     136    /** 
     137     * <p> 
     138     * swaps to elements 
     139     * </p> 
     140     * 
     141     * @param main 
     142     *            the array that is sorted 
     143     * @param index 
     144     *            the index set for the array 
     145     * @param i 
     146     *            index of the first element 
     147     * @param j 
     148     *            index of the second element 
     149     */ 
     150    private static <T extends Comparable<T>> void swap(T[] main, int[] index, int i, int j) { 
     151        T tmp = main[i]; 
     152        main[i] = main[j]; 
     153        main[j] = tmp; 
    54154        int b = index[i]; 
    55155        index[i] = index[j]; 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/util/WekaUtils.java

    r129 r135  
    1515package de.ugoe.cs.cpdp.util; 
    1616 
    17 // TODO comment 
    1817import org.apache.commons.math3.ml.distance.EuclideanDistance; 
    1918 
    … …  
    2120import weka.core.Instances; 
    2221 
     22/** 
     23 * <p> 
     24 * Collections of helper functions to work with Weka. 
     25 * </p> 
     26 *  
     27 * @author Steffen Herbold 
     28 */ 
    2329public class WekaUtils { 
    2430 
     31    /** 
     32     * <p> 
     33     * Data class for distance between instances within a data set based on their distributional 
     34     * characteristics. 
     35     * </p> 
     36     *  
     37     * @author Steffen Herbold 
     38     */ 
    2539    public static class DistChar { 
    2640        public final double mean; 
    … …  
    2943        public final double max; 
    3044        public final int num; 
     45 
    3146        private DistChar(double mean, double std, double min, double max, int num) { 
    3247            this.mean = mean; 
    … …  
    3752        } 
    3853    } 
    39      
     54 
    4055    /** 
    4156     * Scaling value that moves the decimal point by 5 digets. 
    4257     */ 
    4358    public final static double SCALER = 10000.0d; 
    44      
     59 
    4560    /** 
    4661     * <p> 
    … …  
    6681        return distance; 
    6782    } 
    68      
     83 
     84    /** 
     85     * <p> 
     86     * Returns a double array of the values without the classification. 
     87     * </p> 
     88     * 
     89     * @param instance 
     90     *            the instance 
     91     * @return double array 
     92     */ 
    6993    public static double[] instanceValues(Instance instance) { 
    70         double[] values = new double[instance.numAttributes()-1]; 
    71         int k=0;  
    72         for( int j=0; j<instance.numAttributes() ; j++ ) { 
    73             if( j!= instance.classIndex() ) { 
     94        double[] values = new double[instance.numAttributes() - 1]; 
     95        int k = 0; 
     96        for (int j = 0; j < instance.numAttributes(); j++) { 
     97            if (j != instance.classIndex()) { 
    7498                values[k] = instance.value(j); 
    7599                k++; 
    … …  
    78102        return values; 
    79103    } 
    80      
     104 
     105    /** 
     106     * <p> 
     107     * Calculates the distributional characteristics of the distances the instances within a data 
     108     * set have to each other. 
     109     * </p> 
     110     * 
     111     * @param data 
     112     *            data for which the instances are characterized 
     113     * @return characteristics 
     114     */ 
    81115    public static DistChar datasetDistance(Instances data) { 
    82116        double distance; 
    … …  
    87121        int numCmp = 0; 
    88122        int l = 0; 
    89         double[] inst1 = new double[data.numAttributes()-1]; 
    90         double[] inst2 = new double[data.numAttributes()-1]; 
     123        double[] inst1 = new double[data.numAttributes() - 1]; 
     124        double[] inst2 = new double[data.numAttributes() - 1]; 
    91125        EuclideanDistance euclideanDistance = new EuclideanDistance(); 
    92         for( int i=0; i<data.numInstances(); i++ ) { 
    93             l=0; 
    94             for( int k=0; k<data.numAttributes(); k++ ) { 
    95                 if( k!=data.classIndex() ) { 
     126        for (int i = 0; i < data.numInstances(); i++) { 
     127            l = 0; 
     128            for (int k = 0; k < data.numAttributes(); k++) { 
     129                if (k != data.classIndex()) { 
    96130                    inst1[l] = data.instance(i).value(k); 
    97131                } 
    98132            } 
    99             for( int j=0; j<data.numInstances(); j++ ) { 
    100                 if( j!=i ) { 
    101                     l=0; 
    102                     for( int k=0; k<data.numAttributes(); k++ ) { 
    103                         if( k!=data.classIndex() ) { 
     133            for (int j = 0; j < data.numInstances(); j++) { 
     134                if (j != i) { 
     135                    l = 0; 
     136                    for (int k = 0; k < data.numAttributes(); k++) { 
     137                        if (k != data.classIndex()) { 
    104138                            inst2[l] = data.instance(j).value(k); 
    105139                        } 
    … …  
    107141                    distance = euclideanDistance.compute(inst1, inst2); 
    108142                    sumAll += distance; 
    109                     sumAllQ += distance*distance; 
     143                    sumAllQ += distance * distance; 
    110144                    numCmp++; 
    111                     if( distance < min ) { 
     145                    if (distance < min) { 
    112146                        min = distance; 
    113147                    } 
    114                     if( distance > max ) { 
     148                    if (distance > max) { 
    115149                        max = distance; 
    116150                    } 
    … …  
    119153        } 
    120154        double mean = sumAll / numCmp; 
    121         double std = Math.sqrt((sumAllQ-(sumAll*sumAll)/numCmp) * 
    122                                   (1.0d / (numCmp - 1))); 
     155        double std = Math.sqrt((sumAllQ - (sumAll * sumAll) / numCmp) * (1.0d / (numCmp - 1))); 
    123156        return new DistChar(mean, std, min, max, data.numInstances()); 
    124157    } 
    125      
    126     // like above, but for single attribute 
     158 
     159    /** 
     160     * <p> 
     161     * Calculates the distributional characteristics of the distances of a single attribute the 
     162     * instances within a data set have to each other. 
     163     * </p> 
     164     * 
     165     * @param data 
     166     *            data for which the instances are characterized 
     167     * @param index 
     168     *            attribute for which the distances are characterized 
     169     * @return characteristics 
     170     */ 
    127171    public static DistChar attributeDistance(Instances data, int index) { 
    128172        double distance; 
    … …  
    133177        int numCmp = 0; 
    134178        double value1, value2; 
    135         for( int i=0; i<data.numInstances(); i++ ) { 
     179        for (int i = 0; i < data.numInstances(); i++) { 
    136180            value1 = data.instance(i).value(index); 
    137             for( int j=0; j<data.numInstances(); j++ ) { 
    138                 if( j!=i ) { 
     181            for (int j = 0; j < data.numInstances(); j++) { 
     182                if (j != i) { 
    139183                    value2 = data.instance(j).value(index); 
    140                     distance = Math.abs(value1-value2); 
     184                    distance = Math.abs(value1 - value2); 
    141185                    sumAll += distance; 
    142                     sumAllQ += distance*distance; 
     186                    sumAllQ += distance * distance; 
    143187                    numCmp++; 
    144                     if( distance < min ) { 
     188                    if (distance < min) { 
    145189                        min = distance; 
    146190                    } 
    147                     if( distance > max ) { 
     191                    if (distance > max) { 
    148192                        max = distance; 
    149193                    } 
    … …  
    152196        } 
    153197        double mean = sumAll / numCmp; 
    154         double std = Math.sqrt((sumAllQ-(sumAll*sumAll)/numCmp) * 
    155                                   (1.0d / (numCmp - 1))); 
     198        double std = Math.sqrt((sumAllQ - (sumAll * sumAll) / numCmp) * (1.0d / (numCmp - 1))); 
    156199        return new DistChar(mean, std, min, max, data.numInstances()); 
    157200    } 
    158      
     201 
    159202    /** 
    160203     * <p> 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/versions/AbstractVersionFilter.java

    r86 r135  
    2525public abstract class AbstractVersionFilter implements IVersionFilter { 
    2626 
    27     /** 
     27    /* 
    2828     * @see de.ugoe.cs.cpdp.versions.IVersionFilter#apply(java.util.List) 
    2929     */ 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/versions/MinClassNumberFilter.java

    r86 r135  
    3030    private int minInstances = 0; 
    3131 
    32     /** 
     32    /* 
    3333     * @see de.ugoe.cs.cpdp.versions.IVersionFilter#apply(de.ugoe.cs.cpdp.versions.SoftwareVersion) 
    3434     */ 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/versions/MinInstanceNumberFilter.java

    r86 r135  
    2828    private int minInstances = 0; 
    2929 
    30     /** 
     30    /* 
    3131     * @see de.ugoe.cs.cpdp.versions.IVersionFilter#apply(de.ugoe.cs.cpdp.versions.SoftwareVersion) 
    3232     */ 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/versions/SoftwareVersion.java

    r132 r135  
    4040     */ 
    4141    private final Instances instances; 
    42      
     42 
    4343    /** 
    44      * Review effort per instance.  
     44     * Review effort per instance. 
    4545     */ 
    4646    private final List<Double> efforts; 
    … …  
    5656     *            data of the version 
    5757     */ 
    58     public SoftwareVersion(String project, String version, Instances instances, List<Double> efforts) { 
     58    public SoftwareVersion(String project, 
     59                           String version, 
     60                           Instances instances, 
     61                           List<Double> efforts) 
     62    { 
    5963        this.project = project; 
    6064        this.version = version; 
    … …  
    6266        this.efforts = efforts; 
    6367    } 
    64      
     68 
    6569    /** 
    6670     * returns the project name 
    … …  
    8993        return new Instances(instances); 
    9094    } 
    91      
     95 
    9296    /** 
    9397     * <p> 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/wekaclassifier/BayesNetWrapper.java

    r130 r135  
    4040     * generated ID 
    4141     */ 
    42     /**  */ 
    4342    private static final long serialVersionUID = -4835134612921456157L; 
    4443 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/wekaclassifier/FixClass.java

    r86 r135  
    2323 
    2424/** 
    25  * Simple classifier that always predicts the same class 
     25 * Simple classifier that always predicts the same class. 
    2626 *  
    2727 * @author Steffen Herbold 
    … …  
    2929public class FixClass extends AbstractClassifier { 
    3030 
     31    /** 
     32     * default serialization ID 
     33     */ 
    3134    private static final long serialVersionUID = 1L; 
    3235 
     36    /** 
     37     * default prediction: non-defective 
     38     */ 
    3339    private double fixedClassValue = 0.0d; 
    34  
    35     public FixClass() { 
    36         // TODO Auto-generated constructor stub 
    37     } 
    3840 
    3941    /** 
    … …  
    6668    } 
    6769 
     70    /* 
     71     * (non-Javadoc) 
     72     *  
     73     * @see weka.classifiers.AbstractClassifier#setOptions(java.lang.String[]) 
     74     */ 
    6875    @Override 
    6976    public void setOptions(String[] options) throws Exception { 
    … …  
    7178    } 
    7279 
     80    /* 
     81     * (non-Javadoc) 
     82     *  
     83     * @see weka.classifiers.AbstractClassifier#classifyInstance(weka.core.Instance) 
     84     */ 
    7385    @Override 
    7486    public double classifyInstance(Instance instance) { 
    … …  
    7688    } 
    7789 
     90    /* 
     91     * (non-Javadoc) 
     92     *  
     93     * @see weka.classifiers.Classifier#buildClassifier(weka.core.Instances) 
     94     */ 
    7895    @Override 
    7996    public void buildClassifier(Instances traindata) throws Exception { 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/wekaclassifier/ITestAwareClassifier.java

    r66 r135  
     1 
    12package de.ugoe.cs.cpdp.wekaclassifier; 
    23 
    34import weka.core.Instances; 
    45 
     6/** 
     7 * <p> 
     8 * Interface for test data aware classifier implementations 
     9 * </p> 
     10 *  
     11 * @author Steffen Herbold 
     12 */ 
    513public interface ITestAwareClassifier { 
    6      
     14 
     15    /** 
     16     * <p> 
     17     * passes the test data to the classifier 
     18     * </p> 
     19     * 
     20     * @param testdata 
     21     *            the test data 
     22     */ 
    723    public void setTestdata(Instances testdata); 
    824 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/wekaclassifier/RandomClass.java

    r86 r135  
    2222 
    2323/** 
     24 * <p> 
    2425 * Assigns a random class label to the instance it is evaluated on. 
    25  *  
     26 * </p> 
    2627 * The range of class labels are hardcoded in fixedClassValues. This can later be extended to take 
    2728 * values from the XML configuration. 
     29 * </p> 
     30 *  
     31 * @author Alexander Trautsch 
    2832 */ 
    2933public class RandomClass extends AbstractClassifier { 
    3034 
     35    /** 
     36     * default serialization id 
     37     */ 
    3138    private static final long serialVersionUID = 1L; 
    3239 
     40    /** 
     41     * class values 
     42     */ 
    3343    private double[] fixedClassValues = 
    3444        { 0.0d, 1.0d }; 
    3545 
     46    /* 
     47     * (non-Javadoc) 
     48     *  
     49     * @see weka.classifiers.Classifier#buildClassifier(weka.core.Instances) 
     50     */ 
    3651    @Override 
    3752    public void buildClassifier(Instances arg0) throws Exception { 
    … …  
    3954    } 
    4055 
     56    /* 
     57     * (non-Javadoc) 
     58     *  
     59     * @see weka.classifiers.AbstractClassifier#classifyInstance(weka.core.Instance) 
     60     */ 
    4161    @Override 
    4262    public double classifyInstance(Instance instance) { 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/wekaclassifier/VCBSVM.java

    r105 r135  
    334334     */ 
    335335    private Instances weightedResample(final Instances data, final int size) { 
    336         if( data.isEmpty() ) { 
     336        if (data.isEmpty()) { 
    337337            return data; 
    338338        } 

  • trunk/CrossPare/src/de/ugoe/cs/cpdp/wekaclassifier/WHICH.java

    r127 r135  
    268268                score = 0; 
    269269            } 
    270             if( score==0 ) { 
     270            if (score == 0) { 
    271271                score = 0.000000001; // to disallow 0 total score 
    272272            } 
    … …  
    296296                else { 
    297297                    String range = ranges.get(k); 
    298                     if( "'All'".equals(range) ) { 
     298                    if ("'All'".equals(range)) { 
    299299                        result = true; 
    300                     } else { 
     300                    } 
     301                    else { 
    301302                        double instanceValue = instance.value(attrIndex); 
    302303                        double lowerBound; 
    … …  
    327328                            else { 
    328329                                // first value is positive 
    329                                 if( splitResult[0].substring(2, splitResult[0].length()).equals("ll'")) { 
     330                                if (splitResult[0].substring(2, splitResult[0].length()) 
     331                                    .equals("ll'")) 
     332                                { 
    330333                                    System.out.println("foo"); 
    331334                                } 
    332                                 lowerBound = Double 
    333                                     .parseDouble(splitResult[0].substring(2, splitResult[0].length())); 
     335                                lowerBound = Double.parseDouble(splitResult[0] 
     336                                    .substring(2, splitResult[0].length())); 
    334337                                if (splitResult[1].startsWith("inf")) { 
    335338                                    upperBound = Double.POSITIVE_INFINITY; 
    … …  
    346349                        boolean upperBoundMatch = (range.charAt(range.length() - 2) == ')' && 
    347350                            instanceValue < upperBound) || 
    348                             (range.charAt(range.length() - 2) == ']' && instanceValue <= upperBound); 
     351                            (range.charAt(range.length() - 2) == ']' && 
     352                                instanceValue <= upperBound); 
    349353                        result = lowerBoundMatch && upperBoundMatch; 
    350354                    } 
Note: See TracChangeset for help on using the changeset viewer.