DomainLearner.java

Go to the documentation of this file.

package edu.tum.cs.bayesnets.learning;

import edu.ksu.cis.bnj.ver3.core.*;
import edu.tum.cs.bayesnets.core.*;
import edu.tum.cs.clustering.ClusterNamer;

import java.sql.*;
import java.util.*;

import weka.core.*;
import weka.clusterers.*;
//import de.tum.in.fipm.base.data.QueryResult;

public class DomainLearner extends Learner {

        ClusteredDomain[] clusteredDomains;

        protected Instances[] clusterData;

        protected Attribute attrValue;

        SimpleKMeans[] clusterers;

        protected ClusterNamer<SimpleKMeans> clusterNamer;

        protected BeliefNode[] directDomains;

        protected HashSet<?>[] directDomainData;

        String[][] duplicateDomains;

        protected boolean verbose = false;

        static public class ClusteredDomain {
                public String nodeName;

                public int numClusters;

                public ClusteredDomain(String nodeName, int numClusters) {
                        this.nodeName = nodeName;
                        this.numClusters = numClusters;
                }
        }

        public DomainLearner(BeliefNetworkEx bn, String[] directDomains,
                        ClusteredDomain[] clusteredDomains, ClusterNamer namer,
                        String[][] duplicateDomains) throws Exception {
                super(bn);
                init(getBeliefNodes(directDomains), clusteredDomains, namer, duplicateDomains);
        }

        public DomainLearner(BeliefNetwork bn, String[] directDomains,
                        ClusteredDomain[] clusteredDomains, ClusterNamer namer,
                        String[][] duplicateDomains) {
                super(bn);
                init(getBeliefNodes(directDomains), clusteredDomains, namer, duplicateDomains);
        }

        public DomainLearner(BeliefNetwork bn) {
                this(new BeliefNetworkEx(bn));
        }

        public DomainLearner(BeliefNetworkEx bn) {
                super(bn);
                init(bn.bn.getNodes(), null, null, null);
        }

        protected BeliefNode[] getBeliefNodes(String[] names) {
                BeliefNode[] nodes = new BeliefNode[names.length];
                for(int i = 0; i < names.length; i++)
                        nodes[i] = this.bn.getNode(names[i]);
                return nodes;
        }
        
        private void init(BeliefNode[] directDomains,
                        ClusteredDomain[] clusteredDomains, ClusterNamer<SimpleKMeans> namer,
                        String[][] duplicateDomains) {
                this.clusteredDomains = clusteredDomains;
                attrValue = new Attribute("value");
                if (clusteredDomains != null)
                        clusterers = new SimpleKMeans[clusteredDomains.length];
                this.clusterNamer = namer;
                this.directDomains = directDomains;
                this.duplicateDomains = duplicateDomains;

                // create outcome sets for direct domain learning
                if (directDomains != null) {
                        directDomainData = new HashSet<?>[directDomains.length];
                        for (int i = 0; i < directDomains.length; i++)
                                directDomainData[i] = new HashSet<String>();
                }

                // create instance storage for learning of domains using clustering
                if (clusteredDomains != null) {
                        clusterData = new Instances[clusteredDomains.length];
                        for (int i = 0; i < clusteredDomains.length; i++) {
                                FastVector attribs = new FastVector(1);
                                attribs.addElement(attrValue);
                                clusterData[i] = new Instances(clusteredDomains[i].nodeName,
                                                attribs, 100);
                        }
                }
        }

        public void learn(ResultSet rs) throws Exception, SQLException {
                // if it's an empty result set, throw exception
                if (!rs.next())
                        throw new Exception("empty result set!");

                // gather domain data
                int numDirectDomains = directDomains != null ? directDomains.length : 0;
                int numClusteredDomains = clusteredDomains != null ? clusteredDomains.length
                                : 0;
                do {
                        // for direct learning, add outcomes to the set of outcomes
                        for (int i = 0; i < numDirectDomains; i++) {
                                ((HashSet<String>) directDomainData[i]).add(rs
                                                .getString(directDomains[i].getName()));
                        }
                        // for clustering, gather all instances
                        for (int i = 0; i < numClusteredDomains; i++) {
                                Instance inst = new Instance(1);
                                inst.setValue(attrValue, rs
                                                .getDouble(clusteredDomains[i].nodeName));
                                clusterData[i].add(inst);
                        }
                } while (rs.next());
        }
        
        public void learn(Instances instances) throws Exception, SQLException {
                // if it's an empty result set, throw exception
                if(instances.numInstances() == 0)
                        throw new Exception("empty result set!");

                // gather domain data
                int numDirectDomains = directDomains != null ? directDomains.length : 0;
                int numClusteredDomains = clusteredDomains != null ? clusteredDomains.length : 0;
                Enumeration<Instance> instanceEnum = instances.enumerateInstances();
                while (instanceEnum.hasMoreElements()) {
                        Instance instance = instanceEnum.nextElement();
                        // for direct learning, add outcomes to the set of outcomes
                        for (int i = 0; i < numDirectDomains; i++) {
                                ((HashSet<String>) directDomainData[i]).add(instance.stringValue(
                                                instances.attribute(directDomains[i].getName())));
                        }
                        // for clustering, gather all instances
                        for (int i = 0; i < numClusteredDomains; i++) {
                                Instance inst = new Instance(1);
                                inst.setValue(attrValue, instance.value(
                                                instances.attribute(clusteredDomains[i].nodeName)));
                                clusterData[i].add(inst);
                        }
                }
        }
        
        public void learn(Map<String, String> data) throws Exception {
                int numDirectDomains = directDomains != null ? directDomains.length : 0;
                int numClusteredDomains = clusteredDomains != null ? clusteredDomains.length
                                : 0;

                // for direct learning, add outcomes to the set of outcomes
                for (int i = 0; i < numDirectDomains; i++) {
                        String val = data.get(directDomains[i]);
                        if (val == null)
                                throw new Exception("Key " + clusteredDomains[i].nodeName
                                                + " not found in data!");
                        ((HashSet<String>) directDomainData[i]).add(val);
                }
                // for clustering, gather all instances
                for (int i = 0; i < numClusteredDomains; i++) {
                        Instance inst = new Instance(1);
                        String val = data.get(clusteredDomains[i].nodeName);
                        if (val == null) {
                                boolean b = data.containsKey(clusteredDomains[i].nodeName);
                                throw new Exception("Key " + clusteredDomains[i].nodeName
                                                + " not found in data!");
                        }
                        inst.setValue(attrValue, Double.parseDouble(val));
                        clusterData[i].add(inst);
                }
        }

        /*
        public void learn(QueryResult res) throws Exception {
                int numDirectDomains = directDomains != null ? directDomains.length : 0;
                int numClusteredDomains = clusteredDomains != null ? clusteredDomains.length
                                : 0;

                // get column indices
                Vector colnames = res.getColumnNames();
                int[] colIdx_cd = new int[numClusteredDomains];
                int[] colIdx_dd = new int[numDirectDomains];
                for (int i = 0; i < numClusteredDomains; i++) {
                        colIdx_cd[i] = colnames.indexOf(clusteredDomains[i].nodeName);
                        if (colIdx_cd[i] == -1)
                                throw new Exception("Node/column "
                                                + clusteredDomains[i].nodeName
                                                + " was not found in result set");
                }
                for (int i = 0; i < numDirectDomains; i++) {
                        colIdx_dd[i] = colnames.indexOf(directDomains[i]);
                        if (colIdx_dd[i] == -1)
                                throw new Exception("Node/column " + directDomains[i]
                                                + " was not found in result set");
                }

                // gather data
                for (int i = 0; i < res.getRowCount(); i++) {
                        Vector<Object> row = new Vector<Object>();
                        for(Object r:res.getRow(i))
                                        row.add(r);
                        // for direct learning, add outcomes to the set of outcomes
                        for (int j = 0; j < numDirectDomains; j++) {
                                ((HashSet<String>) directDomainData[j]).add((String) row
                                                .get(colIdx_dd[j]));
                        }
                        // for clustering, gather all instances
                        for (int j = 0; j < numClusteredDomains; j++) {
                                Instance inst = new Instance(1);
                                double value = Double.parseDouble((String) row
                                                .get(colIdx_cd[j]));
                                inst.setValue(attrValue, value);
                                clusterData[j].add(inst);
                        }
                }
        }
        */

        protected void end_learning() throws Exception {
                if (directDomains != null)
                        for (int i = 0; i < directDomains.length; i++) {
                                if (verbose)
                                        System.out.println(directDomains[i]);
                                HashSet<String> hs = (HashSet<String>) directDomainData[i];
                                Discrete domain = new Discrete();
                                for (Iterator<String> iter = hs.iterator(); iter.hasNext();)
                                        domain.addName(iter.next());
                                BeliefNode node = directDomains[i];
                                if (node == null) {
                                        System.out.println("No node with name '" + directDomains[i]
                                                        + "' found to learn direct domain for.");
                                }
                                //System.out.println("DomainLearner: applying domain " + hs + " to " + node.getName());
                                bn.bn.changeBeliefNodeDomain(node, domain);
                        }
                if (clusteredDomains != null)
                        for (int i = 0; i < clusteredDomains.length; i++) {
                                if (verbose)
                                        System.out.println(clusteredDomains[i].nodeName);
                                try {
                                        // perform clustering
                                        clusterers[i] = new SimpleKMeans();
                                        if (clusteredDomains[i].numClusters != 0)
                                                clusterers[i]
                                                                .setNumClusters(clusteredDomains[i].numClusters);
                                        clusterers[i].buildClusterer(clusterData[i]);
                                        // update domain
                                        bn.bn.changeBeliefNodeDomain(bn
                                                        .getNode(clusteredDomains[i].nodeName),
                                                        new Discretized(clusterers[i], clusterNamer));
                                } catch (Exception e) {
                                        e.printStackTrace();
                                }
                        }
                if (duplicateDomains != null) {
                        for (int i = 0; i < duplicateDomains.length; i++) {
                                Domain srcDomain = bn.getDomain(duplicateDomains[i][0]);
                                for (int j = 1; j < duplicateDomains[i].length; j++) {
                                        if (verbose)
                                                System.out.println(duplicateDomains[i][j]);
                                        bn.bn.changeBeliefNodeDomain(bn
                                                        .getNode(duplicateDomains[i][j]), srcDomain);
                                }
                        }
                }
        }

        public SimpleKMeans[] getClusterers() throws Exception {
                finish(); // make sure learning is completed
                return clusterers;
        }

        public void sortClusteredDomains() {
                // process all nodes whose domains were subject to clustering
                for (int i = 0; i < clusteredDomains.length; i++) {
                        BeliefNode node = bn.getNode(clusteredDomains[i].nodeName);
                        sortClusteredDomain(node, clusterers[i]);
                }
                // 
                if (duplicateDomains != null) {
                        for (int i = 0; i < duplicateDomains.length; i++)
                                for (int j = 0; j < clusteredDomains.length; j++)
                                        if (duplicateDomains[i][0]
                                                        .equals(clusteredDomains[j].nodeName)) {
                                                for (int k = 1; k < duplicateDomains[i].length; k++)
                                                        sortClusteredDomain(bn
                                                                        .getNode(duplicateDomains[i][k]),
                                                                        clusterers[j]);
                                                break;
                                        }
                }
        }

        protected void sortClusteredDomain(BeliefNode node, SimpleKMeans clusterer) {
                // get domain sort order (sort by centroid, ascending),
                // i.e. get an unsorted and a sorted version of
                // the centroids array
                int numClusters = clusterer.getNumClusters();
                double[] values = clusterer.getClusterCentroids()
                                .attributeToDoubleArray(0);
                double[] sorted_values = (double[]) values.clone();
                Arrays.sort(sorted_values);
                // create new sorted domain
                Discrete domain = (Discrete) node.getDomain();
                Discrete sorted_domain = new Discrete();
                for (int new_idx = 0; new_idx < numClusters; new_idx++) {
                        for (int old_idx = 0; old_idx < numClusters; old_idx++)
                                if (values[old_idx] == sorted_values[new_idx])
                                        sorted_domain.addName(domain.getName(old_idx));
                }
                // apply new, sorted domain
                bn.bn.changeBeliefNodeDomain(node, sorted_domain);
        }
}

---

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