ClusterNamer.java

Go to the documentation of this file.

package edu.tum.cs.clustering;
import weka.clusterers.*;
import weka.core.*;
import java.util.*;
import java.math.*;

public interface ClusterNamer<Cl extends Clusterer> {
        public String[] getNames(Cl clusterer) throws Exception;
        
        public static class SimplePrefix implements ClusterNamer<Clusterer> {
                protected String prefix;
                
                public SimplePrefix(String prefix) {
                        this.prefix = prefix;
                }
                
                public String[] getNames(Clusterer clusterer) throws Exception {
                        int n = clusterer.numberOfClusters();
                        String[] names = new String[n];
                        for(Integer i = 0; i < n; i++)
                                names[i] = prefix + i.toString();
                        return names;
                }
        }
        
        public static class Fixed implements ClusterNamer<Clusterer> {
                protected String[] names;
                
                public Fixed(String[] names) {
                        this.names = names;
                }
                
                public String[] getNames(Clusterer clusterer) throws Exception {
                        if(clusterer.numberOfClusters() != names.length)
                                throw new Exception("Number of clusters does not match number of names.");
                        return names;
                }
        }
        
        public static class MeanStdDev implements ClusterNamer<SimpleKMeans> {
                public String[] getNames(SimpleKMeans clusterer) {
                        int numClusters = clusterer.getNumClusters();
                        String[] ret = new String[numClusters];
                        Instances centroids = clusterer.getClusterCentroids();
                        Instances stdDevs = clusterer.getClusterStandardDevs();
                        for(int i = 0; i < numClusters; i++)
                                ret[i] = String.format("~%.2f +/- %.2f", centroids.instance(i).value(0), stdDevs.instance(i).value(0));
                        return ret;
                }
        }
        
        public static class Intervals implements ClusterNamer<SimpleKMeans> {
                public static double getIntersection(double e1, double s1, double e2, double s2) {
                        if(s2 == 0)
                                return e2;
                        if(s1 == s2)
                                return (e1 + e2) / 2;
                        double r1 = 1.0/2/(s1*s1-s2*s2)*(2*s1*s1*e2-2*s2*s2*e1+2*Math.sqrt(-2*s1*s1*e2*s2*s2*e1+s1*s1*s2*s2*e1*e1-2*s1*s1*s1*s1*Math.log(s2/s1)*s2*s2+s2*s2*s1*s1*e2*e2+2*s2*s2*s2*s2*Math.log(s2/s1)*s1*s1));
                        if((e1 <= r1 && r1 <= e2) || (e2 <= r1 && r1 <= e1))
                                return r1;                      
                        double r2 = 1.0/2/(s1*s1-s2*s2)*(2*s1*s1*e2-2*s2*s2*e1-2*Math.sqrt(-2*s1*s1*e2*s2*s2*e1+s1*s1*s2*s2*e1*e1-2*s1*s1*s1*s1*Math.log(s2/s1)*s2*s2+s2*s2*s1*s1*e2*e2+2*s2*s2*s2*s2*Math.log(s2/s1)*s1*s1));
                        return r2;
                }
                
                public String[] getNames(SimpleKMeans clusterer) {
                        int numClusters = clusterer.getNumClusters();
                        String[] ret = new String[numClusters];
                        double[] centroids = clusterer.getClusterCentroids().attributeToDoubleArray(0);
                        double[] stdDevs = clusterer.getClusterStandardDevs().attributeToDoubleArray(0);
                        double[] sortedCentroids = centroids.clone();
                        Arrays.sort(sortedCentroids);
                        int[] sortOrder = new int[numClusters];
                        for(int i = 0; i < numClusters; i++) 
                                for(int j = 0; j < numClusters; j++)
                                        if(centroids[j] == sortedCentroids[i])
                                                sortOrder[i] = j;
                        boolean lastNoInterv = false;
                        for(int i = 0; i < numClusters; i++) {
                                int idx = sortOrder[i];
                                if(stdDevs[idx] == 0.0) { // no deviation -> no range
                                        ret[idx] = String.format("%.2f", centroids[idx]);
                                        continue;
                                }
                                if(i == 0) { // no left neighbour
                                        ret[idx] = String.format("< %.2f (~%.2f)", getIntersection(centroids[idx], stdDevs[idx], centroids[sortOrder[1]], stdDevs[sortOrder[1]]),  centroids[idx]);
                                        continue;
                                }
                                if(i == numClusters-1) { // no right neighbour
                                        ret[idx] = String.format("> %.2f (~%.2f)", getIntersection(centroids[idx], stdDevs[idx], centroids[sortOrder[i-1]], stdDevs[sortOrder[i-1]]),  centroids[idx]);
                                        continue;                                       
                                }
                                double left = getIntersection(centroids[idx], stdDevs[idx], centroids[sortOrder[i-1]], stdDevs[sortOrder[i-1]]);
                                double right = getIntersection(centroids[idx], stdDevs[idx], centroids[sortOrder[i+1]], stdDevs[sortOrder[i+1]]);
                                ret[idx] = String.format("%.2f - %.2f (~%.2f)", left, right, centroids[idx]);
                        }
                        return ret;
                }
        }
}

---

srldb
Author(s): Dominik Jain, Stefan Waldherr, Moritz Tenorth
autogenerated on Fri Jan 11 09:58:29 2013