EMModel.java

Go to the documentation of this file.

package edu.wpi.rail.jinteractiveworld.model;

import edu.wpi.rail.jinteractiveworld.data.*;
import edu.wpi.rail.jinteractiveworld.ros.msgs.interactiveworldmsgs.*;
import edu.wpi.rail.jrosbridge.messages.geometry.Point;
import weka.clusterers.EM;
import weka.core.*;
import weka.core.Instances;
import weka.filters.Filter;
import weka.filters.unsupervised.attribute.Remove;
import java.util.ArrayList;
import java.util.List;

public class EMModel implements Model {

        private EM em;
        private Placement best;
        private double decisionValue, sigmaX, sigmaY, sigmaZ, sigmaTheta;
        private DataSet data;

        public EMModel(DataSet data) {
                this.data = data;
                this.train();
        }

        @Override
        public void add(DataPoint point) {
                this.data.add(point);
                // retrain
                this.train();
        }

        public int size() {
                return this.data.size();
        }

        @Override
        public List<DataPoint> getData() {
                // copy into an array list
                ArrayList<DataPoint> list = new ArrayList<DataPoint>();
                for (int i = 0; i < this.data.size(); i++) {
                        list.add(this.data.get(i));
                }
                return list;
        }

        @Override
        public String getReferenceFrame() {
                return this.data.getReferenceFrame();
        }

        @Override
        public Item getItem() {
                return this.data.getItem();
        }

        @Override
        public Room getRoom() {
                return this.data.getRoom();
        }

        @Override
        public Surface getSurface() {
                return this.data.getSurface();
        }

        @Override
        public void train() {
                try {
                        this.em = new EM();
                        this.best = null;
                        this.decisionValue = Double.POSITIVE_INFINITY;
                        this.sigmaX = 0;
                        this.sigmaY = 0;
                        this.sigmaZ = 0;
                        this.sigmaTheta = 0;

                        // get the instances
                        Instances instances = this.data.toInstances();

                        // remove z for now
                        Remove rm = new Remove();
                        rm.setAttributeIndicesArray(new int[] { DataSet.Z_ATTRIBUTE.index() });
                        rm.setInputFormat(instances);
                        Instances newInstances = Filter.useFilter(instances, rm);

                        // run EM
                        this.em.buildClusterer(newInstances);

                        // get the results
                        double clusterData[][][] = this.em.getClusterModelsNumericAtts();

                        // cluster each point
                        @SuppressWarnings("unchecked")
                        ArrayList<Instance>[] clusters = (ArrayList<Instance>[]) new ArrayList[clusterData.length];
                        for (int i = 0; i < clusters.length; i++) {
                                clusters[i] = new ArrayList<Instance>();
                        }
                        for (int i = 0; i < newInstances.numInstances(); i++) {
                                Instance inst = newInstances.instance(i);
                                int clust = this.em.clusterInstance(inst);
                                clusters[clust].add(inst);
                        }

                        // determine the densest cluster
                        for (int m = 0; m < clusters.length; m++) {
                                ArrayList<Instance> curInsts = clusters[m];
                                double distance = 0;
                                for (int i = 0; i < curInsts.size(); i++) {
                                        Instance instI = curInsts.get(i);
                                        for (int j = 0; j < curInsts.size(); j++) {
                                                if (i != j) {
                                                        Instance instJ = curInsts.get(j);
                                                        // get each attribute
                                                        double sum = 0;
                                                        for (int k = 0; k < instI.numAttributes(); k++) {
                                                                sum += Math.pow(
                                                                                instI.value(k) - instJ.value(k), 2.0);
                                                        }
                                                        // get the distance
                                                        distance += Math.sqrt(sum);
                                                }
                                        }
                                }
                                // average
                                double density = distance
                                                / (curInsts.size() * (curInsts.size() - 1)) * 1.0
                                                / (((double) curInsts.size()) / ((double) this.size()));

                                // check for a new best
                                if (density < this.decisionValue) {
                                        this.decisionValue = density;
                                        double x = clusterData[m][0][0];
                                        this.sigmaX = clusterData[m][0][1];
                                        double y = clusterData[m][1][0];
                                        this.sigmaY = clusterData[m][1][1];
                                        double z = 0.0;
                                        this.sigmaZ = 0.0;
                                        double theta = clusterData[m][2][0];
                                        this.sigmaTheta = clusterData[m][2][1];
                                        this.best = new Placement(this.getItem(), this.getRoom(), this.getSurface(), this.getReferenceFrame(), new Point(x, y, z), theta);
                                }
                        }
                } catch (Exception e) {
                        System.err.println("[ERROR]: Could not train model: "
                                        + e.getMessage());
                }
        }

        @Override
        public Placement getPlacementLocation() {
                return this.best;
        }

        @Override
        public double getDecisionValue() {
                return this.decisionValue;
        }

        @Override
        public double getSigmaX() {
                return this.sigmaX;
        }

        @Override
        public double getSigmaY() {
                return this.sigmaY;
        }

        @Override
        public double getSigmaZ() {
                return this.sigmaZ;
        }

        @Override
        public double getSigmaTheta() {
                return this.sigmaTheta;
        }
}