12345qiupeng
/
gtsam
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Reenabled BayesTree edit unit tests, and have some passing

release/4.3a0
Richard Roberts 2013-07-26 21:03:11 +00:00
parent 1ee51fb6f5
commit 865b2162ee
1 changed files with 226 additions and 217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

443
gtsam/symbolic/tests/testSymbolicBayesTree.cpp
View File

@ -24,9 +24,13 @@
#include <boost/assign/list_of.hpp> #include <boost/assign/list_of.hpp>
#include <boost/assign/std/vector.hpp> #include <boost/assign/std/vector.hpp>
#include <boost/assign/std/list.hpp>
#include <boost/range/adaptor/indirected.hpp>
using namespace boost::assign; using namespace boost::assign;
using boost::adaptors::indirected;
#include <CppUnitLite/TestHarness.h> #include <CppUnitLite/TestHarness.h>
#include <gtsam/base/TestableAssertions.h>
using namespace std; using namespace std;
using namespace gtsam; using namespace gtsam;
@ -36,22 +40,22 @@ static bool debug = false;
namespace { namespace {
/* ************************************************************************* */ /* ************************************************************************* */
// Conditionals for ASIA example from the tutorial with A and D evidence //// Conditionals for ASIA example from the tutorial with A and D evidence
SymbolicConditionalUnordered::shared_ptr //SymbolicConditionalUnordered::shared_ptr
B(new SymbolicConditionalUnordered(_B_)), // B(new SymbolicConditionalUnordered(_B_)),
L(new SymbolicConditionalUnordered(_L_, _B_)), // L(new SymbolicConditionalUnordered(_L_, _B_)),
E(new SymbolicConditionalUnordered(_E_, _L_, _B_)), // E(new SymbolicConditionalUnordered(_E_, _L_, _B_)),
S(new SymbolicConditionalUnordered(_S_, _L_, _B_)), // S(new SymbolicConditionalUnordered(_S_, _L_, _B_)),
T(new SymbolicConditionalUnordered(_T_, _E_, _L_)), // T(new SymbolicConditionalUnordered(_T_, _E_, _L_)),
X(new SymbolicConditionalUnordered(_X_, _E_)); // X(new SymbolicConditionalUnordered(_X_, _E_));
// Cliques //// Cliques
SymbolicConditionalUnordered::shared_ptr ELB( //SymbolicConditionalUnordered::shared_ptr ELB(
boost::make_shared<SymbolicConditionalUnordered>( // boost::make_shared<SymbolicConditionalUnordered>(
SymbolicConditionalUnordered::FromKeys(list_of(_E_)(_L_)(_B_), 3))); // SymbolicConditionalUnordered::FromKeys(list_of(_E_)(_L_)(_B_), 3)));
/* ************************************************************************* */ /* ************************************************************************* */
// Helper function for below // Helper functions for below
template<typename KEYS> template<typename KEYS>
SymbolicBayesTreeCliqueUnordered::shared_ptr MakeClique(const KEYS& keys, DenseIndex nrFrontals) SymbolicBayesTreeCliqueUnordered::shared_ptr MakeClique(const KEYS& keys, DenseIndex nrFrontals)
{ {
@ -59,6 +63,21 @@ namespace {
boost::make_shared<SymbolicConditionalUnordered>( boost::make_shared<SymbolicConditionalUnordered>(
SymbolicConditionalUnordered::FromKeys(keys, nrFrontals))); SymbolicConditionalUnordered::FromKeys(keys, nrFrontals)));
} }
template<typename KEYS, typename CHILDREN>
SymbolicBayesTreeCliqueUnordered::shared_ptr MakeClique(
const KEYS& keys, DenseIndex nrFrontals, const CHILDREN& children)
{
SymbolicBayesTreeCliqueUnordered::shared_ptr clique =
boost::make_shared<SymbolicBayesTreeCliqueUnordered>(
boost::make_shared<SymbolicConditionalUnordered>(
SymbolicConditionalUnordered::FromKeys(keys, nrFrontals)));
clique->children = children;
BOOST_FOREACH(const SymbolicBayesTreeCliqueUnordered::shared_ptr& child, children)
child->parent_ = clique;
return clique;
}
} }
/* ************************************************************************* */ /* ************************************************************************* */
@ -116,107 +135,100 @@ TEST(SymbolicBayesTree, clear)
CHECK(assert_equal(expected, bayesTree)); CHECK(assert_equal(expected, bayesTree));
} }
///* ************************************************************************* * /* ************************************************************************* *
//Bayes Tree for testing conversion to a forest of orphans needed for incremental. Bayes Tree for testing conversion to a forest of orphans needed for incremental.
// A,B A,B
// C|A E|B C|A E|B
// D|C F|E D|C F|E
// */ */
///* ************************************************************************* */ /* ************************************************************************* */
//TEST( BayesTree, removePath ) TEST( BayesTree, removePath )
//{ {
// const Index _A_=5, _B_=4, _C_=3, _D_=2, _E_=1, _F_=0; const Key _A_=A(0), _B_=B(0), _C_=C(0), _D_=D(0), _E_=E(0), _F_=F(0);
// SymbolicConditionalUnordered::shared_ptr
// A(new SymbolicConditionalUnordered(_A_)), SymbolicBayesTreeUnordered bayesTreeOrig;
// B(new SymbolicConditionalUnordered(_B_, _A_)), bayesTreeOrig.insertRoot(
// C(new SymbolicConditionalUnordered(_C_, _A_)), MakeClique(list_of(_A_)(_B_), 2, list_of
// D(new SymbolicConditionalUnordered(_D_, _C_)), (MakeClique(list_of(_C_)(_A_), 1, list_of
// E(new SymbolicConditionalUnordered(_E_, _B_)), (MakeClique(list_of(_D_)(_C_), 1))))
// F(new SymbolicConditionalUnordered(_F_, _E_)); (MakeClique(list_of(_E_)(_B_), 1, list_of
// SymbolicBayesTreeUnordered bayesTree; (MakeClique(list_of(_F_)(_E_), 1))))));
// EXPECT(bayesTree.empty());
//// Ordering ord; ord += _A_,_B_,_C_,_D_,_E_,_F_; SymbolicBayesTreeUnordered bayesTree = bayesTreeOrig;
// SymbolicBayesTreeUnordered::insert(bayesTree, A);
// SymbolicBayesTreeUnordered::insert(bayesTree, B); // remove C, expected outcome: factor graph with ABC,
// SymbolicBayesTreeUnordered::insert(bayesTree, C); // Bayes Tree now contains two orphan trees: D|C and E|B,F|E
// SymbolicBayesTreeUnordered::insert(bayesTree, D); SymbolicFactorGraphUnordered expected;
// SymbolicBayesTreeUnordered::insert(bayesTree, E); expected += SymbolicFactorUnordered(_A_,_B_);
// SymbolicBayesTreeUnordered::insert(bayesTree, F); expected += SymbolicFactorUnordered(_C_,_A_);
// SymbolicBayesTreeUnordered::Cliques expectedOrphans;
// // remove C, expected outcome: factor graph with ABC, expectedOrphans += bayesTree[_D_], bayesTree[_E_];
// // Bayes Tree now contains two orphan trees: D|C and E|B,F|E
// SymbolicFactorGraph expected; SymbolicBayesNetUnordered bn;
// expected.push_factor(_B_,_A_); SymbolicBayesTreeUnordered::Cliques orphans;
//// expected.push_factor(_A_); bayesTree.removePath(bayesTree[_C_], bn, orphans);
// expected.push_factor(_C_,_A_); SymbolicFactorGraphUnordered factors(bn);
// SymbolicBayesTreeUnordered::Cliques expectedOrphans; CHECK(assert_equal(expected, factors));
// expectedOrphans += bayesTree[_D_], bayesTree[_E_]; CHECK(assert_container_equal(expectedOrphans|indirected, orphans|indirected));
//
// BayesNet<SymbolicConditionalUnordered> bn; bayesTree = bayesTreeOrig;
// SymbolicBayesTreeUnordered::Cliques orphans;
// bayesTree.removePath(bayesTree[_C_], bn, orphans); // remove E: factor graph with EB; E|B removed from second orphan tree
// SymbolicFactorGraph factors(bn); SymbolicFactorGraphUnordered expected2;
// CHECK(assert_equal((SymbolicFactorGraph)expected, factors)); expected2 += SymbolicFactorUnordered(_A_,_B_);
// CHECK(assert_equal(expectedOrphans, orphans)); expected2 += SymbolicFactorUnordered(_E_,_B_);
// SymbolicBayesTreeUnordered::Cliques expectedOrphans2;
// // remove E: factor graph with EB; E|B removed from second orphan tree expectedOrphans2 += bayesTree[_F_];
// SymbolicFactorGraph expected2; expectedOrphans2 += bayesTree[_C_];
// expected2.push_factor(_E_,_B_);
// SymbolicBayesTreeUnordered::Cliques expectedOrphans2; SymbolicBayesNetUnordered bn2;
// expectedOrphans2 += bayesTree[_F_]; SymbolicBayesTreeUnordered::Cliques orphans2;
// bayesTree.removePath(bayesTree[_E_], bn2, orphans2);
// BayesNet<SymbolicConditionalUnordered> bn2; SymbolicFactorGraphUnordered factors2(bn2);
// SymbolicBayesTreeUnordered::Cliques orphans2; CHECK(assert_equal(expected2, factors2));
// bayesTree.removePath(bayesTree[_E_], bn2, orphans2); CHECK(assert_container_equal(expectedOrphans2|indirected, orphans2|indirected));
// SymbolicFactorGraph factors2(bn2); }
// CHECK(assert_equal((SymbolicFactorGraph)expected2, factors2));
// CHECK(assert_equal(expectedOrphans2, orphans2)); /* ************************************************************************* */
//} TEST( BayesTree, removePath2 )
// {
///* ************************************************************************* */ SymbolicBayesTreeUnordered bayesTree = asiaBayesTree;
//TEST( BayesTree, removePath2 )
//{ // Call remove-path with clique B
// SymbolicBayesTreeUnordered bayesTree = createAsiaSymbolicBayesTree(); SymbolicBayesNetUnordered bn;
// SymbolicBayesTreeUnordered::Cliques orphans;
// // Call remove-path with clique B bayesTree.removePath(bayesTree[_B_], bn, orphans);
// BayesNet<SymbolicConditionalUnordered> bn; SymbolicFactorGraphUnordered factors(bn);
// SymbolicBayesTreeUnordered::Cliques orphans;
// bayesTree.removePath(bayesTree[_B_], bn, orphans); // Check expected outcome
// SymbolicFactorGraph factors(bn); SymbolicFactorGraphUnordered expected;
// expected += SymbolicFactorUnordered(_B_,_L_,_E_,_S_);
// // Check expected outcome CHECK(assert_equal(expected, factors));
// SymbolicFactorGraph expected; SymbolicBayesTreeUnordered::Cliques expectedOrphans;
// expected.push_factor(_E_,_L_,_B_); expectedOrphans += bayesTree[_T_], bayesTree[_X_];
//// expected.push_factor(_L_,_B_); CHECK(assert_container_equal(expectedOrphans|indirected, orphans|indirected));
//// expected.push_factor(_B_); }
// CHECK(assert_equal(expected, factors));
// SymbolicBayesTreeUnordered::Cliques expectedOrphans; /* ************************************************************************* */
// expectedOrphans += bayesTree[_S_], bayesTree[_T_], bayesTree[_X_]; TEST( BayesTree, removePath3 )
// CHECK(assert_equal(expectedOrphans, orphans)); {
//} SymbolicBayesTreeUnordered bayesTree = asiaBayesTree;
//
///* ************************************************************************* */ // Call remove-path with clique S
//TEST( BayesTree, removePath3 ) SymbolicBayesNetUnordered bn;
//{ SymbolicBayesTreeUnordered::Cliques orphans;
// SymbolicBayesTreeUnordered bayesTree = createAsiaSymbolicBayesTree(); bayesTree.removePath(bayesTree[_T_], bn, orphans);
// SymbolicFactorGraphUnordered factors(bn);
// // Call remove-path with clique S
// BayesNet<SymbolicConditionalUnordered> bn; // Check expected outcome
// SymbolicBayesTreeUnordered::Cliques orphans; SymbolicFactorGraphUnordered expected;
// bayesTree.removePath(bayesTree[_S_], bn, orphans); expected += SymbolicFactorUnordered(_B_,_L_,_E_,_S_);
// SymbolicFactorGraph factors(bn); expected += SymbolicFactorUnordered(_T_,_E_,_L_);
// CHECK(assert_equal(expected, factors));
// // Check expected outcome SymbolicBayesTreeUnordered::Cliques expectedOrphans;
// SymbolicFactorGraph expected; expectedOrphans += bayesTree[_X_];
// expected.push_factor(_E_,_L_,_B_); CHECK(assert_container_equal(expectedOrphans|indirected, orphans|indirected));
//// expected.push_factor(_L_,_B_); }
//// expected.push_factor(_B_);
// expected.push_factor(_S_,_L_,_B_);
// CHECK(assert_equal(expected, factors));
// SymbolicBayesTreeUnordered::Cliques expectedOrphans;
// expectedOrphans += bayesTree[_T_], bayesTree[_X_];
// CHECK(assert_equal(expectedOrphans, orphans));
//}
void getAllCliques(const SymbolicBayesTreeUnordered::sharedClique& subtree, SymbolicBayesTreeUnordered::Cliques& cliques) { void getAllCliques(const SymbolicBayesTreeUnordered::sharedClique& subtree, SymbolicBayesTreeUnordered::Cliques& cliques) {
// Check if subtree exists // Check if subtree exists
@ -278,104 +290,106 @@ TEST( BayesTree, shortcutCheck )
// } // }
} }
///* ************************************************************************* */ /* ************************************************************************* */
//TEST( BayesTree, removeTop ) TEST( BayesTree, removeTop )
//{ {
// SymbolicBayesTreeUnordered bayesTree = createAsiaSymbolicBayesTree(); SymbolicBayesTreeUnordered bayesTree = asiaBayesTree;
//
// // create a new factor to be inserted bayesTree.print("asiaBayesTree: ");
// boost::shared_ptr<IndexFactor> newFactor(new IndexFactor(_S_,_B_));
// // create a new factor to be inserted
// // Remove the contaminated part of the Bayes tree //boost::shared_ptr<IndexFactor> newFactor(new IndexFactor(_S_,_B_));
// BayesNet<SymbolicConditionalUnordered> bn;
// SymbolicBayesTreeUnordered::Cliques orphans; // Remove the contaminated part of the Bayes tree
// list<Index> keys; keys += _B_,_S_; SymbolicBayesNetUnordered bn;
// bayesTree.removeTop(keys, bn, orphans); SymbolicBayesTreeUnordered::Cliques orphans;
// SymbolicFactorGraph factors(bn); list<Key> keys; keys += _B_,_S_;
// bayesTree.removeTop(keys, bn, orphans);
// // Check expected outcome SymbolicFactorGraphUnordered factors(bn);
// SymbolicFactorGraph expected;
// expected.push_factor(_E_,_L_,_B_); // Check expected outcome
//// expected.push_factor(_L_,_B_); SymbolicFactorGraphUnordered expected;
//// expected.push_factor(_B_); expected.push_factor(_E_,_L_,_B_);
// expected.push_factor(_S_,_L_,_B_); // expected.push_factor(_L_,_B_);
// CHECK(assert_equal(expected, factors)); // expected.push_factor(_B_);
// SymbolicBayesTreeUnordered::Cliques expectedOrphans; expected.push_factor(_S_,_L_,_B_);
// expectedOrphans += bayesTree[_T_], bayesTree[_X_]; CHECK(assert_equal(expected, factors));
// CHECK(assert_equal(expectedOrphans, orphans)); SymbolicBayesTreeUnordered::Cliques expectedOrphans;
// expectedOrphans += bayesTree[_T_], bayesTree[_X_];
// // Try removeTop again with a factor that should not change a thing CHECK(assert_container_equal(expectedOrphans|indirected, orphans|indirected));
// boost::shared_ptr<IndexFactor> newFactor2(new IndexFactor(_B_));
// BayesNet<SymbolicConditionalUnordered> bn2; // Try removeTop again with a factor that should not change a thing
// SymbolicBayesTreeUnordered::Cliques orphans2; //boost::shared_ptr<IndexFactor> newFactor2(new IndexFactor(_B_));
// keys.clear(); keys += _B_; SymbolicBayesNetUnordered bn2;
// bayesTree.removeTop(keys, bn2, orphans2); SymbolicBayesTreeUnordered::Cliques orphans2;
// SymbolicFactorGraph factors2(bn2); keys.clear(); keys += _B_;
// SymbolicFactorGraph expected2; bayesTree.removeTop(keys, bn2, orphans2);
// CHECK(assert_equal(expected2, factors2)); SymbolicFactorGraphUnordered factors2(bn2);
// SymbolicBayesTreeUnordered::Cliques expectedOrphans2; SymbolicFactorGraphUnordered expected2;
// CHECK(assert_equal(expectedOrphans2, orphans2)); CHECK(assert_equal(expected2, factors2));
//} SymbolicBayesTreeUnordered::Cliques expectedOrphans2;
// CHECK(assert_container_equal(expectedOrphans2|indirected, orphans2|indirected));
///* ************************************************************************* */ }
//TEST( BayesTree, removeTop2 )
//{ /* ************************************************************************* */
// SymbolicBayesTreeUnordered bayesTree = createAsiaSymbolicBayesTree(); TEST( BayesTree, removeTop2 )
// {
// // create two factors to be inserted SymbolicBayesTreeUnordered bayesTree = asiaBayesTree;
// SymbolicFactorGraph newFactors;
// newFactors.push_factor(_B_); // create two factors to be inserted
// newFactors.push_factor(_S_); //SymbolicFactorGraph newFactors;
// //newFactors.push_factor(_B_);
// // Remove the contaminated part of the Bayes tree //newFactors.push_factor(_S_);
// BayesNet<SymbolicConditionalUnordered> bn;
// SymbolicBayesTreeUnordered::Cliques orphans; // Remove the contaminated part of the Bayes tree
// list<Index> keys; keys += _B_,_S_; SymbolicBayesNetUnordered bn;
// bayesTree.removeTop(keys, bn, orphans); SymbolicBayesTreeUnordered::Cliques orphans;
// SymbolicFactorGraph factors(bn); list<Key> keys; keys += _B_,_S_;
// bayesTree.removeTop(keys, bn, orphans);
// // Check expected outcome SymbolicFactorGraphUnordered factors(bn);
// SymbolicFactorGraph expected;
// expected.push_factor(_E_,_L_,_B_); // Check expected outcome
//// expected.push_factor(_L_,_B_); SymbolicFactorGraphUnordered expected;
//// expected.push_factor(_B_); expected.push_factor(_E_,_L_,_B_);
// expected.push_factor(_S_,_L_,_B_); // expected.push_factor(_L_,_B_);
// CHECK(assert_equal(expected, factors)); // expected.push_factor(_B_);
// SymbolicBayesTreeUnordered::Cliques expectedOrphans; expected.push_factor(_S_,_L_,_B_);
// expectedOrphans += bayesTree[_T_], bayesTree[_X_]; CHECK(assert_equal(expected, factors));
// CHECK(assert_equal(expectedOrphans, orphans)); SymbolicBayesTreeUnordered::Cliques expectedOrphans;
//} expectedOrphans += bayesTree[_T_], bayesTree[_X_];
// CHECK(assert_container_equal(expectedOrphans|indirected, orphans|indirected));
///* ************************************************************************* */ }
//TEST( BayesTree, removeTop3 )
//{ /* ************************************************************************* */
// const Index _x4_=5, _l5_=6; TEST( BayesTree, removeTop3 )
// // simple test case that failed after COLAMD was fixed/activated {
// SymbolicConditionalUnordered::shared_ptr const Key _x4_=5, _l5_=6;
// X(new SymbolicConditionalUnordered(_l5_)), // simple test case that failed after COLAMD was fixed/activated
// A(new SymbolicConditionalUnordered(_x4_, _l5_)), SymbolicConditionalUnordered::shared_ptr
// B(new SymbolicConditionalUnordered(_x2_, _x4_)), X(new SymbolicConditionalUnordered(_l5_)),
// C(new SymbolicConditionalUnordered(_x3_, _x2_)); A(new SymbolicConditionalUnordered(_x4_, _l5_)),
// B(new SymbolicConditionalUnordered(_x2_, _x4_)),
//// Ordering newOrdering; C(new SymbolicConditionalUnordered(_x3_, _x2_));
//// newOrdering += _x3_, _x2_, _x1_, _l2_, _l1_, _x4_, _l5_;
// SymbolicBayesTreeUnordered bayesTree; // Ordering newOrdering;
// SymbolicBayesTreeUnordered::insert(bayesTree, X); // newOrdering += _x3_, _x2_, _x1_, _l2_, _l1_, _x4_, _l5_;
// SymbolicBayesTreeUnordered::insert(bayesTree, A); SymbolicBayesTreeUnordered bayesTree;
// SymbolicBayesTreeUnordered::insert(bayesTree, B); SymbolicBayesTreeUnordered::insert(bayesTree, X);
// SymbolicBayesTreeUnordered::insert(bayesTree, C); SymbolicBayesTreeUnordered::insert(bayesTree, A);
// SymbolicBayesTreeUnordered::insert(bayesTree, B);
// // remove all SymbolicBayesTreeUnordered::insert(bayesTree, C);
// list<Index> keys;
// keys += _l5_, _x2_, _x3_, _x4_; // remove all
// BayesNet<SymbolicConditionalUnordered> bn; list<Index> keys;
// SymbolicBayesTreeUnordered::Cliques orphans; keys += _l5_, _x2_, _x3_, _x4_;
// bayesTree.removeTop(keys, bn, orphans); BayesNet<SymbolicConditionalUnordered> bn;
// SymbolicFactorGraph factors(bn); SymbolicBayesTreeUnordered::Cliques orphans;
// bayesTree.removeTop(keys, bn, orphans);
// CHECK(orphans.size() == 0); SymbolicFactorGraph factors(bn);
//}
// CHECK(orphans.size() == 0);
}
/////* ************************************************************************* */ /////* ************************************************************************* */
/////** /////**
//// * x2 - x3 - x4 - x5 //// * x2 - x3 - x4 - x5
@ -457,8 +471,6 @@ TEST( SymbolicBayesTreeUnordered, thinTree ) {
bayesNet.push_back(boost::make_shared<SymbolicConditionalUnordered>(1, 8, 12)); bayesNet.push_back(boost::make_shared<SymbolicConditionalUnordered>(1, 8, 12));
bayesNet.push_back(boost::make_shared<SymbolicConditionalUnordered>(0, 8, 12)); bayesNet.push_back(boost::make_shared<SymbolicConditionalUnordered>(0, 8, 12));
bayesNet.print("bayesNet: ");
if (debug) { if (debug) {
GTSAM_PRINT(bayesNet); GTSAM_PRINT(bayesNet);
bayesNet.saveGraph("/tmp/symbolicBayesNet.dot"); bayesNet.saveGraph("/tmp/symbolicBayesNet.dot");
@ -467,7 +479,6 @@ TEST( SymbolicBayesTreeUnordered, thinTree ) {
// create a BayesTree out of a Bayes net // create a BayesTree out of a Bayes net
OrderingUnordered ordering(bayesNet.keys()); OrderingUnordered ordering(bayesNet.keys());
SymbolicBayesTreeUnordered bayesTree = *SymbolicFactorGraphUnordered(bayesNet).eliminateMultifrontal(ordering); SymbolicBayesTreeUnordered bayesTree = *SymbolicFactorGraphUnordered(bayesNet).eliminateMultifrontal(ordering);
bayesTree.print("bayesTree: ");
if (debug) { if (debug) {
GTSAM_PRINT(bayesTree); GTSAM_PRINT(bayesTree);
bayesTree.saveGraph("/tmp/SymbolicBayesTreeUnordered.dot"); bayesTree.saveGraph("/tmp/SymbolicBayesTreeUnordered.dot");
@ -676,8 +687,6 @@ TEST(SymbolicBayesTreeUnordered, complicatedMarginal)
bt.saveGraph("/tmp/SymbolicBayesTreeUnordered.dot"); bt.saveGraph("/tmp/SymbolicBayesTreeUnordered.dot");
} }
bt.print("bt: ");
// Shortcut on 9 // Shortcut on 9
{ {
SymbolicBayesTreeUnordered::Clique::shared_ptr c = bt[9]; SymbolicBayesTreeUnordered::Clique::shared_ptr c = bt[9];