public static void main(String[] args) throws Exception { TestSuite theSuite; if (args.length > 0) { theSuite = new TestSuite(); for (int i = 0; i < args.length; i++) { theSuite.addTest(new TestInference(args[i])); } } else { theSuite = (TestSuite) suite(); } junit.textui.TestRunner.run(theSuite); }
public void testSumLogProb () { java.util.Random rand = new java.util.Random (3214123); for (int i = 0; i < 10; i++) { double v1 = rand.nextDouble(); double v2 = rand.nextDouble(); double sum1 = Math.log (v1 + v2); double sum2 = Maths.sumLogProb (Math.log(v1), Math.log (v2)); // System.out.println("Summing "+v1+" + "+v2); assertEquals (sum1, sum2, 0.00001); } }
public void testFindVariable () { FactorGraph mdl = models [0]; Variable[] vars = new Variable [mdl.numVariables ()]; Iterator it = mdl.variablesIterator (); while (it.hasNext()) { Variable var = (Variable) it.next(); String name = new String (var.getLabel()); assertTrue (var == mdl.findVariable (name)); } assertTrue (mdl.findVariable ("xsdfasdf") == null); }
protected void setUp() { modelsList = createTestModels(); createTestTrees(); models = (UndirectedModel[]) modelsList.toArray (new UndirectedModel[]{}); computeTestTreeMargs(); }
public void testSerializable () throws Exception { for (int i = 0; i < algorithms.length; i++) { Inferencer alg = (Inferencer) algorithms[i].newInstance(); testSerializationForAlg (alg); } for (int i = 0; i < appxAlgs.length; i++) { Inferencer alg = (Inferencer) appxAlgs[i].newInstance(); testSerializationForAlg (alg); } Inferencer[] maxAlgs = constructMaxProductInferencers (); for (int i = 0; i < maxAlgs.length; i++) { testSerializationForAlg (maxAlgs [i]); } }
public static List createTestModels() { Random r = new Random(42); // These models are all small so that we can run the brute force // inferencer on them. FactorGraph[] mdls = new FactorGraph[]{ createTriangle(), createChainGraph(), createRandomGraph(3, 2, r), createRandomGraph(3, 3, r), createRandomGraph(6, 3, r), createRandomGraph(8, 2, r), createRandomGrid(3, 2, 4, r), createRandomGrid(4, 3, 2, r), }; return new ArrayList(Arrays.asList(mdls)); }
Factor[] normed = new Factor [4]; for (int i = 0; i < vars.length; i++) { ptls[i] = randomNodePotential (r, vars[i]); normed[i] = ptls[i].duplicate(); normed[i].normalize(); assertTrue ("Marginals not equal!\n True: "+normed[i]+"\n Returned "+marg, marg.almostEquals (normed[i])); double trueProb = 1.0; for (int i = 0; i < vars.length; i++) trueProb *= normed[i].value (assn); assertEquals (trueProb, inf.lookupJoint (assn), 1e-5);
public void testTrp() final UndirectedModel model = createTriangle(); TRP trp = new TRP().setTerminator (new TRP.IterationTerminator(200)); compareTrpJoint(joint, trp); Factor marg1 = trp.lookupMarginal(var); Factor marg2 = joint.marginalize (var); assertTrue(marg1.almostEquals(marg2, APPX_EPSILON)); Factor marg1 = trp.lookupMarginal (factor.varSet ()); Factor marg2 = joint.marginalize (factor.varSet ()); assertTrue(marg1.almostEquals(marg2, APPX_EPSILON));
public void testMarginals() throws Exception Inferencer[] appxInferencers = constructAllAppxInferencers (); logger.fine("Computing marginals for model " + mdl + " alg " + alg); alg.computeMarginals(models[mdl]); joints[mdl][i] = collectAllMarginals (models [mdl], alg); assertTrue(joint1.almostEquals(joint2)); Factor joint2 = joints[mdl][alg2][vrt]; try { assertTrue(joint1.almostEquals(joint2, APPX_EPSILON)); } catch (AssertionFailedError e) { System.out.println("\n************************************\nAppx Marginal Test FAILED\n\n");
public void testTrpJoint() { FactorGraph model = createTriangle(); TRP trp = new TRP().setTerminator (new TRP.IterationTerminator(25)); trp.computeMarginals(model); // For each assignment to the model, check that // TRP.lookupLogJoint and TRP.lookupJoint are consistent VarSet all = new HashVarSet (model.variablesSet ()); for (Iterator it = all.assignmentIterator(); it.hasNext();) { Assignment assn = (Assignment) it.next(); double log = trp.lookupLogJoint(assn); double prob = trp.lookupJoint(assn); assertTrue(Maths.almostEquals(Math.exp(log), prob)); } logger.info("Test trpJoint passed."); }
public void testLogNormalize () { FactorGraph mdl = models [0]; Iterator it = mdl.variablesIterator (); Variable v1 = (Variable) it.next(); Variable v2 = (Variable) it.next(); Random rand = new Random (3214123); for (int i = 0; i < 10; i++) { Factor ptl = randomEdgePotential (rand, v1, v2); Factor norm1 = new LogTableFactor((AbstractTableFactor) ptl); Factor norm2 = ptl.duplicate(); norm1.normalize(); norm2.normalize(); assertTrue ("LogNormalize failed! Correct: "+norm2+" Log-normed: "+norm1, norm1.almostEquals (norm2)); } }
public void testLoopyCaching () { FactorGraph mdl1 = models[4]; FactorGraph mdl2 = models[5]; Variable var = mdl1.get (0); LoopyBP inferencer = new LoopyBP (); inferencer.setUseCaching (true); inferencer.computeMarginals (mdl1); Factor origPtl = inferencer.lookupMarginal (var); assertTrue (2 < inferencer.iterationsUsed ()); // confuse the inferencer inferencer.computeMarginals (mdl2); // make sure we have cached, correct results inferencer.computeMarginals (mdl1); Factor sndPtl = inferencer.lookupMarginal (var); // note that we can't use an epsilon here, that's less than our convergence criteria. assertTrue ("Huh? Original potential:"+origPtl+"After: "+sndPtl, origPtl.almostEquals (sndPtl, 1e-4)); assertEquals (1, inferencer.iterationsUsed ()); }
public void testDirectedJt () { DirectedModel bn = createDirectedModel (); BruteForceInferencer brute = new BruteForceInferencer (); brute.computeMarginals (bn); JunctionTreeInferencer jt = new JunctionTreeInferencer (); jt.computeMarginals (bn); compareMarginals ("Error comparing junction tree to brute on directed model!", bn, brute, jt); }
public void testLoopyConvergence () { Random r = new Random (67); FactorGraph mdl = createRandomGrid (5, 5, 2, r); LoopyBP loopy = new LoopyBP (); loopy.computeMarginals (mdl); assertTrue (loopy.iterationsUsed() > 8); }
private void testSerializationForAlg (Inferencer alg) throws IOException, ClassNotFoundException { for (int mdlIdx = 0; mdlIdx < models.length; mdlIdx++) { FactorGraph mdl = models [mdlIdx]; // Copy the inferencer before calling b/c of random seed issues. Inferencer alg2 = (Inferencer) TestSerializable.cloneViaSerialization (alg); alg.computeMarginals(mdl); Factor[] pre = collectAllMarginals (mdl, alg); alg2.computeMarginals (mdl); Factor[] post2 = collectAllMarginals (mdl, alg2); compareMarginals ("Error comparing marginals after serialzation on model "+mdl, pre, post2); } }
public void testTrpTreeList () { FactorGraph model = createTriangle(); model.getVariable (0).setLabel ("V0"); model.getVariable (1).setLabel ("V1"); model.getVariable (2).setLabel ("V2"); List readers = new ArrayList (); for (int i = 0; i < treeStrs.length; i++) { readers.add (new StringReader (treeStrs[i])); } TRP trp = new TRP().setTerminator (new TRP.DefaultConvergenceTerminator()) .setFactory (TRP.TreeListFactory.makeFromReaders (model, readers)); trp.computeMarginals(model); Inferencer jt = new BruteForceInferencer (); jt.computeMarginals (model); compareMarginals ("", model, trp, jt); }
public void testDefaultLookupMarginal () { Inferencer inf = new TreeBP (); FactorGraph mdl = trees[JT_CHAIN_TEST_TREE]; Variable var = mdl.get (0); inf.computeMarginals (mdl); // Previously: UnsupportedOperationException // Exptected: default to lookupMarginal (Variable) for clique of size 1 VarSet varSet = new HashVarSet (new Variable[] { var }); Factor ptl1 = inf.lookupMarginal (varSet); Factor ptl2 = inf.lookupMarginal (var); assertTrue (ptl1.almostEquals (ptl2)); Variable var2 = mdl.get (1); Variable var3 = mdl.get (2); VarSet c2 = new HashVarSet (new Variable[] { var, var2, var3 }); try { inf.lookupMarginal (c2); fail ("Expected an UnsupportedOperationException with clique "+c2); } catch (UnsupportedOperationException e) {} }
Inferencer[] algs = constructMaxProductInferencers (); for (int infIdx = 0; infIdx < algs.length; infIdx++) { Inferencer inf = algs[infIdx]; System.err.println("Dump of model " + mdlIdx + " ***"); mdl.dump (); assertTrue (maxPot.argmax() == trueMaxPot.argmax());
public static List createTestModels() { Random r = new Random(42); // These models are all small so that we can run the brute force // inferencer on them. FactorGraph[] mdls = new FactorGraph[]{ createTriangle(), createChainGraph(), createRandomGraph(3, 2, r), createRandomGraph(3, 3, r), createRandomGraph(6, 3, r), createRandomGraph(8, 2, r), createRandomGrid(3, 2, 4, r), createRandomGrid(4, 3, 2, r), }; return new ArrayList(Arrays.asList(mdls)); }
protected void setUp() { modelsList = createTestModels(); createTestTrees(); models = (UndirectedModel[]) modelsList.toArray (new UndirectedModel[]{}); computeTestTreeMargs(); }