MarkovLogicNetwork.java

Go to the documentation of this file.

package edu.tum.cs.srl.mln;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Set;
import java.util.TreeSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import edu.tum.cs.logic.Formula;
import edu.tum.cs.logic.parser.ParseException;
import edu.tum.cs.srl.Database;
import edu.tum.cs.srl.RelationKey;
import edu.tum.cs.srl.RelationalModel;
import edu.tum.cs.srl.Signature;
import edu.tum.cs.srl.taxonomy.Taxonomy;
import edu.tum.cs.tools.JythonInterpreter;
import edu.tum.cs.util.FileUtil;

public class MarkovLogicNetwork implements RelationalModel {

    protected File mlnFile;
    protected HashMap<Formula, Double> formula2weight;
    protected HashMap<String, Signature> signatures;
    protected HashMap<String, String[]> guaranteedDomainElements;
    protected HashMap<String, Integer> functionalPreds;
    double sumAbsWeights = 0;

    public MarkovLogicNetwork(String mlnFileLoc) throws Exception {
        this();
        read(mlnFile = new File(mlnFileLoc));
    }
    
    public MarkovLogicNetwork() {
        mlnFile = null;
        signatures = new HashMap<String, Signature>();
        functionalPreds = new HashMap<String, Integer>();        
        guaranteedDomainElements = new HashMap<String, String[]>();
        formula2weight = new HashMap<Formula, Double>();
    }
    
    public void addSignature(Signature sig) {
        signatures.put(sig.functionName, sig);
    }
    
    public void addFormula(Formula f, double weight) {
        this.formula2weight.put(f, weight);
    }
    
    public void addHardFormula(Formula f) {
        addFormula(f, getHardWeight());
    }
    
    public void addFunctionalDependency(String predicateName, Integer index) {
        this.functionalPreds.put(predicateName, index);
    }
    
    public void addGuaranteedDomainElements(String domain, String[] elements) {
        this.guaranteedDomainElements.put(domain, elements);
    }
    
    public Set<Formula> getFormulas() {
        return formula2weight.keySet();
    }

    public Signature getSignature(String predName) {
        return signatures.get(predName);
    }

    public Integer getFunctionallyDeterminedArgument(String predicateName) {
        return this.functionalPreds.get(predicateName);
    }

    public MarkovRandomField ground(Database db) throws Exception {
        return ground(db, true, null);
    }
    
    public MarkovRandomField ground(Database db, boolean storeFormulasInMRF, GroundingCallback gc) throws Exception {
        return new MarkovRandomField(this, db, storeFormulasInMRF, gc);
    }

    public void read(File mlnFile) throws Exception {
        String actLine;
        ArrayList<Formula> hardFormulas = new ArrayList<Formula>();
        
        // read the complete MLN-File and save it in a String
        String content = FileUtil.readTextFile(mlnFile);
        
        // remove all comments
        Pattern comments = Pattern.compile("//.*?$|/\\*.*?\\*/", Pattern.MULTILINE | Pattern.DOTALL);
        Matcher matcher = comments.matcher(content);
        content = matcher.replaceAll("");
        BufferedReader breader = new BufferedReader(new StringReader(content));

        String identifier = "\\w+";
        String constant = "(?:[A-Z]\\w*|[0-9]+)";
        // predicate declaration
        Pattern predDecl = Pattern.compile(String.format("(%s)\\(\\s*(%s!?(?:\\s*,\\s*%s!?)*)\\s*\\)", identifier, identifier, identifier));
        // domain declaration
        Pattern domDecl = Pattern.compile(String.format("(%s)\\s*=\\s*\\{\\s*(%s(?:\\s*,\\s*%s)*)\\s*\\}", identifier, constant, constant));
        
        JythonInterpreter jython = null;
        
        // parse line by line         
        for(actLine = breader.readLine(); breader != null && actLine != null; actLine = breader.readLine()) {
                String line = actLine.trim();
                if(line.length() == 0)
                continue;            

            // hard constraint
            if(line.endsWith(".")) {
                Formula f;
                String strF = line.substring(0, line.length() - 1);
                try {
                        f = Formula.fromString(strF);
                }
                catch(ParseException e) {
                        throw new Exception("The hard formula '" + strF + "' could not be parsed: " + e.toString());
                }
                hardFormulas.add(f);
                continue;
            } 
            
            // predicate declaration
            Matcher m = predDecl.matcher(line);
            if(m.matches()) {                 
                String predName = m.group(1);
                Signature sig = getSignature(predName);
                if(sig != null) {
                        throw new Exception(String.format("Signature declared in line '%s' was previously declared as '%s'", line, sig.toString()));
                }
                String[] argTypes = m.group(2).trim().split("\\s*,\\s*");
                for (int c = 0; c < argTypes.length; c++) {
                    // check whether it's a blockvariable
                    if(argTypes[c].endsWith("!")) {
                        argTypes[c] = argTypes[c].replace("!", "");
                        Integer oldValue = functionalPreds.put(predName, c);
                        if(oldValue != null)
                                throw new Exception(String.format("Predicate '%s' was declared to have more than one functionally determined parameter", predName));
                        break;
                    }
                }
                sig = new Signature(predName, "boolean", argTypes);
                addSignature(sig);
                continue;
            }
            
            // domain declaration
            m = domDecl.matcher(line);
            if(m.matches()) { 
                Pattern domName = Pattern.compile("[a-z]+\\w+");
                Pattern domCont = Pattern.compile("\\{(\\s*[A-Z]+\\w*\\s*,?)+\\}");
                Matcher mat = domName.matcher(line);
                Matcher mat2 = domCont.matcher(line);
                // parse entries of domain
                if (mat.find() && mat2.find()) {
                    String domarg = mat2.group(0).substring(1, mat2.group(0).length() - 1);
                    String[] cont = domarg.trim().split("\\s*,\\s*");
                    addGuaranteedDomainElements(mat.group(0), cont);
                }
                continue;
            }
            
            // must be a weighted formula
            int iSpace = line.indexOf(' ');
            if(iSpace == -1)
                throw new Exception("This line is not a correct declaration of a weighted formula: " + line);
            String strWeight = line.substring(0, iSpace);
            Double weight = null;
            try {
                weight = Double.parseDouble(strWeight);
            }            
            catch(NumberFormatException e) {
                if(jython == null) {
                        jython = new JythonInterpreter();
                        jython.exec("from math import *");
                        jython.exec("def logx(x):\n  if x == 0: return -100\n  return log(x)");
                }
                try {
                        weight = jython.evalDouble(strWeight);
                }
                catch(Exception e2) {
                        throw new Exception("Could not interpret weight '" + strWeight + "': " + e2.toString());
                }            
            }
            String strF = line.substring(iSpace+1).trim();
            Formula f;
            try {
                f = Formula.fromString(strF);
            }
            catch(ParseException e) {
                throw new Exception("The formula '" + strF + "' could not be parsed: " + e.toString());
            }
            addFormula(f, weight);
            sumAbsWeights += Math.abs(weight);
        }
        
        // assign weights to hard constraints
        double hardWeight = getHardWeight();
        for (Formula f : hardFormulas)
            addFormula(f, hardWeight);
    }

    public double getHardWeight() {
        return sumAbsWeights + 100;
    }

    public double getdeltaMin() {
        double deltaMin = Double.MAX_VALUE;
        TreeSet<Double> weight = new TreeSet<Double>();
        // add weights in a sorted TreeSet
        for(double d : formula2weight.values())
            weight.add(d);
        if(weight.size() == 1)
                return 1.0e-5;
        // calculate the smallest difference between consecutive weights
        while(weight.iterator().hasNext()) {
            Double d = weight.first();
            weight.remove(d);
            if (weight.iterator().hasNext()) {
                if (Math.abs(d - weight.first()) < deltaMin)
                    deltaMin = Math.abs(d - weight.first());
            }
        }
        return deltaMin;
    }

        public void replaceType(String oldType, String newType) {
                for(Signature sig : signatures.values()) 
                        sig.replaceType(oldType, newType);              
        }


    public HashMap<String, String[]> getGuaranteedDomainElements() {
        return guaranteedDomainElements;
    }

    public Collection<RelationKey> getRelationKeys(String relation) {
        // TODO     
        return null;
    }
    
    public Set<String> getFunctionalPreds() {
        return functionalPreds.keySet();
    }
    
    public Collection<Signature> getSignatures() {
        return this.signatures.values();
    }

        public Taxonomy getTaxonomy() {
                return null;
        }
        
        public void write(PrintStream out) {
                MLNWriter writer = new MLNWriter(out);
                
                // domain declarations
                if(this.guaranteedDomainElements.size() > 0) {
                        out.println("// domain declarations");
                        for(java.util.Map.Entry<String,String[]> e : this.getGuaranteedDomainElements().entrySet()) {
                                writer.writeDomainDecl(e.getKey(), e.getValue());                       
                        }
                        out.println();
                }
                
                // predicate declarations
                out.println("// predicate declarations");
                for(Signature sig : this.getSignatures()) {
                        writer.writePredicateDecl(sig, this.getFunctionallyDeterminedArgument(sig.functionName));
                }
                out.println();
                
                out.println("// formulas");
                for(Formula f : getFormulas()) {
                        double w = formula2weight.get(f);
                        out.printf("%f  %s\n", w, f.toString());
                }
        }
        
        public void write(File f) throws FileNotFoundException {
                write(new PrintStream(f));
        }

        @Override
        public Collection<String> getPrologRules() {
                return null;
        }
}

---

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