MarkovRandomField.java

Go to the documentation of this file.

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package edu.tum.cs.srl.mln;

import java.io.PrintStream;
import java.util.Iterator;
import java.util.Vector;

import edu.tum.cs.logic.Formula;
import edu.tum.cs.logic.GroundAtom;
import edu.tum.cs.logic.IPossibleWorld;
import edu.tum.cs.logic.WorldVariables;
import edu.tum.cs.logic.sat.weighted.WeightedFormula;
import edu.tum.cs.srl.AbstractVariable;
import edu.tum.cs.srl.Database;
import edu.tum.cs.srl.Signature;

public class MarkovRandomField implements Iterable<WeightedFormula> {
    protected Database db;
    public MarkovLogicNetwork mln;
    protected Vector<WeightedFormula> weightedFormulas;
    protected WorldVariables vars;
    protected final boolean simplifyGroundedFormulas = true;
    
    public MarkovRandomField(MarkovLogicNetwork mln, Database db, boolean storeFormulas, GroundingCallback gc) throws Exception {
        this.db = db;
        this.vars = new WorldVariables();
        this.mln = mln;        
        groundVariables();
        groundFormulas(storeFormulas, gc);
    }
    
    public MarkovRandomField(MarkovLogicNetwork mln, Database db) throws Exception {
        this(mln, db, true, null);
    }
    
    public WorldVariables getWorldVariables() {
        return vars;
    }
    
    protected void groundVariables() throws Exception {
        for(Signature sig : mln.getSignatures()) {
                groundVariables(sig, new String[sig.argTypes.length], 0, mln.getFunctionallyDeterminedArgument(sig.functionName));
        }
    }
    
    protected void groundVariables(Signature sig, String[] args, int i, Integer functionallyDeterminedArg) throws Exception {
        if(i == args.length) {
                if(functionallyDeterminedArg != null) {
                        // build the block of variables and check if we have positive evidence for one of them
                        Vector<GroundAtom> block = new Vector<GroundAtom>();
                        Iterable<String> dom = db.getDomain(sig.argTypes[functionallyDeterminedArg]);
                        GroundAtom trueOne = null;
                        for(String value : dom) {
                                args[functionallyDeterminedArg] = value;
                                GroundAtom ga = new GroundAtom(sig.functionName, args.clone()); 
                                block.add(ga);
                                AbstractVariable var = db.getVariable(ga.toString());
                                if(var != null && var.isTrue()) {
                                        if(trueOne != null)
                                                throw new Exception(String.format("The block the variable '%s' is in contains more than one true ground atom", ga.toString()));
                                        trueOne = ga; 
                                }
                        }
                        // if we have positive evidence, explicitly set the others to false in the database (to make full use of the evidence when grounding the formulas later on)
                        if(trueOne != null) {
                                for(GroundAtom ga : block)
                                        if(ga != trueOne && !db.contains(ga.toString()))
                                                db.addVariable(new Database.Variable(ga.predicate, ga.args, "False", mln));
                        }
                        // add the block to the set of vars
                        vars.addBlock(block);
                        //System.out.println("Block: " + block);
                }
                else {
                        vars.add(new GroundAtom(sig.functionName, args.clone()));
                }
                return;
        }       
        if(functionallyDeterminedArg != null && functionallyDeterminedArg.equals(i)) { // skip the functionally determined argument
                groundVariables(sig, args, i+1, functionallyDeterminedArg);             
        }
        else {
                Iterable<String> dom = db.getDomain(sig.argTypes[i]);
                if(dom == null)
                        throw new Exception("Domain '" + sig.argTypes[i] + "' not found in the database");
                for(String value : dom) {
                        args[i] = value;
                        groundVariables(sig, args, i+1, functionallyDeterminedArg);
                }
        }
    }
    
    protected void groundFormulas(boolean makelist, GroundingCallback gc) throws Exception {
        weightedFormulas = new Vector<WeightedFormula>();
        for(Formula form : mln.getFormulas()) {
                Double weight = mln.formula2weight.get(form);
                if(weight == null)
                        throw new Exception(String.format("MLN does not assign a weight to '%s'; mapped formulas are %s.", form.toString(), mln.formula2weight.keySet().toString()));
                boolean isHard = weight.equals(mln.getHardWeight());
            for(Formula gf : form.getAllGroundings(db, vars, simplifyGroundedFormulas)) {
                WeightedFormula wf = new WeightedFormula(gf, weight, isHard);
                if(makelist)
                    weightedFormulas.add(wf);
                if(gc != null)
                    gc.onGroundedFormula(wf, this);
            }
        }
    }
    
    public Database getDb() {
        return db;
    }

        public Iterator<WeightedFormula> iterator() {
                return weightedFormulas.iterator();
        }
        
        public void print(PrintStream out) {
                for(WeightedFormula wf : this)
                        out.println(wf.toString());
        }
        
        public double getWorldValue(IPossibleWorld w) {
                double s = 0;
                for(WeightedFormula wf : this)
                        if(wf.formula.isTrue(w))
                                s += wf.weight;
                return s;
        }
}

---

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