CPTDecTree.java

Go to the documentation of this file.

import java.io.FileNotFoundException;
import java.util.HashMap;
import java.util.Set;
import java.util.TreeSet;
import java.util.Vector;

import weka.classifiers.trees.J48;
import weka.core.Attribute;
import weka.core.FastVector;
import weka.core.Instance;
import weka.core.Instances;

import edu.ksu.cis.bnj.ver3.core.BeliefNode;
import edu.ksu.cis.bnj.ver3.core.CPF;
import edu.ksu.cis.bnj.ver3.core.Discrete;
import edu.ksu.cis.bnj.ver3.core.values.ValueDouble;
import edu.tum.cs.bayesnets.core.BeliefNetworkEx;
import edu.tum.cs.srl.bayesnets.CPT2MLNFormulas;
import edu.tum.cs.srl.bayesnets.RelationalBeliefNetwork;


public class CPTDecTree {

        public static void main(String[] args) {
                try {
                        RelationalBeliefNetwork bn = new RelationalBeliefNetwork("actseq.xml");
                        
                        CPT2MLNFormulas cpt2mln = new CPT2MLNFormulas(bn.getRelationalNode("performs(p,a2,s2)"));
                        cpt2mln.convert(System.out);
                        System.exit(0);
                        
                        FastVector fvAttribs = new FastVector(bn.bn.getNodes().length+1);
                        HashMap<String, Attribute> attrs = new HashMap<String, Attribute>();
                        for(BeliefNode node : bn.bn.getNodes()) {                               
                                Discrete dom = (Discrete)node.getDomain();
                                FastVector attValues = new FastVector(dom.getOrder());
                                for(int i = 0; i < dom.getOrder(); i++)
                                        attValues.addElement(dom.getName(i));
                                Attribute attr = new Attribute(node.getName(), attValues);                              
                                attrs.put(node.getName(), attr);
                                fvAttribs.addElement(attr);
                        }
                        
                        BeliefNode node = bn.getNode("performs(p,a2,s2)");
                
                        // add class attribute
                        // - collect values
                        CPF cpf = node.getCPF();
                        TreeSet<Double> probs = new TreeSet<Double>();
                        walkCPT2(cpf, new int[bn.bn.getNodes().length], 0, probs);
                        FastVector attrValues = new FastVector(probs.size());
                        for(Double d : probs) 
                                attrValues.addElement(Double.toString(d));
                        // - add
                        Attribute probAttr = new Attribute("prob", attrValues);
                        attrs.put("prob", probAttr);
                        fvAttribs.addElement(probAttr);                 

                        Instances instances = new Instances(node.getName(), fvAttribs, 60000);

                        
                        // add all 55000 instances
                        walkCPT(node.getCPF(), new int[bn.bn.getNodes().length], 0, instances, attrs);
                        
                        // learn the J48 decision tree from the instances
                        instances.setClass(attrs.get("prob"));
                        J48 j48 = new J48();
                        j48.setUnpruned(true);
                        j48.setMinNumObj(0); // there is no minimum number of objects for the tree's leaf nodes 
                        j48.buildClassifier(instances);         
                        
                        // output the decision tree
                        System.out.println(j48);                        
                } 
                catch (Exception e) {                   
                        e.printStackTrace();
                }               
        }
        
        public static void walkCPT(CPF cpf, int[] addr, int i, Instances instances, HashMap<String, Attribute> attrs) {
                BeliefNode[] nodes = cpf.getDomainProduct();
                if(i == addr.length) { // we have a complete address
                        // get the probability value
                        int realAddr = cpf.addr2realaddr(addr);
                        double value = ((ValueDouble)cpf.get(realAddr)).getValue();
                        
                        // create a new instance
                        Instance inst = new Instance(nodes.length+1);
                        
                        // translate the address to attributes
                        for(int j = 0; j < addr.length; j++) {
                                Discrete dom = (Discrete)nodes[j].getDomain();
                                inst.setValue(attrs.get(nodes[j].getName()), dom.getName(addr[j]));
                        }
                        // add attribute for actual value (which is predicted)
                        inst.setValue(attrs.get("prob"), Double.toString(value));
                        
                        // add the instance to the instances
                        instances.add(inst);
                }
                else { // the address is yet incomplete -> consider all ways of setting the next e
                        Discrete dom = (Discrete)nodes[i].getDomain();
                        for(int j = 0; j < dom.getOrder(); j++) {
                                addr[i] = j;
                                walkCPT(cpf, addr, i+1, instances, attrs);
                        }
                }       
        }

        public static void walkCPT2(CPF cpf, int[] addr, int i, Set<Double> values) {
                BeliefNode[] nodes = cpf.getDomainProduct();
                if(i == addr.length) { // we have a complete address
                        // get the probability value
                        int realAddr = cpf.addr2realaddr(addr);
                        double value = ((ValueDouble)cpf.get(realAddr)).getValue();
                        values.add(value);
                }
                else { // the address is yet incomplete -> consider all ways of setting the next e
                        Discrete dom = (Discrete)nodes[i].getDomain();
                        for(int j = 0; j < dom.getOrder(); j++) {
                                addr[i] = j;
                                walkCPT2(cpf, addr, i+1, values);
                        }
                }       
        }
}

---

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