source: trunk/CrossPare/src/de/ugoe/cs/cpdp/training/WekaLocalEMTraining.java @ 24

package de.ugoe.cs.cpdp.training;

import java.io.PrintStream;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
import java.util.logging.Level;

import org.apache.commons.io.output.NullOutputStream;

import de.ugoe.cs.util.console.Console;
import weka.classifiers.AbstractClassifier;
import weka.classifiers.Classifier;
import weka.clusterers.EM;
import weka.core.DenseInstance;
import weka.core.Instance;
import weka.core.Instances;
import weka.filters.Filter;
import weka.filters.unsupervised.attribute.Remove;

/**
 * WekaClusterTraining2
 * 
 * Currently supports only EM Clustering.
 * 
 * 1. Cluster training data
 * 2. for each cluster train a classifier with training data from cluster
 * 3. match test data instance to a cluster, then classify with classifier from the cluster
 * 
 * XML configuration:
 * <!-- because of clustering -->
 * <preprocessor name="Normalization" param=""/>
 * 
 * <!-- cluster trainer -->
 * <trainer name="WekaClusterTraining2" param="NaiveBayes weka.classifiers.bayes.NaiveBayes" />
 */
public class WekaLocalEMTraining extends WekaBaseTraining implements ITrainingStrategy {

        private final TraindatasetCluster classifier = new TraindatasetCluster();
        
        @Override
        public Classifier getClassifier() {
                return classifier;
        }
        
        @Override
        public void apply(Instances traindata) {
                PrintStream errStr      = System.err;
                System.setErr(new PrintStream(new NullOutputStream()));
                try {
                        classifier.buildClassifier(traindata);
                } catch (Exception e) {
                        throw new RuntimeException(e);
                } finally {
                        System.setErr(errStr);
                }
        }
        

        public class TraindatasetCluster extends AbstractClassifier {
                
                private static final long serialVersionUID = 1L;

                private EM clusterer = null;

                private HashMap<Integer, Classifier> cclassifier;
                private HashMap<Integer, Instances> ctraindata; 
                
                
                /**
                 * Helper method that gives us a clean instance copy with 
                 * the values of the instancelist of the first parameter. 
                 * 
                 * @param instancelist with attributes
                 * @param instance with only values
                 * @return copy of the instance
                 */
                private Instance createInstance(Instances instances, Instance instance) {
                        // attributes for feeding instance to classifier
                        Set<String> attributeNames = new HashSet<>();
                        for( int j=0; j<instances.numAttributes(); j++ ) {
                                attributeNames.add(instances.attribute(j).name());
                        }
                        
                        double[] values = new double[instances.numAttributes()];
                        int index = 0;
                        for( int j=0; j<instance.numAttributes(); j++ ) {
                                if( attributeNames.contains(instance.attribute(j).name())) {
                                        values[index] = instance.value(j);
                                        index++;
                                }
                        }
                        
                        Instances tmp = new Instances(instances);
                        tmp.clear();
                        Instance instCopy = new DenseInstance(instance.weight(), values);
                        instCopy.setDataset(tmp);
                        
                        return instCopy;
                }
                
                @Override
                public double classifyInstance(Instance instance) {
                        double ret = 0;
                        try {
                                // 1. copy the instance (keep the class attribute)
                                Instances traindata = ctraindata.get(0);
                                Instance classInstance = createInstance(traindata, instance);
                                
                                // 2. remove class attribute before clustering
                                Remove filter = new Remove();
                                filter.setAttributeIndices("" + (traindata.classIndex() + 1));
                                filter.setInputFormat(traindata);
                                traindata = Filter.useFilter(traindata, filter);
                                
                                // 3. copy the instance (without the class attribute) for clustering
                                Instance clusterInstance = createInstance(traindata, instance);
                                
                                // 4. match instance without class attribute to a cluster number
                                int cnum = clusterer.clusterInstance(clusterInstance);
                                
                                // 5. classify instance with class attribute to the classifier of that cluster number
                                ret = cclassifier.get(cnum).classifyInstance(classInstance);
                                
                        }catch( Exception e ) {
                                Console.traceln(Level.INFO, String.format("ERROR matching instance to cluster!"));
                                throw new RuntimeException(e);
                        }
                        return ret;
                }

                @Override
                public void buildClassifier(Instances traindata) throws Exception {
                        
                        // 1. copy training data
                        Instances train = new Instances(traindata);
                        
                        // 2. remove class attribute for clustering
                        Remove filter = new Remove();
                        filter.setAttributeIndices("" + (train.classIndex() + 1));
                        filter.setInputFormat(train);
                        train = Filter.useFilter(train, filter);
                        
                        // new objects
                        cclassifier = new HashMap<Integer, Classifier>();
                        ctraindata = new HashMap<Integer, Instances>();
                                                
                        Instances ctrain;
                        int maxNumClusters = train.size();
                        boolean sufficientInstancesInEachCluster;
                        do { // while(onlyTarget)
                                sufficientInstancesInEachCluster = true;
                                clusterer = new EM();
                                clusterer.setMaximumNumberOfClusters(maxNumClusters);
                                clusterer.buildClusterer(train);
                                
                                // 4. get cluster membership of our traindata
                                //AddCluster cfilter = new AddCluster();
                                //cfilter.setClusterer(clusterer);
                                //cfilter.setInputFormat(train);
                                //Instances ctrain = Filter.useFilter(train, cfilter);
                                
                                ctrain = new Instances(train);
                                ctraindata = new HashMap<>();
                                
                                // get traindata per cluster
                                for ( int j=0; j < ctrain.numInstances(); j++ ) {
                                        // get the cluster number from the attributes, subract 1 because if we clusterInstance we get 0-n, and this is 1-n
                                        //cnumber = Integer.parseInt(ctrain.get(j).stringValue(ctrain.get(j).numAttributes()-1).replace("cluster", "")) - 1;
                                        
                                        int cnumber = clusterer.clusterInstance(ctrain.get(j));
                                        // add training data to list of instances for this cluster number
                                        if ( !ctraindata.containsKey(cnumber) ) {
                                                ctraindata.put(cnumber, new Instances(traindata));
                                                ctraindata.get(cnumber).delete();
                                        }
                                        ctraindata.get(cnumber).add(traindata.get(j));
                                }
                                
                                for( Entry<Integer,Instances> entry : ctraindata.entrySet() ) {
                                        Instances instances = entry.getValue();
                                        int[] counts = instances.attributeStats(instances.classIndex()).nominalCounts;
                                        for( int count : counts ) {
                                                sufficientInstancesInEachCluster &= count>0;
                                        }
                                        sufficientInstancesInEachCluster &= instances.numInstances()>=5;
                                }
                                maxNumClusters = clusterer.numberOfClusters()-1;
                        } while(!sufficientInstancesInEachCluster);
                        
                        // train one classifier per cluster, we get the cluster number from the training data
                        Iterator<Integer> clusternumber = ctraindata.keySet().iterator();
                        while ( clusternumber.hasNext() ) {
                                int cnumber = clusternumber.next();                     
                                cclassifier.put(cnumber,setupClassifier());
                                cclassifier.get(cnumber).buildClassifier(ctraindata.get(cnumber));
                                
                                //Console.traceln(Level.INFO, String.format("classifier in cluster "+cnumber));
                        }
                }
        }
}