Changeset 13 for trunk/CrossPare/src/de


Ignore:
Timestamp:
08/25/14 14:32:23 (10 years ago)
Author:
atrautsch
Message:

More Comments

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r12 r13  
    2626/** 
    2727 * ACHTUNG UNFERTIG 
    28  * 
    2928 *  
    30  * Basically a copy of WekaClusterTraining2 with internal classes for the Fastmap and QuadTree implementations 
     29 * With WekaLocalTraining2 we do the following: 
     30 * 1) Run the Fastmap algorithm on all training data, let it calculate the 2 most significant  
     31 *    dimensions and projections of each instance to these dimensions 
     32 * 2) With these 2 dimensions we span a QuadTree which gets recursively split on median(x) and median(y) values. 
     33 * 3) We cluster the QuadTree nodes together if they have similar density (50%) 
     34 * 4) We save the clusters and their training data 
     35 * 5) We train a Weka classifier for each cluster with the clusters training data 
     36 * 5) We classify single instances to a cluster and then classify them using the classifier of the cluster 
     37 *  
    3138 */ 
    3239public class WekaLocalTraining2 extends WekaBaseTraining2 implements ITrainingStrategy { 
    … …  
    3441        private final TraindatasetCluster classifier = new TraindatasetCluster(); 
    3542         
    36         // we do not need to keep them around 
    37         //private final QuadTree q = null; 
    38         //private final Fastmap f = null; 
    39          
    4043        // these values are set later when we have all the information we need 
     44         
    4145        /*Stopping rule for tree recursion (Math.sqrt(Instances)*/ 
    4246        public static double ALPHA = 0; 
    … …  
    4549        /*size of the complete set (used for density function)*/ 
    4650        public static int SIZE = 0; 
    47          
    48         public static int MIN_INST = 10; 
    4951         
    5052        // cluster 
    … …  
    104106                 
    105107                /** 
    106                  * Because Fastmap saves only the image not the values of the attributes 
    107                  * we can not use it to classify single instances to values 
    108                  *  
    109                  * TODO: mehr erklärung 
    110                  * TODO: class lavel filter raus 
    111                  *  
    112                  * Finde die am nächsten liegende Instanz zur übergebenen 
    113                  * dann bestimme den cluster der instanz und führe dann den  
    114                  * classifier des clusters aus 
     108                 * Because Fastmap saves only the image not the values of the attributes it used 
     109                 * we can not use it or the QuadTree to classify single instances to clusters. 
     110                 *  
     111                 * To classify a single instance we measure the distance to all instances we have clustered and 
     112                 * use the cluster where the distance is minimal. 
     113                 *  
     114                 * TODO: class attribute filter raus 
    115115                 */ 
    116116                @Override 
    … …  
    190190                        // 4. run fastmap for 2 dimensions on the distance matrix 
    191191                        Fastmap f = new Fastmap(2, dist); 
    192                         f.calculate(2); 
     192                        f.calculate(); 
    193193                        double[][] X = f.getX(); 
    194194                         
    … …  
    223223                    SIZE = train.size(); 
    224224                     
    225                     Console.traceln(Level.INFO, String.format("Generate QuadTree with "+ SIZE + " size, Alpha: "+ ALPHA+ "")); 
     225                    //Console.traceln(Level.INFO, String.format("Generate QuadTree with "+ SIZE + " size, Alpha: "+ ALPHA+ "")); 
    226226                     
    227227                    // set the size and then split the tree recursively at the median value for x, y 
    … …  
    232232                    ArrayList<QuadTree> l = new ArrayList<QuadTree>(q.getList(q)); 
    233233                     
    234                     // recursive grid clustering (tree pruning), the values are stored in cluster! 
     234                    // recursive grid clustering (tree pruning), the values are stored in cluster 
    235235                    q.gridClustering(l); 
    236                      
    237                     // after grid clustering we need to remove the clusters with < 2 * ALPHA instances 
    238                      
    239                     // hier müssten wir sowas haben wie welche instanz in welchem cluster ist 
    240                     // oder wir iterieren durch die cluster und sammeln uns die instanzen daraus 
     236                  
     237                    // wir iterieren durch die cluster und sammeln uns die instanzen daraus 
    241238                    for(int i=0; i < cluster.size(); i++) { 
    242239                        ArrayList<QuadTreePayload<Instance>> current = cluster.get(i); 
    243240                         
    244241                        // i is the clusternumber 
    245                         // we only allow clusters with Instances > ALPHA 
     242                        // we only allow clusters with Instances > ALPHA, other clusters are not considered! 
    246243                        if(current.size() > ALPHA) { 
    247244                                for(int j=0; j < current.size(); j++ ) { 
    … …  
    290287        } 
    291288         
     289         
    292290        /** 
    293291         * Fastmap implementation 
    294          *  
    295          * TODO: only one place to pass dimension! 
    296292         *  
    297293         * Faloutsos, C., & Lin, K. I. (1995).  
    … …  
    313309                private int col = 0; 
    314310                 
     311                /*number of dimensions we want*/ 
     312                private int target_dims = 0; 
     313                 
    315314                public Fastmap(int k, double[][] O) { 
    316315                        this.O = O; 
    317                          
    318316                        int N = O.length; 
     317                         
     318                        this.target_dims = k; 
    319319                         
    320320                        this.X = new double[N][k]; 
    … …  
    323323                 
    324324                /** 
    325                  * The distance function for eculidean distance 
     325                 * The distance function for euclidean distance 
    326326                 *  
    327327                 * Acts according to equation 4 of the fastmap paper 
    … …  
    395395                 * @param dims dimensionality 
    396396                 */ 
    397                 public void calculate(int dims) { 
    398                          
    399                         for(int k=0; k <dims; k++) { 
     397                public void calculate() { 
     398                         
     399                        for(int k=0; k <this.target_dims; k++) { 
    400400                                 
    401401                                // 2) choose pivot objects 
    … …  
    436436        } 
    437437 
     438         
    438439        /** 
    439440         * QuadTree implementation 
    … …  
    517518                } 
    518519                 
    519                  
    520                 /** 
    521                  * Todo: DRY, median ist immer dasselbe 
     520                /** 
     521                 * TODO: DRY, median ist immer dasselbe 
    522522                 *   
    523523                 * @return median for x 
    … …  
    551551                } 
    552552                 
    553                  
    554553                private double getMedianForY() { 
    555554                        double med_y =0 ; 
    … …  
    580579                } 
    581580                 
    582                  
    583581                /** 
    584582                 * Reurns the number of instances in the payload 
    … …  
    593591                        return number; 
    594592                } 
    595                  
    596593                 
    597594                /** 
    … …  
    678675                } 
    679676                 
    680                  
    681677                /**  
    682                  * Todo: evt. auslagern, eigentlich auch eher ne statische methode 
     678                 * TODO: evt. auslagern, eigentlich auch eher ne statische methode 
    683679                 *  
    684680                 * @param q 
    … …  
    704700                } 
    705701                 
    706                  
    707702                /** 
    708703                 * returns an list of childs sorted by density 
    … …  
    732727                        } 
    733728                } 
    734                  
    735729                 
    736730                /** 
Note: See TracChangeset for help on using the changeset viewer.