PSL basic-example using an existing database

BasicExampleReuse2.groovy

import java.text.DecimalFormat

import edu.umd.cs.psl.application.inference.MPEInference
import edu.umd.cs.psl.config.*
import edu.umd.cs.psl.database.DataStore
import edu.umd.cs.psl.database.Database
import edu.umd.cs.psl.database.Partition
import edu.umd.cs.psl.database.rdbms.RDBMSDataStore
import edu.umd.cs.psl.database.rdbms.driver.H2DatabaseDriver
import edu.umd.cs.psl.database.rdbms.driver.H2DatabaseDriver.Type
import edu.umd.cs.psl.groovy.PSLModel
import edu.umd.cs.psl.groovy.PredicateConstraint
import edu.umd.cs.psl.model.argument.ArgumentType
import edu.umd.cs.psl.model.argument.GroundTerm
import edu.umd.cs.psl.model.atom.GroundAtom
import edu.umd.cs.psl.ui.functions.textsimilarity.*
import edu.umd.cs.psl.util.database.Queries

ConfigManager cm = ConfigManager.getManager()
ConfigBundle config = cm.getBundle("basic-example")

def defaultPath = System.getProperty("java.io.tmpdir")
String dbpath = config.getString("dbpath", defaultPath + File.separator + "basic-example")
DataStore data = new RDBMSDataStore(new H2DatabaseDriver(Type.Disk, dbpath, false), config)

PSLModel m = new PSLModel(this, data)

m.add predicate: "Network",    types: [ArgumentType.UniqueID, ArgumentType.UniqueID]
m.add predicate: "Name",       types: [ArgumentType.UniqueID, ArgumentType.String]
m.add predicate: "Knows",      types: [ArgumentType.UniqueID, ArgumentType.UniqueID]
m.add predicate: "SamePerson", types: [ArgumentType.UniqueID, ArgumentType.UniqueID]

m.add function: "SameName" , implementation: new LevenshteinSimilarity()

GroundTerm snA = data.getUniqueID(1);
GroundTerm snB = data.getUniqueID(2);

m.add rule : ( Network(A, snA) & Network(B, snB) & Name(A,X) & Name(B,Y)
& SameName(X,Y) ) >> SamePerson(A,B),  weight : 5

m.add rule : ( Network(A, snA) & Network(B, snB) & SamePerson(A,B) & Knows(A, Friend1)
& Knows(B, Friend2) ) >> SamePerson(Friend1, Friend2) , weight : 3.2

m.add PredicateConstraint.PartialFunctional, on : SamePerson
m.add PredicateConstraint.PartialInverseFunctional, on : SamePerson
m.add PredicateConstraint.Symmetric, on : SamePerson

m.add rule: ~SamePerson(A,B), weight: 1

println m;

def evidencePartition = new Partition(0);
def targetPartition = new Partition(1);
Database db = data.getDatabase(targetPartition, [Network, Name, Knows] as Set, evidencePartition);

MPEInference inferenceApp = new MPEInference(m, db, config);
inferenceApp.mpeInference();
inferenceApp.close();

println "Inference results with hand-defined weights:"
DecimalFormat formatter = new DecimalFormat("#.##");
for (GroundAtom atom : Queries.getAllAtoms(db, SamePerson))
    println atom.toString() + "\t" + formatter.format(atom.getValue());

db.close();