public void testMdlToGraph() {
List models = TestInference.createTestModels();
for (Iterator mdlIt = models.iterator(); mdlIt.hasNext(); ) {
UndirectedModel mdl = (UndirectedModel) mdlIt.next();
UndirectedGraph g = Graphs.mdlToGraph(mdl);
Set vertices = g.vertexSet();
// check the number of vertices
assertEquals(mdl.numVariables(), vertices.size());
// check the number of edges
int numEdgePtls = 0;
for (Iterator factorIt = mdl.factors().iterator(); factorIt.hasNext(); ) {
Factor factor = (Factor) factorIt.next();
if (factor.varSet().size() == 2) numEdgePtls++;
}
assertEquals(numEdgePtls, g.edgeSet().size());
// check that the neighbors of each vertex contain at least some of what they're supposed to
Iterator it = vertices.iterator();
while (it.hasNext()) {
Variable var = (Variable) it.next();
assertTrue(vertices.contains(var));
Set neighborsInG = new HashSet(GraphHelper.neighborListOf(g, var));
neighborsInG.add(var);
Iterator factorIt = mdl.allFactorsContaining(var).iterator();
while (factorIt.hasNext()) {
Factor factor = (Factor) factorIt.next();
assertTrue(neighborsInG.containsAll(factor.varSet()));
}
}
}
}
/**
* Constructs a junction tree from a given factor graph. Does not perform BP in the resulting
* graph. So this gives you the structure of a jnuction tree, but the factors don't correspond to
* the true marginals unless you call BP yourself.
*
* @param mdl Factor graph to compute JT for.
*/
public JunctionTree buildJunctionTree(FactorGraph mdl) {
jtCurrent = (JunctionTree) mdl.getInferenceCache(JunctionTreeInferencer.class);
if (jtCurrent != null) {
jtCurrent.clearCPFs();
} else {
/* The graph g is the topology of the MRF that corresponds to the factor graph mdl.
* Essentially, this means that we triangulate factor graphs by converting to an MRF first.
* I could have chosen to trianglualte the FactorGraph directly, but I didn't for historical reasons
* (I already had a version of triangulate() for MRFs, not bipartite factor graphs.)
* Note that the call to mdlToGraph() is perfectly valid for FactorGraphs that are also DirectedModels,
* and has the effect of moralizing in that case. */
UndirectedGraph g = Graphs.mdlToGraph(mdl);
triangulate(g);
jtCurrent = buildJtStructure();
mdl.setInferenceCache(JunctionTreeInferencer.class, jtCurrent);
}
initJtCpts(mdl, jtCurrent);
return jtCurrent;
}
// xxx Insanely inefficient stub
public boolean isConnected(Variable v1, Variable v2) {
UndirectedGraph g = Graphs.mdlToGraph(this);
ConnectivityInspector ins = new ConnectivityInspector(g);
return g.containsVertex(v1) && g.containsVertex(v2) && ins.pathExists(v1, v2);
}
