Changeset 47 for trunk/CrossPare

Timestamp:

12/12/15 10:57:31 (9 years ago)

Author:

atrautsch

Message:

selection

File:

• trunk/CrossPare/src/de/ugoe/cs/cpdp/training/MetricMatchingTraining.java (modified) (20 diffs)

trunk/CrossPare/src/de/ugoe/cs/cpdp/training/MetricMatchingTraining.java

@@ -16 +16 @@
 
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
 import java.util.HashMap;
 import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
 import java.util.Map;
 import java.util.logging.Level;
+
+import javax.management.RuntimeErrorException;
+
 import java.util.Random;
 
@@ -28 +37 @@
 
 import de.ugoe.cs.util.console.Console;
+import weka.attributeSelection.SignificanceAttributeEval;
 import weka.classifiers.AbstractClassifier;
 import weka.classifiers.Classifier;
@@ -35 +45 @@
 import weka.core.Instance;
 import weka.core.Instances;
+
 
 public class MetricMatchingTraining extends WekaBaseTraining implements ISetWiseTestdataAwareTrainingStrategy {
@@ -53 +64 @@
         return this.classifier;
     }
-    
-    
-    @Override
-    public String getName() {
-        return "MetricMatching_" + classifierName;
-    }
 
 
@@ -90 +95 @@
                         //tmp.kolmogorovSmirnovTest(0.05);
                         
-                        if( this.method.equals("spearman") ) {
+                        try {
+                                tmp.attributeSelection();
+                        }catch(Exception e) {
+                                
+                        }
+                        
+                        if (this.method.equals("spearman")) {
                             tmp.spearmansRankCorrelation(this.threshold);
                         }
-                        else if( this.method.equals("kolmogorov") ) {
+                        else if (this.method.equals("kolmogorov")) {
                             tmp.kolmogorovSmirnovTest(this.threshold);
                         }
@@ -101 +112 @@
 
                         // we only select the training data from our set with the most matching attributes
-                        if(tmp.getRank() > rank) {
+                        if (tmp.getRank() > rank) {
                                 rank = tmp.getRank();
                                 biggest = tmp;
@@ -108 +119 @@
                 }
                 
-                if( biggest == null ) {
+                if (biggest == null) {
                     throw new RuntimeException("not enough matching attributes found");
                 }
@@ -117 +128 @@
                 Instances ilist = this.mm.getMatchedTrain();
                 Console.traceln(Level.INFO, "Chosing the trainingdata set num "+biggest_num +" with " + rank + " matching attributs, " + ilist.size() + " instances out of a possible set of " + traindataSet.size() + " sets");
+                
+                // replace traindataSEt
+                //traindataSet = new SetUniqueList<Instances>();
+                traindataSet.clear();
+                traindataSet.add(ilist);
                 
                 // we have to build the classifier here:
@@ -122 +138 @@
                     
                         //
-                    if( this.classifier == null ) {
+                    if (this.classifier == null) {
                         Console.traceln(Level.SEVERE, "Classifier is null");
                     }
@@ -200 +216 @@
                         
                          this.test_values = new ArrayList<double[]>();
-                         for( int i=0; i < this.test.numAttributes()-1; i++ ) {
+                         for (int i=0; i < this.test.numAttributes()-1; i++) {
                                 this.test_values.add(this.test.attributeToDoubleArray(i));
                          }
@@ -232 +248 @@
                          Iterator it = this.attributes.entrySet().iterator();
                          int j = 0;
-                         while(it.hasNext()) {
+                         while (it.hasNext()) {
                                  Map.Entry values = (Map.Entry)it.next();
                                  ni.setValue(testdata.attribute(j), test.value((int)values.getValue()));
@@ -268 +284 @@
                          Attribute[] attrs = new Attribute[this.attributes.size()+1];
                          FastVector fwTrain = new FastVector(this.attributes.size());
-                         for(int i=0; i < this.attributes.size(); i++) {
+                         for (int i=0; i < this.attributes.size(); i++) {
                                  attrs[i] = new Attribute(String.valueOf(i));
                                  fwTrain.addElement(attrs[i]);
@@ -281 +297 @@
                          newTrain.setClassIndex(newTrain.numAttributes()-1);
                          
-                         for(int i=0; i < data.size(); i++) {
+                         for (int i=0; i < data.size(); i++) {
                                  Instance ni = new DenseInstance(this.attributes.size()+1);
                                 
                                  Iterator it = this.attributes.entrySet().iterator();
                                  int j = 0;
-                                 while(it.hasNext()) {
+                                 while (it.hasNext()) {
                                          Map.Entry values = (Map.Entry)it.next();
                                          int value = (int)values.getValue();
                                          
                                          // key ist traindata
-                                         if(name.equals("train")) {
+                                         if (name.equals("train")) {
                                                  value = (int)values.getKey();
                                          }
@@ -302 +318 @@
                          }
                          
-                         return newTrain;
-                 }
+                    return newTrain;
+        }
+                 
+                 
+                /**
+                 * performs the attribute selection
+                 * we perform attribute significance tests and drop attributes
+                 */
+                public void attributeSelection() throws Exception {
+                        this.attributeSelection(this.train);
+                        this.attributeSelection(this.test);
+                }
+                
+                private void attributeSelection(Instances which) throws Exception {
+                        // 1. step we have to categorize the attributes
+                        //http://weka.sourceforge.net/doc.packages/probabilisticSignificanceAE/weka/attributeSelection/SignificanceAttributeEval.html
+                        
+                        SignificanceAttributeEval et = new SignificanceAttributeEval();
+                        et.buildEvaluator(which);
+                        //double tmp[] = new double[this.train.numAttributes()];
+                        HashMap<Integer,Double> saeval = new HashMap<Integer,Double>();
+                        // evaluate all training attributes
+                        // select top 15% of metrics
+                        for(int i=0; i < which.numAttributes() - 1; i++) { 
+                                //tmp[i] = et.evaluateAttribute(i);
+                                saeval.put(i, et.evaluateAttribute(i));
+                                //Console.traceln(Level.SEVERE, "Significance Attribute Eval: " + tmp);
+                        }
+                        
+                        HashMap<Integer, Double> sorted = sortByValues(saeval);
+                        
+                        // die letzen 15% wollen wir haben
+                        int last = (saeval.size() / 100) * 15;
+                        int drop_first = saeval.size() - last;
+                        
+                        // drop attributes above last
+                        Iterator it = sorted.entrySet().iterator();
+                    while (it.hasNext()) {
+                        Map.Entry pair = (Map.Entry)it.next();
+                        if(drop_first > 0) {
+                                which.deleteAttributeAt((int)pair.getKey());
+                        }
+                        drop_first--;
+                    }   
+                }
+                
+                private HashMap sortByValues(HashMap map) {
+               List list = new LinkedList(map.entrySet());
+               // Defined Custom Comparator here
+               Collections.sort(list, new Comparator() {
+                    public int compare(Object o1, Object o2) {
+                       return ((Comparable) ((Map.Entry) (o1)).getValue())
+                          .compareTo(((Map.Entry) (o2)).getValue());
+                    }
+               });
+
+               // Here I am copying the sorted list in HashMap
+               // using LinkedHashMap to preserve the insertion order
+               HashMap sortedHashMap = new LinkedHashMap();
+               for (Iterator it = list.iterator(); it.hasNext();) {
+                      Map.Entry entry = (Map.Entry) it.next();
+                      sortedHashMap.put(entry.getKey(), entry.getValue());
+               } 
+               return sortedHashMap;
+                }
+                 
                  
                  /**
@@ -315 +395 @@
 
                          // size has to be the same so we randomly sample the number of the smaller sample from the big sample
-                         if( this.train.size() > this.test.size() ) {
+                         if (this.train.size() > this.test.size()) {
                              this.sample(this.train, this.test, this.train_values);
-                         }else if( this.test.size() > this.train.size() ) {
+                         }else if (this.test.size() > this.train.size()) {
                              this.sample(this.test, this.train, this.test_values);
                          }
                          
                          // try out possible attribute combinations
-            for( int i=0; i < this.train.numAttributes()-1; i++ ) {
-                for ( int j=0; j < this.test.numAttributes()-1; j++ ) {
+            for (int i=0; i < this.train.numAttributes()-1; i++) {
+                for (int j=0; j < this.test.numAttributes()-1; j++) {
                     // class attributes are not relevant 
-                    if ( this.train.classIndex() == i ) {
+                    if (this.train.classIndex() == i) {
                         continue;
                     }
-                    if ( this.test.classIndex() == j ) {
+                    if (this.test.classIndex() == j) {
                         continue;
                     }
                     
                     
-                                        if( !this.attributes.containsKey(i) ) {
+                                        if (!this.attributes.containsKey(i)) {
                                                 p = t.correlation(this.train_values.get(i), this.test_values.get(j));
-                                                if( p > cutoff ) {
+                                                if (p > cutoff) {
                                                         this.attributes.put(i, j);
                                                 }
@@ -349 +429 @@
             ArrayList<Integer> indices = new ArrayList<Integer>();
             Random rand = new Random();
-            while( indices_to_draw > 0) {
+            while (indices_to_draw > 0) {
                 
                 int index = rand.nextInt(bigger.size()-1);
                 
-                if( !indices.contains(index) ) {
+                if (!indices.contains(index)) {
                     indices.add(index);
                     indices_to_draw--;
@@ -360 +440 @@
             
             // now reduce our values to the indices we choose above for every attribute
-            for(int att=0; att < bigger.numAttributes()-1; att++ ) {
+            for (int att=0; att < bigger.numAttributes()-1; att++) {
                 
                 // get double for the att
@@ -367 +447 @@
                 
                 int i = 0;
-                for( Iterator<Integer> it = indices.iterator(); it.hasNext(); ) {
+                for (Iterator<Integer> it = indices.iterator(); it.hasNext();) {
                     new_vals[i] = vals[it.next()];
                     i++;
@@ -394 +474 @@
                         // todo: this relies on the last attribute being the class, 
                         //Console.traceln(Level.INFO, "Starting Kolmogorov-Smirnov test for traindata size: " + this.train.size() + " attributes("+this.train.numAttributes()+") and testdata size: " + this.test.size() + " attributes("+this.test.numAttributes()+")");
-                        for( int i=0; i < this.train.numAttributes()-1; i++ ) {
+                        for (int i=0; i < this.train.numAttributes()-1; i++) {
                                 for ( int j=0; j < this.test.numAttributes()-1; j++) {
                                         //p = t.kolmogorovSmirnovTest(this.train_values.get(i), this.test_values.get(j));
@@ -406 +486 @@
                     }
                                         // PRoblem: exactP is forced for small sample sizes and it never finishes
-                                        if( !this.attributes.containsKey(i) ) {
+                                        if (!this.attributes.containsKey(i)) {
                                                 
                                                 // todo: output the values and complain on the math.commons mailinglist
                                                 p = t.kolmogorovSmirnovTest(this.train_values.get(i), this.test_values.get(j));
-                                                if( p > cutoff ) {
+                                                if (p > cutoff) {
                                                         this.attributes.put(i, j);
                                                 }