BeliefNetworkEx.java

Go to the documentation of this file.

package edu.tum.cs.bayesnets.core;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

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

import edu.ksu.cis.bnj.ver3.core.BeliefNetwork;
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.DiscreteEvidence;
import edu.ksu.cis.bnj.ver3.core.Domain;
import edu.ksu.cis.bnj.ver3.core.values.ValueDouble;
import edu.ksu.cis.bnj.ver3.inference.approximate.sampling.ForwardSampling;
import edu.ksu.cis.bnj.ver3.inference.exact.Pearl;
import edu.ksu.cis.bnj.ver3.plugin.IOPlugInLoader;
import edu.ksu.cis.bnj.ver3.streams.Exporter;
import edu.ksu.cis.bnj.ver3.streams.Importer;
import edu.ksu.cis.bnj.ver3.streams.OmniFormatV1_Reader;
import edu.ksu.cis.util.graph.algorithms.TopologicalSort;
import edu.ksu.cis.util.graph.core.Graph;
import edu.ksu.cis.util.graph.core.Vertex;
import edu.tum.cs.bayesnets.core.io.Converter_ergo;
import edu.tum.cs.bayesnets.core.io.Converter_hugin;
import edu.tum.cs.bayesnets.core.io.Converter_pmml;
import edu.tum.cs.bayesnets.core.io.Converter_xmlbif;
import edu.tum.cs.bayesnets.inference.WeightedSample;

public class BeliefNetworkEx {
        static final Logger logger = Logger.getLogger(BeliefNetworkEx.class);
        static {
                logger.setLevel(Level.WARN);
        }

        public static final int MAX_TRIALS = 5000;

        public BeliefNetwork bn;
        
        protected String filename;
        
        protected Map<String, String> nodeNameToAttributeMapping = new HashMap<String, String>();
        
        protected Map<String, Set<String>> attributeToNodeNameMapping = new HashMap<String, Set<String>>();
        
        public BeliefNetworkEx(BeliefNetwork bn) {
                this.bn = bn;
                initAttributeMapping();
        }
        
        public BeliefNetworkEx(String filename) throws Exception {
                this.bn = load(filename);
                initAttributeMapping();
                this.filename = filename;
        }
        
        public BeliefNetworkEx() {
                this.bn = new BeliefNetwork();
        }
        
        protected void initAttributeMapping() {
            for (BeliefNode node: bn.getNodes()) {
                        addAttributeMapping(node.getName(), node.getName());
            }
        }
        
        protected void addAttributeMapping(String nodeName, String attributeName) {
            nodeNameToAttributeMapping.put(nodeName, attributeName);
            Set<String> nodeNames = attributeToNodeNameMapping.get(attributeName);
            if (nodeNames == null) {
                nodeNames = new HashSet<String>();
                attributeToNodeNameMapping.put(attributeName, nodeNames);
            }
            nodeNames.add(nodeName);
        }
        
        public String getAttributeNameForNode(String nodeName) {
            return nodeNameToAttributeMapping.get(nodeName);
        }
        
        public Set<String> getNodeNamesForAttribute(String attributeName) {
                return attributeToNodeNameMapping.get(attributeName);
        }
        
        public void addNode(BeliefNode node) {
                bn.addBeliefNode(node);
                addAttributeMapping(node.getName(), node.getName());
        }
        
        public BeliefNode addDecisionNode(String name) {
                BeliefNode node = new BeliefNode(name, new Discrete(new String[]{"True", "False"}));
                node.setType(BeliefNode.NODE_DECISION);
                bn.addBeliefNode(node);
                return node;
        }

        
        public BeliefNode addNode(String name) {
                return addNode(name, new Discrete(new String[]{"True", "False"}));
        }
        
        public BeliefNode addNode(String name, Domain domain) {
                return addNode(name, domain, name);
        }
        
        public BeliefNode addNode(String name, Domain domain, String attributeName) {
                BeliefNode node = new BeliefNode(name, domain);
                bn.addBeliefNode(node);
                addAttributeMapping(name, attributeName);
                logger.debug("Added node "+name+" with attributeName "+attributeName);
                return node;
        }
        
        public void connect(String node1, String node2) throws Exception {
                try {
                        logger.debug("connecting "+node1+" and "+node2);
                        logger.debug("Memory free: "+Runtime.getRuntime().freeMemory()+"/"+Runtime.getRuntime().totalMemory());
                        BeliefNode n1 = getNode(node1);
                        BeliefNode n2 = getNode(node2);
                        if(n1 == null || n2 == null)
                                throw new Exception("One of the node names "+node1+" or "+node2+" is invalid!");
                        logger.debug("Domainsize: "+n1.getDomain().getOrder()+"x"+n2.getDomain().getOrder());
                        logger.debug("Doing the connect...");
                        bn.connect(n1, n2);
                        logger.debug("Memory free: "+Runtime.getRuntime().freeMemory()+"/"+Runtime.getRuntime().totalMemory());
                        logger.debug("Connection done.");
                } catch(Exception e) {
                        System.out.println("Exception occurred in connect!");
                        e.printStackTrace(System.out);
                        throw e;
                } catch(Error e2) {
                        System.out.println("Error occurred");
                        e2.printStackTrace(System.out);
                        throw e2;
                }
        }
        
        public void connect(BeliefNode parent, BeliefNode child, boolean adjustCPF) {
                Graph graph = bn.getGraph();
                graph.addDirectedEdge(parent.getOwner(), child.getOwner());
                if(adjustCPF) {
                        Vertex[] parents = graph.getParents(child.getOwner());
                        BeliefNode[] after = new BeliefNode[parents.length + 1];
                        for (int i = 0; i < parents.length; i++)
                        {
                                after[i + 1] = ((BeliefNode) parents[i].getObject());
                        }
                        after[0] = child;
                        CPF beforeCPF = child.getCPF();
                        child.setCPF(beforeCPF.expand(after));
                }
        }
        
        public void connect(BeliefNode parent, BeliefNode child) {
                connect(parent, child, true);
        }
        
        public BeliefNode getNode(String name) {
                int idx = getNodeIndex(name);
                if(idx == -1)
                        return null;
                return bn.getNodes()[idx];
        }
        
        public BeliefNode getNode(int idx) {
                return bn.getNodes()[idx];
        }
        
        public int getNodeIndex(String name) {
                BeliefNode[] nodes = bn.getNodes();
                for(int i = 0; i < nodes.length; i++)
                        if(nodes[i].getName().equals(name))
                                return i;
                return -1;              
        }
        
        public int[] getDomainProductNodeIndices(BeliefNode node) {
                BeliefNode[] nodes = node.getCPF().getDomainProduct();
                int[] nodeIndices = new int[nodes.length];
                for(int i = 0; i < nodes.length; i++)
                        nodeIndices[i] = this.getNodeIndex(nodes[i].getName());
                return nodeIndices;
        }
        
        public int[] getNodeDomainIndicesFromStrings(String[][] nodeAndDomains) {
                BeliefNode[] nodes = bn.getNodes(); 
                int[] nodeDomainIndices = new int[nodes.length];
                Arrays.fill(nodeDomainIndices, -1);
                for (String[] nodeAndDomain: nodeAndDomains) {
                        if (nodeAndDomain == null || nodeAndDomain.length != 2)
                                throw new IllegalArgumentException("Evidences not in the correct format: "+Arrays.toString(nodeAndDomain)+"!");
                        int nodeIdx = getNodeIndex(nodeAndDomain[0]);
                        if (nodeIdx < 0)
                                throw new IllegalArgumentException("Variable with the name "+nodeAndDomain[0]+" not found!");
                        if (nodeDomainIndices[nodeIdx] > 0)
                                logger.warn("Evidence "+nodeAndDomain[0]+" set twice!");
                        Discrete domain = (Discrete)nodes[nodeIdx].getDomain();
                        int domainIdx = domain.findName(nodeAndDomain[1]);
                        if (domainIdx < 0) {
                                if (domain instanceof Discretized) {
                                        try {
                                                double value = Double.parseDouble(nodeAndDomain[1]);
                                                String domainStr = ((Discretized)domain).getNameFromContinuous(value);
                                                domainIdx = domain.findName(domainStr);
                                        } catch (Exception e) {
                                                throw new IllegalArgumentException("Cannot find evidence value "+nodeAndDomain[1]+" in domain "+domain+"!");
                                        }
                                } else {
                                        throw new IllegalArgumentException("Cannot find evidence value "+nodeAndDomain[1]+" in domain "+domain+"!");
                                }
                        }
                        nodeDomainIndices[nodeIdx]=domainIdx;
                }
                return nodeDomainIndices;
        }
        
        public int getNodeIndex(BeliefNode node) {
                BeliefNode[] nodes = bn.getNodes();
                for(int i = 0; i < nodes.length; i++)
                        if(nodes[i] == node)
                                return i;
                return -1;
        }

        public void setEvidence(String nodeName, String outcome) throws Exception {
                BeliefNode node = getNode(nodeName);
                if(node == null)
                        throw new Exception("Invalid node reference: " + nodeName);
                Discrete domain = (Discrete) node.getDomain();
                int idx = domain.findName(outcome);
                if(idx == -1)
                        throw new Exception("Outcome " + outcome + " not in domain of " + nodeName);
                node.setEvidence(new DiscreteEvidence(idx));
        }
        
        public double getProbability(String[][] queries, String[][] evidences) throws Exception {
                // queries with only one query variable (i.e. Pr[X | A,B,...]) can be solved directly
                // ... for others, recursion is necessary
                if(queries.length == 1) { 
                        // remove any previous evidence
                        BeliefNode[] nodes = bn.getNodes();                     
                        for(int i = 0; i < nodes.length; i++)
                                nodes[i].setEvidence(null);
                        // set new evidence
                        if(evidences != null)
                                for(int i = 0; i < evidences.length; i++) {
                                        setEvidence(evidences[i][0], evidences[i][1]);                          
                                }
                        // run inference
                        Pearl inf = new Pearl();                
                        inf.run(this.bn);
                        // return result
                        BeliefNode node = getNode(queries[0][0]);
                        CPF cpf = inf.queryMarginal(node);
                        BeliefNode[] dp = cpf.getDomainProduct();
                        boolean done = false;
                        int[] addr = cpf.realaddr2addr(0);
                        while(!done) {
                                for (int i = 0; i < addr.length; i++)
                                        if(dp[i].getDomain().getName(addr[i]).equals(queries[0][1])) {
                                                ValueDouble v = (ValueDouble) cpf.get(addr);
                                                return v.getValue();                                            
                                        }
                                done = cpf.addOne(addr);
                        }
                        throw new Exception("Outcome not in domain!");
                        //inf.printResults();
                }
                else { // Pr[A,B,C,D | E] = Pr[A | B,C,D,E] * Pr[B,C,D | E]
                        String[][] _queries = new String[1][2];
                        String[][] _queries2 = new String[queries.length-1][2];
                        _queries[0] = queries[0];
                        int numEvidences = evidences == null ? 0 : evidences.length;
                        String[][] _evidences = new String[numEvidences+queries.length-1][2];
                        int idx = 0;
                        for(int i = 1; i < queries.length; i++, idx++) {
                                _evidences[idx] = queries[i];
                                _queries2[idx] = queries[i];
                        }
                        for(int i = 0; i < numEvidences; i++, idx++)
                                _evidences[idx] = evidences[i];
                        return getProbability(_queries, _evidences) * getProbability(_queries2, evidences);                     
                }
        }

        protected void printProbabilities(int node, Stack<String[]> evidence) throws Exception {
                BeliefNode[] nodes = bn.getNodes();
                if(node == nodes.length) {
                        String[][] e = new String[evidence.size()][];
                        evidence.toArray(e);
                        double prob = getProbability(e, null);
                        StringBuffer s = new StringBuffer();
                        s.append(String.format("%6.2f%%  ", 100*prob));
                        int i = 0;
                        for(String[] pair : evidence) {
                                if(i > 0)
                                        s.append(", ");
                                s.append(String.format("%s=%s", pair[0], pair[1]));
                                i++;
                        }
                        System.out.println(s);
                        return;
                }
                Domain dom = nodes[node].getDomain();
                for(int i = 0; i < dom.getOrder(); i++) {
                        evidence.push(new String[]{nodes[node].getName(), dom.getName(i)});
                        printProbabilities(node+1, evidence);
                        evidence.pop();
                }
        }
        
        public void printFullJoint() throws Exception {
                printProbabilities(0, new Stack<String[]>());
        }

        public void printDomain() {
                BeliefNode[] nodes = bn.getNodes();
                for(int i = 0; i < nodes.length; i++) {
                        System.out.print(nodes[i].getName());
                        Discrete domain = (Discrete)nodes[i].getDomain();
                        System.out.print(" {");
                        int c = domain.getOrder();
                        for(int j = 0; j < c; j++) {
                                if(j > 0) System.out.print(", ");
                                System.out.print(domain.getName(j));
                        }                       
                        System.out.println("}");
                }
        }
        
        public static BeliefNetwork load(String filename, Importer importer) throws FileNotFoundException {
                FileInputStream fis = new FileInputStream(filename);
                OmniFormatV1_Reader ofv1w = new OmniFormatV1_Reader();
                importer.load(fis, ofv1w);
                return ofv1w.GetBeliefNetwork(0);
        }
        
        public static BeliefNetwork load(String filename) throws Exception {
                registerDefaultPlugins();
                IOPlugInLoader iopl = IOPlugInLoader.getInstance();
                String ext = iopl.GetExt(filename);
                Importer imp = iopl.GetImporterByExt(ext);
                if(imp == null) 
                        throw new Exception("Unable to find an importer that can handle " + ext + " files.");
                return load(filename, imp);
        }
        
        public static void save(BeliefNetwork net, String filename) throws Exception {
                registerDefaultPlugins();
                IOPlugInLoader iopl = IOPlugInLoader.getInstance();
                String ext = iopl.GetExt(filename);
                Exporter exporter = iopl.GetExportersByExt(ext);
                if(exporter == null) 
                        throw new Exception("Unable to find an exporter that can handle " + ext + " files.");
                save(net, filename, exporter);
        }
        
        public static void save(BeliefNetwork net, String filename, Exporter exporter) throws FileNotFoundException {
                exporter.save(net, new FileOutputStream(filename));
                //OmniFormatV1_Writer.Write(net, (OmniFormatV1)exporter);
        }
        
        public void save(String filename) throws Exception {
                save(this.bn, filename);
        }
        
        public void save(String filename, Exporter exporter) throws FileNotFoundException {
                save(this.bn, filename, exporter);
        }

        public void saveXMLBIF(String filename) throws FileNotFoundException {
                save(filename, new Converter_xmlbif());
        }
        
        public void savePMML(String filename) throws FileNotFoundException {
                save(filename, new Converter_pmml());
        }
        
        public void save() throws Exception {
                IOPlugInLoader pil = IOPlugInLoader.getInstance();
                if(filename == null)
                        throw new Exception("Cannot save - filename not given!");
                Exporter exporter = pil.GetExportersByExt(pil.GetExt(filename));
                save(filename, exporter);
        }
        
        public void sortNodeDomain(String nodeName, boolean numeric) throws Exception {
                BeliefNode node = getNode(nodeName);
                if(node == null)
                        throw new Exception("Node not found");
                Discrete domain = (Discrete)node.getDomain();
                int ord = domain.getOrder();
                String[] strings = new String[ord];
                if(!numeric) {                  
                        for(int i = 0; i < ord; i++)
                                strings[i] = domain.getName(i);
                        Arrays.sort(strings);                   
                }
                else {
                        double[] values = new double[ord];
                        for(int i = 0; i < ord; i++)
                                values[i] = Double.parseDouble(domain.getName(i));
                        double[] sorted_values = values.clone();                        
                        Arrays.sort(sorted_values);                     
                        for(int i = 0; i < ord; i++)
                                for(int j = 0; j < ord; j++)
                                        if(sorted_values[i] == values[j])
                                                strings[i] = domain.getName(j);                 
                }
                bn.changeBeliefNodeDomain(node, new Discrete(strings));
        }
        
        public Domain getDomain(String nodeName) {
                BeliefNode node = getNode(nodeName);
                if(node == null)
                        return null;
                return node.getDomain();
        }
        
        public void show() {
                registerDefaultPlugins();               
                edu.ksu.cis.bnj.gui.GUIWindow window = new edu.ksu.cis.bnj.gui.GUIWindow();
                window.register();      
                window.open(bn, filename);
        }
        
        public static void registerDefaultPlugins() {
                IOPlugInLoader iopl = IOPlugInLoader.getInstance();
                // XML-BIF
                Converter_xmlbif xmlbif = new Converter_xmlbif();
                iopl.addPlugin(xmlbif, xmlbif);
                // PMML
                Converter_pmml pmml = new Converter_pmml();
                iopl.addPlugin(pmml, pmml);
                // Hugin
                Converter_hugin hugin = new Converter_hugin();
                iopl.addPlugin(null, hugin);
                // Ergo
                Converter_ergo ergo = new Converter_ergo();
                iopl.addPlugin(ergo, null);
        }
        
        public void show(String pluginDir) {
                IOPlugInLoader iopl = IOPlugInLoader.getInstance();
                iopl.loadPlugins(pluginDir);
                show();
        }
        
        protected static String[][] readList(String list) throws java.lang.Exception {
                if(list == null)
                        return null;
                String[] items = list.split(",");
                String[][] res = new String[items.length][2];
                for(int i = 0; i < items.length; i++) {
                        res[i] = items[i].split("=");
                        if(res[i].length != 2)
                                throw new java.lang.Exception("syntax error!");
                }
                return res;
        }

        public void queryShell() {
                // output some usage information
                System.out.println("Domain:");
                printDomain();
                System.out.println("\nUsage: Pr[X=x, Y=y, ... | E=e, F=f, ...]   (X,Y: query vars;\n" +
                                                     "                                            E,F: evidence vars;\n" +
                                                     "                                            x,y,e,f: outcomes\n" + 
                                             "       exit                                (close shell)");
                
                BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 
            for(;;) {   
                        try {
                                // get input query from stdin 
                                System.out.print("\n> ");                       
                            String input = br.readLine(); 
                                
                                if(input.equalsIgnoreCase("exit"))
                                        break;
                        
                                // parse expression...
                                input = input.replaceAll("\\s+", "");
                                Pattern p = Pattern.compile("Pr\\[([^\\]\\|]*)(?:\\|([^\\]]*))?\\]");           
                                Matcher m = p.matcher(input);
                                if(!m.matches()) {
                                        System.out.println("syntax error!");
                                }
                                else {
                                        String[][] queries = readList(m.group(1));
                                        String[][] evidences = readList(m.group(2));
                                        try {
                                                // evaluate and output result...
                                                double result = getProbability(queries, evidences);
                                                System.out.println(result);
                                        }
                                        catch(Exception e) {
                                                System.out.println(e.getMessage());
                                        }
                                }
                        }
                        catch(IOException e) {
                                System.err.println(e.getMessage());
                        }
                        catch(java.lang.Exception e) {
                                System.out.println(e.getMessage());
                        }
            }
        }
        
        public WeightedSample[] getAssignmentDistribution(String[][] evidences, String[] queryNodeNames, int numSamples) throws Exception {
                HashMap<WeightedSample, Double> sampleSums = new HashMap<WeightedSample, Double>();

                int[] queryNodes = new int[queryNodeNames.length];
                for (int i=0; i<queryNodeNames.length; i++) {
                        queryNodes[i]=getNodeIndex(queryNodeNames[i]);
                        if (queryNodes[i] < 0)
                                throw new IllegalArgumentException("Cannot find node with name "+queryNodeNames[i]);
                }

                Random generator = new Random();
                for (int i=0; i<numSamples; i++) {
                        WeightedSample sample = getWeightedSample(evidences, generator);
                        if (sample == null && i == 0)   // If we need too many trials and we have no samples 
                                return null;                            // it will be very probable that we have an endless loop because of a bad evidence!
                        WeightedSample subSample = sample.subSample(queryNodes);

                        if (sampleSums.containsKey(subSample)) {
                                sampleSums.put(subSample, sampleSums.get(subSample)+subSample.weight);
                        } else {
                                sampleSums.put(subSample, subSample.weight);
                        }
                }

                double sum = 0;
                for (WeightedSample sample: sampleSums.keySet()) {
                        logger.debug(sample);
                        double value = sampleSums.get(sample);
                        sum += value;
                }
                WeightedSample[] samples = sampleSums.keySet().toArray(new WeightedSample[0]);
                for (WeightedSample sample: samples) {
                        sample.weight = sampleSums.get(sample)/sum;
                }
                
                Arrays.sort(samples, new Comparator<WeightedSample>() {
                        public int compare(WeightedSample o1, WeightedSample o2) {
                                return Double.compare(o2.weight, o1.weight);
                        }
                });

                return samples;
        }
        
        public int[] getTopologicalOrder() {
                TopologicalSort topsort = new TopologicalSort();
                topsort.execute(bn.getGraph());
                return topsort.alpha;
        }
        
        public double getCPTProbability(BeliefNode node, int[] nodeDomainIndices ) {
                CPF cpf = node.getCPF();
                int[] domainProduct = getDomainProductNodeIndices(node);
                int[] address = new int[domainProduct.length];
                for (int i=0; i<address.length; i++) {
                        address[i]=nodeDomainIndices[domainProduct[i]];
                }
                int realAddress = cpf.addr2realaddr(address);
                return cpf.getDouble(realAddress);
        }
        
        public void removeAllEvidences() {
                // remove evidences (restoring original state)
                for(BeliefNode node : bn.getNodes()) {
                        node.setEvidence(null);
                }
        }
        
        public double getSampledProbability(String[][] queries, String[][] evidences, int numSamples) throws Exception {
            String[] queryNodes = new String[queries.length];
            for (int i=0; i<queryNodes.length; i++) {
                queryNodes[i]=queries[i][0];
            }
            WeightedSample[] samples = getAssignmentDistribution(evidences, queryNodes, numSamples);
            double goodSum = 0;
            double allSum = 0;
            for (int i=0; i<samples.length; i++) {
                        allSum += samples[i].weight;
                        if (samples[i].checkAssignment(queries))
                            goodSum += samples[i].weight;
            }
            return goodSum/allSum;
        }
        
        public WeightedSample getWeightedSample(String[][] evidences, Random generator) throws Exception {              
                if (generator == null) {
                        generator = new Random();
                }               
                return getWeightedSample(getTopologicalOrder(), evidence2DomainIndices(evidences), generator);
        }
        
        public WeightedSample getWeightedSample(int[] nodeOrder, int[] evidenceDomainIndices, Random generator) throws Exception {
                BeliefNode[] nodes = bn.getNodes();
                int[] sampleDomainIndices  = new int[nodes.length];
                boolean successful = false;
                double weight = 1.0;
                int trials=0;
success:while (!successful) {
                        //System.out.println(trials);
                        weight = 1.0;
                        if (trials > MAX_TRIALS)
                                return null;
                        for (int i=0; i< nodeOrder.length; i++) {
                                int nodeIdx = nodeOrder[i];
                                int domainIdx = evidenceDomainIndices[nodeIdx];
                                if (domainIdx >= 0) { // This is an evidence node?
                                        sampleDomainIndices[nodeIdx] = domainIdx;
                                        nodes[nodeIdx].setEvidence(new DiscreteEvidence(domainIdx));
                                        // TODO this call is inefficient
                                        double prob = getCPTProbability(nodes[nodeIdx], sampleDomainIndices);
                                        if (prob == 0.0) {
                                                //System.out.println("sampling failed at evidence node " + nodes[nodeIdx].getName());
                                                removeAllEvidences();
                                                trials++;
                                                continue success;
                                        }
                                        weight *= prob;
                                } else {
                                        domainIdx = ForwardSampling.sampleForward(nodes[nodeIdx], bn, generator);
                                        if (domainIdx < 0) {
                                                System.out.println("could not sample forward because of column with 0s in CPT of " + nodes[nodeIdx].getName());
                                                removeAllEvidences();
                                                trials++;
                                                continue success;
                                        }
                                        sampleDomainIndices[nodeIdx] = domainIdx;
                                        nodes[nodeIdx].setEvidence(new DiscreteEvidence(domainIdx));
                                }
                        }
                        trials++;
                        removeAllEvidences();
                        successful = true;
                }
                return new WeightedSample(this, sampleDomainIndices, weight, null, trials);             
        }
        
        public int[] evidence2DomainIndices(String[][] evidences) {
                BeliefNode[] nodes = bn.getNodes();
                int[] evidenceDomainIndices = new int[nodes.length];
                Arrays.fill(evidenceDomainIndices, -1);
                for (String[] evidence: evidences) {
                        if (evidence == null || evidence.length != 2)
                                throw new IllegalArgumentException("Evidences not in the correct format: "+Arrays.toString(evidence)+"!");
                        int nodeIdx = getNodeIndex(evidence[0]);
                        if (nodeIdx < 0) {
                                String error = "Variable with the name "+evidence[0]+" not found in model but mentioned in evidence!";
                                System.err.println("Warning: " + error);
                                continue;
                                //throw new IllegalArgumentException(error);
                        }
                        if (evidenceDomainIndices[nodeIdx] > 0)
                                logger.warn("Evidence "+evidence[0]+" set twice!");
                        Discrete domain = (Discrete)nodes[nodeIdx].getDomain();
                        int domainIdx = domain.findName(evidence[1]);
                        if (domainIdx < 0) {
                                if (domain instanceof Discretized) {
                                        try {
                                                double value = Double.parseDouble(evidence[1]);
                                                String domainStr = ((Discretized)domain).getNameFromContinuous(value);
                                                domainIdx = domain.findName(domainStr);
                                        } catch (Exception e) {
                                                throw new IllegalArgumentException("Cannot find evidence value "+evidence[1]+" in domain "+domain+"!");
                                        }
                                } 
                                else {
                                        throw new IllegalArgumentException("Cannot find evidence value "+evidence[1]+" in domain "+domain+" of node " + nodes[nodeIdx].getName());
                                }
                        }
                        evidenceDomainIndices[nodeIdx]=domainIdx;
                }
                return evidenceDomainIndices;
        }

        public HashMap<String,String> getSample(Random generator) throws Exception {
                if(generator == null)
                        generator = new Random();
                HashMap<String,String> ret = new HashMap<String,String>();
                // perform topological sort to determine sampling order
                TopologicalSort topsort = new TopologicalSort();
                topsort.execute(bn.getGraph());
                int[] order = topsort.alpha;
                // sample
                BeliefNode[] nodes = bn.getNodes();
                boolean succeeded = false;
                while(!succeeded) {
                        ArrayList<BeliefNode> setEvidences = new ArrayList<BeliefNode>(); // remember nodes for which we set evidences while sampling
                        for(int i = 0; i < order.length; i++) {
                                BeliefNode node = nodes[order[i]];
                                if(node.hasEvidence()) {
                                        throw new Exception("At least one node has evidence. You can only sample from the marginal distribution!");
                                }
                                int idxValue = ForwardSampling.sampleForward(node, bn, generator);                      
                                if(idxValue == -1) {
                                        // sampling node failed - most probably because the distribution was all 0 values -> retry from start
                                        succeeded = false;
                                        break;
                                }
                                succeeded = true;
                                Domain dom = node.getDomain();
                                //System.out.println("set node " + node.getName() + " to " + dom.getName(idxValue));
                                ret.put(node.getName(), dom.getName(idxValue));
                                node.setEvidence(new DiscreteEvidence(idxValue));
                                setEvidences.add(node);                         
                        }
                        // remove evidences (restoring original state)
                        for(BeliefNode node : setEvidences) {
                                node.setEvidence(null);
                        }
                }
                return ret;
        }
        
        public static String[] getDiscreteDomainAsArray(BeliefNode node) {
                Discrete domain = (Discrete)node.getDomain();
                String[] ret = new String[domain.getOrder()];
                for(int i = 0; i < ret.length; i++)
                        ret[i] = domain.getName(i);
                return ret;             
        }
        
        public String[] getDiscreteDomainAsArray(String nodeName) {
                return getDiscreteDomainAsArray(getNode(nodeName));
        }
        
        public void dump() {
                BeliefNode[] nodes = bn.getNodes();
                for (int i=0; i<nodes.length; i++) {
                        logger.debug("Node "+i+": "+nodes[i].getName());
                        logger.debug("\tAttribute: "+getAttributeNameForNode(nodes[i].getName()));
                }
                for (String attributeName: attributeToNodeNameMapping.keySet()) {
                        logger.debug("Attribute "+attributeName+": "+attributeToNodeNameMapping.get(attributeName));
                }
        }

        public abstract class CPTWalker {
                public abstract void tellSize(int childConfigs, int parentConfigs);
                public abstract void tellNodeOrder(BeliefNode n);               
                public abstract void tellValue(double v);
        }
        
        public void walkCPT(BeliefNode node, CPTWalker walker) {
                CPF cpf = node.getCPF();
                BeliefNode[] nodes = cpf.getDomainProduct();
                int parentConfigs = 1;
                for(int i = 1; i < nodes.length; i++)
                        parentConfigs *= nodes[i].getDomain().getOrder();
                walker.tellSize(nodes[0].getDomain().getOrder(), parentConfigs);
                int[] addr = new int[cpf.getDomainProduct().length];
                walkCPT(walker, cpf, addr, 0);
        }
        
        protected void walkCPT(CPTWalker walker, CPF cpf, int[] addr, int i) {
                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();
                        walker.tellValue(value);
                }
                else { // the address is yet incomplete -> consider all ways of setting the next e
                        walker.tellNodeOrder(nodes[i]);
                        Discrete dom = (Discrete)nodes[i].getDomain();
                        for(int j = 0; j < dom.getOrder(); j++) {
                                addr[i] = j;
                                walkCPT(walker, cpf, addr, i+1);
                        }
                }
        }
        
        public int getDomainIndex(BeliefNode node, String value) {
                Discrete domain = (Discrete)node.getDomain();
                return domain.findName(value);
        }

        public HashMap<BeliefNode, double[]> computePriors(int[] evidenceDomainIndices) {
                HashMap<BeliefNode, double[]> priors = new HashMap<BeliefNode, double[]>();
                BeliefNode[] nodes = bn.getNodes();
                int[] topOrder = getTopologicalOrder();
                for(int i : topOrder) {
                        BeliefNode node = nodes[i];
                        double[] dist = new double[node.getDomain().getOrder()];
                        int evidence = evidenceDomainIndices != null ? evidenceDomainIndices[i] : -1;
                        if(evidence >= 0) {
                                for(int j = 0; j < dist.length; j++)
                                        dist[j] = evidence == j ? 1.0 : 0.0;
                        }
                        else {
                                CPF cpf = node.getCPF();
                                computePrior(priors, evidenceDomainIndices, cpf, 0, new int[cpf.getDomainProduct().length], dist);
                        }
                        priors.put(node, dist);
                }
                return priors;
        }
        
        protected void computePrior(HashMap<BeliefNode, double[]> priors, int[] evidenceDomainIndices, CPF cpf, int i, int[] addr, double[] dist) {
                BeliefNode[] domProd = cpf.getDomainProduct(); 
                if(i == addr.length) {
                        double p = cpf.getDouble(addr); // p = P(node setting | parent configuration)
                        for(int j = 1; j < addr.length; j++) {
                                double[] parentPrior = priors.get(domProd[j]);
                                p *= parentPrior[addr[j]]; 
                        } // p = P(node setting, parent configuration)
                        dist[addr[0]] += p;
                        return;
                }
                BeliefNode node = domProd[i];
                int nodeIdx = getNodeIndex(node);
                if(evidenceDomainIndices[nodeIdx] >= 0) {
                        addr[i] = evidenceDomainIndices[nodeIdx];
                        computePrior(priors, evidenceDomainIndices, cpf, i+1, addr, dist);
                }
                else {
                        Domain dom = node.getDomain();
                        for(int j = 0; j < dom.getOrder(); j++) {
                                addr[i] = j;
                                computePrior(priors, evidenceDomainIndices, cpf, i+1, addr, dist);
                        }
                }
        }
        
        public double getWorldProbability(int[] nodeDomainIndices) {
                BeliefNode[] nodes = bn.getNodes();
                double ret = 1.0;
                for(int i = 0; i < nodes.length; i++)
                        ret *= getCPTProbability(nodes[i], nodeDomainIndices);
                return ret;
        }
        
        public BeliefNode[] getNodes() {
                return bn.getNodes();
        }
        
        public double getNumWorlds() {
                double num = 1;
                for(BeliefNode n : getNodes())
                        num *= n.getDomain().getOrder();
                return num;
        }
}

---

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