CPTLearner.java

Go to the documentation of this file.

package edu.tum.cs.bayesnets.learning;

//import de.tum.in.fipm.base.data.QueryResult;
import edu.ksu.cis.bnj.ver3.core.*;
import edu.ksu.cis.bnj.ver3.core.values.Field;
import edu.ksu.cis.bnj.ver3.core.values.ValueDouble;
import java.sql.*; 
import java.util.*;

import org.apache.log4j.Level;
import org.apache.log4j.Logger;

import edu.tum.cs.bayesnets.core.BeliefNetworkEx;
import edu.tum.cs.bayesnets.core.Discretized;

import weka.clusterers.*;
import weka.core.*;

public class CPTLearner extends Learner {
        static final Logger logger = Logger.getLogger(CPTLearner.class);
        static {
                logger.setLevel(Level.WARN);
        }
        
        protected ExampleCounter[] counters;
        protected Clusterer[] clusterers;
        protected boolean uniformDefault;
        
        public CPTLearner(BeliefNetworkEx bn) {
                super(bn);
                init();
        }
        
        public void setUniformDefault(boolean value) {
                uniformDefault = value;
        }
        
        public CPTLearner(DomainLearner dl) throws Exception {
                super(dl.bn.bn);
                init();
                // initialize clusterers from the domain learner
                if(dl.clusteredDomains != null) {       
                        for(int i = 0; i < dl.clusteredDomains.length; i++)
                                addClusterer(dl.clusteredDomains[i].nodeName, dl.clusterers[i]);
                        if(dl.duplicateDomains != null) {
                                for(int i = 0; i < dl.duplicateDomains.length; i++)
                                        for(int j = 0; j < dl.clusteredDomains.length; j++)
                                                if(dl.duplicateDomains[i][0].equals(dl.clusteredDomains[j].nodeName)) {
                                                        for(int k = 1; k < dl.duplicateDomains[i].length; k++)
                                                                addClusterer(dl.duplicateDomains[i][k], dl.clusterers[j]);                                      
                                                        break;
                                                }
                        }
                }
        }
        
        private void init() {
                uniformDefault = false;
                clusterers = new Clusterer[nodes.length];
        // create example counters for each node
        counters = new ExampleCounter[nodes.length];            
        for(int i = 0; i < nodes.length; i++)
                counters[i] = new ExampleCounter(nodes[i], bn);
        }
        
        public void learn(ResultSet rs) throws Exception {
        try {
                        // if it's an empty result set, throw exception
                        if(!rs.next())
                                throw new Exception("empty result set!");

                        BeliefNode[] nodes = bn.bn.getNodes();
                        ResultSetMetaData rsmd = rs.getMetaData();
                        int numCols = rsmd.getColumnCount();
                        // Now we can get much more nodes than attributes
//                      if(numCols != nodes.length)
//                              throw new Exception("Result does not contain suitable data (column count = " + numCols + "; node count = " + nodes.length + ")");
                        
                        // map node indices to result set column indices
                        int[] nodeIdx2colIdx = new int[nodes.length];
                        Arrays.fill(nodeIdx2colIdx, -1);
                        for(int i = 1; i <= numCols; i++) {
                                Set<String> nodeNames = bn.getNodeNamesForAttribute(rsmd.getColumnName(i));
                                for (String nodeName: nodeNames) {
                                        int node_idx = bn.getNodeIndex(nodeName);
                                        if(node_idx == -1)
                                                throw new Exception("Unknown node referenced in result set: " + rsmd.getColumnName(i));
                                        nodeIdx2colIdx[node_idx] = i;
                                }
                        }                       
                        
            // gather data, iterating over the result set
                        int[] domainIndices = new int[nodes.length];
            do {
                                // for each row...
                                // - get the indices into the domains of each node
                                //   that correspond to the current row of data
                                //   (sorted in the same order as the nodes are ordered
                                //   in the BeliefNetwork)                              
                                for(int node_idx = 0; node_idx < nodes.length; node_idx++) {
                                        int domain_idx;
                                        if(clusterers[node_idx] == null) {
                                                Discrete domain = (Discrete) nodes[node_idx].getDomain();

                                                String strValue;
                                                if (domain instanceof Discretized) {    // If we have a discretized domain we discretize first...
                                                        double value = rs.getDouble(nodeIdx2colIdx[node_idx]);
                                                        strValue = (((Discretized)domain).getNameFromContinuous(value));
                                                } else {
                                                        strValue = rs.getString(nodeIdx2colIdx[node_idx]);
                                                }
                                                domain_idx = domain.findName(strValue);
                                                if(domain_idx == -1)
                                                        throw new Exception(strValue + " not found in domain of " + nodes[node_idx].getName());                         
                                        }
                                        else {
                                                Instance inst = new Instance(1);
                                                double value = rs.getDouble(bn.getAttributeNameForNode(bn.bn.getNodes()[node_idx].getName()));
                                                inst.setValue(0, value);
                                                domain_idx = clusterers[node_idx].clusterInstance(inst);
                                        }
                                        domainIndices[node_idx] = domain_idx;
                                }
                // - update each node's CPT
                for(int i = 0; i < nodes.length; i++) {
                        counters[i].count(domainIndices);
                }
            } while(rs.next());
        } 
        catch (SQLException ex) { // handle any database errors             
            System.out.println("SQLException: " + ex.getMessage()); 
            System.out.println("SQLState: " + ex.getSQLState()); 
            System.out.println("VendorError: " + ex.getErrorCode()); 
        }
        }
        
        public void learn(Instances instances) throws Exception {
                // if it's an empty result set, throw exception
                if(instances.numInstances() == 0)
                        throw new Exception("empty result set!");

                BeliefNode[] nodes = bn.bn.getNodes();
                int numAttributes = instances.numAttributes();
                // Now we can get much more nodes than attributes
//              if(numAttributes != nodes.length)
//                      throw new Exception("Result does not contain suitable data (attribute count = " + numAttributes + "; node count = " + nodes.length + ")");
                
                // map node indices to attribute index
                int[] nodeIdx2colIdx = new int[nodes.length];
                Arrays.fill(nodeIdx2colIdx, -1);
                for(int i = 0; i < numAttributes; i++) {
                        Set<String> nodeNames = bn.getNodeNamesForAttribute(instances.attribute(i).name());
                        logger.debug("Nodes for attribute "+instances.attribute(i).name()+": "+nodeNames);
                        if (nodeNames==null)
                                continue;
                        for (String nodeName: nodeNames) {
                                int node_idx = bn.getNodeIndex(nodeName);
                                if(node_idx == -1)
                                        throw new Exception("Unknown node referenced in result set: " + instances.attribute(i).name());
                                nodeIdx2colIdx[node_idx] = i;
                        }
                }
                
        // gather data, iterating over the result set
                int[] domainIndices = new int[nodes.length];
        Enumeration<Instance> instanceEnum = instances.enumerateInstances();
        while (instanceEnum.hasMoreElements()) {
                Instance instance = instanceEnum.nextElement();
                        // for each row...
                        // - get the indices into the domains of each node
                        //   that correspond to the current row of data
                        //   (sorted in the same order as the nodes are ordered
                        //   in the BeliefNetwork)                              
                        for(int node_idx = 0; node_idx < nodes.length; node_idx++) {
                                int domain_idx;
                                if(clusterers[node_idx] == null) {
                                        Discrete domain = (Discrete) nodes[node_idx].getDomain();
                                        String strValue;
                                        if (domain instanceof Discretized) {    // If we have a discretized domain we discretize first...
                                                int colIdx = nodeIdx2colIdx[node_idx];
                                                if (colIdx < 0) {
                                                        bn.dump();
                                                        for (int i = 0; i < numAttributes; i++) {
                                                                logger.debug("Attribute "+i+": "+instances.attribute(i).name());
                                                        }
                                                        StringBuffer sb = new StringBuffer();
                                                        for (int i = 0; i < nodeIdx2colIdx.length; i++) {
                                                                sb.append(i+"\t");
                                                        }
                                                        sb.append("\n");
                                                        for (int i = 0; i < nodeIdx2colIdx.length; i++) {
                                                                sb.append(nodeIdx2colIdx[i]+"\t");
                                                        }
                                                        logger.debug(sb);
                                                        throw new Exception("No attribute specified for "+bn.bn.getNodes()[node_idx].getName());
                                                }
                                                double value = instance.value(colIdx);
                                                strValue = (((Discretized)domain).getNameFromContinuous(value));
                                                if (domain.findName(strValue) == -1) {
                                                        logger.debug(domain);
                                                        logger.debug(strValue);
                                                }
                                        } else {
                                                int colIdx = nodeIdx2colIdx[node_idx];
                                                if (colIdx < 0) {
                                                        throw new Exception("No attribute specified for "+bn.bn.getNodes()[node_idx].getName());
                                                }
                                                strValue = instance.stringValue(nodeIdx2colIdx[node_idx]);
                                        }
                                        domain_idx = domain.findName(strValue);
                                        if(domain_idx == -1) {
                                                String[] myDomain = bn.getDiscreteDomainAsArray(bn.bn.getNodes()[node_idx].getName());
                                                for (int i=0; i<myDomain.length; i++) {
                                                        logger.debug(myDomain[i]);
                                                }
                                                throw new Exception(strValue + " not found in domain of " + nodes[node_idx].getName());
                                        }
                                }
                                else {
                                        Instance inst = new Instance(1);
                                        inst.setValue(0, instance.value(nodeIdx2colIdx[node_idx]));
                                        domain_idx = clusterers[node_idx].clusterInstance(inst);
                                }
                                domainIndices[node_idx] = domain_idx;
                        }
                // - update each node's CPT
                for(int i = 0; i < nodes.length; i++) {
                        counters[i].count(domainIndices);
                }
        }
        }
                
        public void learn(Map<String,String> data) throws Exception {                                   
                // - get the indices into the domains of each node
                //   that correspond to the current row of data
                //   (sorted in the same order as the nodes are ordered
                //   in the BeliefNetwork)                              
                BeliefNode[] nodes = bn.bn.getNodes();
                int[] domainIndices = new int[nodes.length];
                for(int node_idx = 0; node_idx < nodes.length; node_idx++) {
                        int domain_idx;
                        String value = data.get(nodes[node_idx].getName());
                        if(value == null)
                                throw new Exception("Key " + nodes[node_idx].getName() + " not found in data!");
                        if(clusterers[node_idx] == null) {
                                Discrete domain = (Discrete) nodes[node_idx].getDomain();
                                domain_idx = domain.findName(value);
                                if(domain_idx == -1)
                                        throw new Exception(value + " not found in domain of " + nodes[node_idx].getName());                            
                        }
                        else {
                                Instance inst = new Instance(1);
                                inst.setValue(0, Double.parseDouble(value));
                                domain_idx = clusterers[node_idx].clusterInstance(inst);
                        }
                        domainIndices[node_idx] = domain_idx;
                }
        // - update each node's CPT
        for(int i = 0; i < nodes.length; i++) {
                counters[i].count(domainIndices);
        }
        }
        
        /*
        public void learn(QueryResult res) throws Exception {
                // map node indices to result set column indices
                Vector colnames = res.getColumnNames();
                int[] nodeIdx2colIdx = new int[nodes.length];
                for(int i = 0; i < nodes.length; i++) {
                        nodeIdx2colIdx[i] = colnames.indexOf(bn.getAttributeNameForNode(nodes[i].getName()));
                        if(nodeIdx2colIdx[i] == -1)
                                throw new Exception("Incomplete result set; missing: " + nodes[i].getName());                   
                }                       
                
        // gather data, iterating over the result set
                int[] domainIndices = new int[nodes.length];
                for(int k = 0; k < res.getRowCount(); k++) {
                        // for each row...
                        Vector<Object> row = new Vector<Object>();
                        for(Object r:res.getRow(k))
                                        row.add(r);
                        
                        // - get the indices into the domains of each node
                        //   that correspond to the current row of data
                        //   (sorted in the same order as the nodes are ordered
                        //   in the BeliefNetwork)                      
                        for(int node_idx = 0; node_idx < nodes.length; node_idx++) {
                                int domain_idx;
                                if(clusterers[node_idx] == null) {
                                        Discrete domain = (Discrete) nodes[node_idx].getDomain();
                                        String strValue;
                                        if (domain instanceof Discretized) {    // If we have a discretized domain we discretize first...
                                                double value = Double.parseDouble(row.get(nodeIdx2colIdx[node_idx]).toString());
                                                strValue = (((Discretized)domain).getNameFromContinuous(value));
                                        } else {
                                                strValue = row.get(nodeIdx2colIdx[node_idx]).toString();
                                        }
                                        domain_idx = domain.findName(strValue);
                                        if(domain_idx == -1)
                                                throw new Exception(strValue + " not found in domain of " + nodes[node_idx].getName());                         
                                }
                                else {
                                        Instance inst = new Instance(1);
                                        inst.setValue(0, Double.parseDouble((String)row.get(nodeIdx2colIdx[node_idx])));
                                        domain_idx = clusterers[node_idx].clusterInstance(inst);
                                }
                                domainIndices[node_idx] = domain_idx;
                        }
                // - update each node's CPT
                for(int i = 0; i < nodes.length; i++) {
                        counters[i].count(domainIndices);
                }
        }               
        }
        */
        
        public void addClusterer(String nodeName, Clusterer clusterer) throws Exception {
                for(int i = 0; i < nodes.length; i++)
                        if(nodes[i].getName().equals(nodeName)) {
                                clusterers[i] = clusterer;
                                return;
                        }
                throw new Exception("Passed unknown node name!");
        }
        
        protected void end_learning() {
        // normalize the CPTs
        for(int i = 0; i < nodes.length; i++)
                nodes[i].getCPF().normalizeByDomain(uniformDefault);
        }

        
        protected class ExampleCounter {
                CPF cpf;
                public int[] nodeIndices;

                public ExampleCounter(BeliefNode n, BeliefNetworkEx bn) {
                        // empty the cpf (initialize values to 0)
                        cpf = n.getCPF();                       
                        for(int i = 0; i < cpf.size(); i++)
                                cpf.put(i, new ValueDouble(0));
                        
                        // get the indices of the nodes that the CPT depends on
                        BeliefNode[] nodes = cpf.getDomainProduct();
                        nodeIndices = new int[nodes.length];
                        for(int i = 0; i < nodes.length; i++)
                                nodeIndices[i] = bn.getNodeIndex(nodes[i]);     
                }
                
                public ExampleCounter(CPF cpf, int[] nodeIndices) {
                        this.cpf = cpf;
                        this.nodeIndices = nodeIndices;
                }
        
                public void count(int[] domainIndices) {
                        count(domainIndices, 1.0);
                }
                
                public void count(int[] domainIndices, double weight) {
                        int[] addr = new int[nodeIndices.length];
                        
                        // get the address of the CPT field
                        for(int i = 0; i < nodeIndices.length; i++) {
                                addr[i] = domainIndices[nodeIndices[i]];
                        }
                        
                        // get the real address of the table entry
                        int realAddr = cpf.addr2realaddr(addr);
                        // add one to the entry
                        cpf.put(realAddr, Field.add(cpf.get(realAddr), new ValueDouble(weight)) );
                }
        }
}

---

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