Changeset 14 for trunk/CrossPare/src/de/ugoe/cs/cpdp/training

Timestamp:

08/29/14 19:33:14 (10 years ago)

Author:

atrautsch

Message:

upd

File:

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

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

@@ -50 +50 @@
         public static int SIZE = 0;
         
+        private static QuadTree TREE;
+        private static Fastmap FMAP;
+        private static EuclideanDistance DIST;
+        
         // cluster
         private static ArrayList<ArrayList<QuadTreePayload<Instance>>> cluster = new ArrayList<ArrayList<QuadTreePayload<Instance>>>();
@@ -130 +134 @@
                                 Instance clusterInstance = createInstance(traindata, instance);
                                 
+                                // build temp dist matrix
+                                double[][] distmat = new double[3][3];
+                                
+                                
+                                
                                 // get distance of this instance to every other instance
                                 // if the distance is minimal apply the classifier of the current cluster
+                                
+                                /*
                                 int cnumber;
                                 int min_cluster = -1;
@@ -155 +166 @@
                                         throw new RuntimeException("min_cluster not found");
                                 }
+                                */
                                 
                                 // classify the passed instance with the cluster we found
@@ -180 +192 @@
                         
                         // 3. calculate distance matrix (needed for Fastmap because it starts at dimension 1)
-                        EuclideanDistance d = new EuclideanDistance(train);
+                        DIST = new EuclideanDistance(train);
                         double[][] dist = new double[train.size()][train.size()];
                         for(int i=0; i < train.size(); i++) {
                                 for(int j=0; j < train.size(); j++) {
-                                        dist[i][j] = d.distance(train.get(i), train.get(j));
+                                        dist[i][j] = DIST.distance(train.get(i), train.get(j));
                                 }
                         }
                         
                         // 4. run fastmap for 2 dimensions on the distance matrix
-                        Fastmap f = new Fastmap(2, dist);
-                        f.calculate();
-                        double[][] X = f.getX();
+                        FMAP = new Fastmap(2, dist);
+                        FMAP.calculate();
+                        double[][] X = FMAP.getX();
                         
                         // quadtree payload generation
@@ -219 +231 @@
                     
                     // 5. generate quadtree
-                    QuadTree q = new QuadTree(null, qtp);
+                    TREE = new QuadTree(null, qtp);
                     ALPHA = Math.sqrt(train.size());
                     SIZE = train.size();
@@ -226 +238 @@
                     
                     // set the size and then split the tree recursively at the median value for x, y
-                    q.setSize(new double[] {small[0], big[0]}, new double[] {small[1], big[1]});
-                    q.recursiveSplit(q);
+                    TREE.setSize(new double[] {small[0], big[0]}, new double[] {small[1], big[1]});
+                    TREE.recursiveSplit(TREE);
                     
                     // generate list of nodes sorted by density (childs only)
-                    ArrayList<QuadTree> l = new ArrayList<QuadTree>(q.getList(q));
+                    ArrayList<QuadTree> l = new ArrayList<QuadTree>(TREE.getList(TREE));
                     
                     // recursive grid clustering (tree pruning), the values are stored in cluster
-                    q.gridClustering(l);
+                    TREE.gridClustering(l);
                  
                     // wir iterieren durch die cluster und sammeln uns die instanzen daraus
@@ -301 +313 @@
                 
                 /*2 x k pivot Array one pair per recursive call*/
-                private double[][] PA;
+                private int[][] PA;
                 
                 /*Objects we got (distance matrix)*/
@@ -312 +324 @@
                 private int target_dims = 0;
                 
+                /*3 x k tmp projections array, we need this for later projections*/
+                double[][] tmpX;
+                
+                /**/
                 public Fastmap(int k, double[][] O) {
+                        this.tmpX = new double[2*k+1][k];
                         this.O = O;
                         int N = O.length;
@@ -319 +336 @@
                         
                         this.X = new double[N][k];
-                        this.PA = new double[2][k];
+                        this.PA = new int[2][k];
                 }
                 
@@ -349 +366 @@
                 
                 /**
+                 * Distance calculation used for adding an Instance after initialization is complete
+                 * 
+                 * @param x x index of x image (if k==0 x object)
+                 * @param y y index of y image (if k==0 y object)
+                 * @param kdimensionality
+                 * @param distmat temp distmatrix for the instance to be added
+                 * @return distance between x, y
+                 */
+                public double tmpDist(int x, int y, int k, double[][] distmat) {
+                        double tmp = distmat[x][y] * distmat[x][y]; 
+                        
+                        // decrease by projections
+                        for(int i=0; i < k; i++) {
+                                double tmp2 = (this.tmpX[x][i] - this.tmpX[y][i]);
+                                tmp -= tmp2 * tmp2;
+                        }
+                        
+                        //return Math.abs(tmp);
+                        return tmp;
+                }
+
+                /**
+                 * Projects an instance after initialization is complete
+                 * 
+                 * This uses the previously saved pivot elements.
+                 * 
+                 * @param distmat distance matrix of the instance and pivot elements (3x3 matrix)
+                 * @return vector of the projection values (k-vector)
+                 */
+                public double[] addInstance(double[][] distmat) {
+
+                        for(int k=0; k < this.target_dims; k++) {
+                                
+                                double dxy = this.dist(this.PA[0][k], this.PA[1][k], k);
+                                
+                                for(int i=0; i < distmat.length; i++) {
+                                        
+                                        double dix = this.tmpDist(i, 2*k+1, k, distmat);
+                                        double diy = this.tmpDist(i, 2*k+2, k, distmat);
+                                        
+                                        // projektion speichern
+                                        this.tmpX[i][k] = (dix + dxy - diy) / (2 * Math.sqrt(dxy));
+                                }
+                        }
+                        
+                        double[] ret = new double[this.target_dims];
+                        for(int k=0; k < this.target_dims; k++) {
+                                ret[k] = this.tmpX[0][k];
+                        }
+                        return ret;
+                }
+
+                /**
                  * Find the object farthest from the given index
                  * This method is a helper Method for findDistandObjects
@@ -418 +488 @@
                                         double diy = this.dist(i, pivots[1], this.col);
                 
-                                        double tmp = (dix + dxy - diy) / 2 * Math.sqrt(dxy);
+                                        double tmp = (dix + dxy - diy) / (2 * Math.sqrt(dxy));
                                         
                                         this.X[i][this.col] = tmp;