libDAI-0.2.4/0000755000263000017630000000000011334765023011461 5ustar jorismkyblibDAI-0.2.4/swig/0000755000263000017630000000000011334764706012441 5ustar jorismkyblibDAI-0.2.4/swig/example_sprinkler.m0000644000263000017630000000572611334764706016355 0ustar jorismkyb% This file is part of libDAI - http://www.libdai.org/ % % libDAI is licensed under the terms of the GNU General Public License version % 2, or (at your option) any later version. libDAI is distributed without any % warranty. See the file COPYING for more details. % % Copyright (C) 2009 Joris Mooij [joris dot mooij at libdai dot org] % This example program illustrates how to construct a factorgraph % by means of the sprinkler network example discussed at % http://www.cs.ubc.ca/~murphyk/Bayes/bnintro.html % using the SWIG octave wrapper of libDAI dai C = dai.Var(0, 2); % Define binary variable Cloudy (with label 0) S = dai.Var(1, 2); % Define binary variable Sprinkler (with label 1) R = dai.Var(2, 2); % Define binary variable Rain (with label 2) W = dai.Var(3, 2); % Define binary variable Wetgrass (with label 3) % Define probability distribution for C P_C = dai.Factor(C); P_C(0) = 0.5; % C = 0 P_C(1) = 0.5; % C = 1 % Define conditional probability of S given C P_S_given_C = dai.Factor(dai.VarSet(S,C)); P_S_given_C(0) = 0.5; % C = 0, S = 0 P_S_given_C(1) = 0.9; % C = 1, S = 0 P_S_given_C(2) = 0.5; % C = 0, S = 1 P_S_given_C(3) = 0.1; % C = 1, S = 1 % Define conditional probability of R given C P_R_given_C = dai.Factor(dai.VarSet(R,C)); P_R_given_C(0) = 0.8; % C = 0, R = 0 P_R_given_C(1) = 0.2; % C = 1, R = 0 P_R_given_C(2) = 0.2; % C = 0, R = 1 P_R_given_C(3) = 0.8; % C = 1, R = 1 % Define conditional probability of W given S and R SRW = dai.VarSet(S,R); SRW.append(W); P_W_given_S_R = dai.Factor(SRW); P_W_given_S_R(0) = 1.0; % S = 0, R = 0, W = 0 P_W_given_S_R(1) = 0.1; % S = 1, R = 0, W = 0 P_W_given_S_R(2) = 0.1; % S = 0, R = 1, W = 0 P_W_given_S_R(3) = 0.01; % S = 1, R = 1, W = 0 P_W_given_S_R(4) = 0.0; % S = 0, R = 0, W = 1 P_W_given_S_R(5) = 0.9; % S = 1, R = 0, W = 1 P_W_given_S_R(6) = 0.9; % S = 0, R = 1, W = 1 P_W_given_S_R(7) = 0.99; % S = 1, R = 1, W = 1 % Build factor graph consisting of those four factors SprinklerFactors = dai.VecFactor(); SprinklerFactors.append(P_C); SprinklerFactors.append(P_R_given_C); SprinklerFactors.append(P_S_given_C); SprinklerFactors.append(P_W_given_S_R); SprinklerNetwork = dai.FactorGraph(SprinklerFactors); % Write factorgraph to a file SprinklerNetwork.WriteToFile('sprinkler.fg'); fprintf('Sprinkler network written to sprinkler.fg'); % Output some information about the factorgraph fprintf('%d variables\n', SprinklerNetwork.nrVars()); fprintf('%d factors\n', SprinklerNetwork.nrFactors()); % Calculate joint probability of all four variables P = dai.Factor(); for I = 0:(SprinklerNetwork.nrFactors()-1) P *= SprinklerNetwork.factor(I); end P.normalize(); % Not necessary: a Bayesian network is already normalized by definition % Calculate some probabilities denom = P.marginal(dai.VarSet(W))(1); fprintf('P(W=1) = %f\n', denom); fprintf('P(S=1 | W=1) = %f\n', P.marginal(dai.VarSet(S,W))(3) / denom); fprintf('P(R=1 | W=1) = %f\n', P.marginal(dai.VarSet(R,W))(3) / denom); libDAI-0.2.4/swig/README0000644000263000017630000000026311334764706013322 0ustar jorismkybThis directory contains preliminary experimental SWIG wrappers for libDAI written by Patrick Pletscher. They enable usage of libDAI functionality directly from python and octave. libDAI-0.2.4/swig/Makefile0000644000263000017630000000161111334764706014100 0ustar jorismkyb# This file is part of libDAI - http://www.libdai.org/ # # libDAI is licensed under the terms of the GNU General Public License version # 2, or (at your option) any later version. libDAI is distributed without any # warranty. See the file COPYING for more details. # # Copyright (C) 2009 Patrick Pletscher [pletscher at inf dot ethz dot ch] include ../Makefile.conf .PHONY: all all: _dai.so dai.oct _dai.so: ../lib/libdai.a dai.i $(SWIG) -python -classic -c++ dai.i g++ -Wall -c -O3 -g -fPIC dai_wrap.cxx -I$(INCLUDE_PYTHON) -I$(INCLUDE_BOOST) -I../include g++ -shared dai_wrap.o -o _dai.so ../lib/libdai.a dai.oct: ../lib/libdai.a dai.i $(SWIG) -octave -c++ -o dai_wrap.cpp dai.i mkoctfile -I$(INCLUDE_BOOST) -I../include -o dai.oct dai_wrap.cpp ../lib/libdai.a .PHONY: clean clean: rm -f dai_wrap.cxx dai_wrap.cpp dai_wrap.o _dai.so dai.oct dai.py dai.pyc sprinkler.fg libDAI-0.2.4/swig/dai.i0000644000263000017630000000572211334764706013356 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Patrick Pletscher [pletscher at inf dot ethz dot ch] * 2009 Joris Mooij [joris dot mooij at libdai dot org] */ %module dai struct Neighbor { size_t iter; size_t node; size_t dual; Neighbor() {} Neighbor( size_t iter, size_t node, size_t dual ) : iter(iter), node(node), dual(dual) {} operator size_t () const { return node; } }; %{ #include "../include/dai/var.h" #include "../include/dai/smallset.h" #include "../include/dai/varset.h" #include "../include/dai/prob.h" #include "../include/dai/factor.h" #include "../include/dai/bipgraph.h" #include "../include/dai/factorgraph.h" #include "../include/dai/util.h" %} %ignore dai::TProb::operator[]; %ignore dai::TFactor::operator[]; %ignore dai::Var::label() const; %ignore dai::Var::states() const; %include "../include/dai/util.h" %include "../include/dai/var.h" %include "../include/dai/smallset.h" %template(SmallSetVar) dai::SmallSet< dai::Var >; %include "../include/dai/varset.h" %extend dai::VarSet { inline void append(const dai::Var &v) { (*self) |= v; } /* for python, octave */ }; %include "../include/dai/prob.h" %template(Prob) dai::TProb; %extend dai::TProb { inline dai::Real __getitem__(int i) const {return (*self)[i];} /* for python */ inline void __setitem__(int i,dai::Real d) {(*self)[i] = d;} /* for python */ inline dai::Real __paren(int i) const {return (*self)[i];} /* for octave */ inline void __paren_asgn(int i,dai::Real d) {(*self)[i] = d;} /* for octave */ }; %include "../include/dai/factor.h" %extend dai::TFactor { inline dai::Real __getitem__(int i) const {return (*self)[i];} /* for python */ inline void __setitem__(int i,dai::Real d) {(*self)[i] = d;} /* for python */ inline dai::Real __paren__(int i) const {return (*self)[i];} /* for octave */ inline void __paren_asgn__(int i,dai::Real d) {(*self)[i] = d;} /* for octave */ }; %template(Factor) dai::TFactor; %include "../include/dai/bipgraph.h" %include "../include/dai/factorgraph.h" %include "std_vector.i" // TODO: typemaps for the vectors (input/output python arrays) %inline{ typedef std::vector VecFactor; typedef std::vector< VecFactor > VecVecFactor; } %template(VecFactor) std::vector< dai::Factor >; %template(VecVecFactor) std::vector< VecFactor >; %{ typedef dai::BipartiteGraph::Neighbor Neighbor; %} %include "../include/dai/index.h" %extend dai::multifor { inline size_t __getitem__(int i) const { return (*self)[i]; } inline void next() { return (*self)++; } }; libDAI-0.2.4/swig/example_sprinkler.py0000644000263000017630000000560611334764706016546 0ustar jorismkyb# This file is part of libDAI - http://www.libdai.org/ # # libDAI is licensed under the terms of the GNU General Public License version # 2, or (at your option) any later version. libDAI is distributed without any # warranty. See the file COPYING for more details. # # Copyright (C) 2009 Joris Mooij [joris dot mooij at libdai dot org] # This example program illustrates how to construct a factorgraph # by means of the sprinkler network example discussed at # http://www.cs.ubc.ca/~murphyk/Bayes/bnintro.html # using the SWIG python wrapper of libDAI import dai C = dai.Var(0, 2) # Define binary variable Cloudy (with label 0) S = dai.Var(1, 2) # Define binary variable Sprinkler (with label 1) R = dai.Var(2, 2) # Define binary variable Rain (with label 2) W = dai.Var(3, 2) # Define binary variable Wetgrass (with label 3) # Define probability distribution for C P_C = dai.Factor(C) P_C[0] = 0.5 # C = 0 P_C[1] = 0.5 # C = 1 # Define conditional probability of S given C P_S_given_C = dai.Factor(dai.VarSet(S,C)) P_S_given_C[0] = 0.5 # C = 0, S = 0 P_S_given_C[1] = 0.9 # C = 1, S = 0 P_S_given_C[2] = 0.5 # C = 0, S = 1 P_S_given_C[3] = 0.1 # C = 1, S = 1 # Define conditional probability of R given C P_R_given_C = dai.Factor(dai.VarSet(R,C)) P_R_given_C[0] = 0.8 # C = 0, R = 0 P_R_given_C[1] = 0.2 # C = 1, R = 0 P_R_given_C[2] = 0.2 # C = 0, R = 1 P_R_given_C[3] = 0.8 # C = 1, R = 1 # Define conditional probability of W given S and R SRW = dai.VarSet(S,R) SRW.append(W) P_W_given_S_R = dai.Factor(SRW) P_W_given_S_R[0] = 1.0 # S = 0, R = 0, W = 0 P_W_given_S_R[1] = 0.1 # S = 1, R = 0, W = 0 P_W_given_S_R[2] = 0.1 # S = 0, R = 1, W = 0 P_W_given_S_R[3] = 0.01 # S = 1, R = 1, W = 0 P_W_given_S_R[4] = 0.0 # S = 0, R = 0, W = 1 P_W_given_S_R[5] = 0.9 # S = 1, R = 0, W = 1 P_W_given_S_R[6] = 0.9 # S = 0, R = 1, W = 1 P_W_given_S_R[7] = 0.99 # S = 1, R = 1, W = 1 # Build factor graph consisting of those four factors SprinklerFactors = dai.VecFactor() SprinklerFactors.append(P_C) SprinklerFactors.append(P_R_given_C) SprinklerFactors.append(P_S_given_C) SprinklerFactors.append(P_W_given_S_R) SprinklerNetwork = dai.FactorGraph(SprinklerFactors) # Write factorgraph to a file SprinklerNetwork.WriteToFile('sprinkler.fg') print 'Sprinkler network written to sprinkler.fg' # Output some information about the factorgraph print SprinklerNetwork.nrVars(), 'variables' print SprinklerNetwork.nrFactors(), 'factors' # Calculate joint probability of all four variables P = dai.Factor() for I in range(SprinklerNetwork.nrFactors()): P *= SprinklerNetwork.factor(I) P.normalize() # Not necessary: a Bayesian network is already normalized by definition # Calculate some probabilities denom = P.marginal(dai.VarSet(W))[1] print 'P(W=1) =', denom print 'P(S=1 | W=1) =', P.marginal(dai.VarSet(S,W))[3] / denom print 'P(R=1 | W=1) =', P.marginal(dai.VarSet(R,W))[3] / denom libDAI-0.2.4/ChangeLog0000644000263000017630000007776111334764771013266 0ustar jorismkyblibDAI-0.2.4 (2010-02-11) ------------------------- New features: * Implemented Tree-Reweighted BP * [Frederik Eaton] Implemented Fractional Belief Propagation Miscellaneous improvements: * Improved documentation * [Frederik Eaton] Added constructors for BBPCostFunction * [Frederik Eaton] Added accessor/mutator for the elements of a SmallSet<> * [Frederik Eaton] Added unary minus to TProb<> * [Frederik Eaton] Added Hellinger distance to TProb<>::DistType * [Frederik Eaton] Two small patches for src/jtree.cpp and utils/createfg.cpp * tests/testdai option "marginals" now has three possible values: NONE outputs no marginals, VAR only variable marginals, and ALL outputs all marginals calculated by the algorithm. * Strengthened convergence criteria of various algorithms * Added GraphAL, an adjacency list implementation for graphs, similar to (but simpler than) BipartiteGraph * Added some functionality to create various standard factors (the functions whose names start with "createFactor") * Added examples example_sprinkler_gibbs and example_sprinkler_em * Implemented various heuristics for choosing a variable elimination sequence in JTree * Added BETHE method for GBP/HAK cluster choice Build system: * Moved platform independent build options into Makefile.ALL * Windows platform now needs Boost 1.37 or higher Code cleanup: * Cleaned up utils/createfg and tests/testdai Interface changes (the old interface is marked obsolete and will be removed in the next release): * Removed obsolete/deprecated stuff * Renamed Graph into GraphEL (for Graph, implemented as Edge List) * Renamed some functions of BipartiteGraph: add1() -> addNode1() erase1() -> eraseNode1() nr1() -> nrNodes1() add2() -> addNode2() erase2() -> eraseNode2() nr2() -> nrNodes2() * Renamed some functions in ClusterGraph: ClusterGraph::eliminationCost() -> ::eliminationCost_MinFill() ClusterGraph::VarElim() -> ClusterGraph::VarElim( sequentialVariableElimination( ElimSeq ) ) ClusterGraph::VarElim_MinFill() -> ClusterGraph::VarElim( greedyVariableElimination( eliminationCost_MinFill ) ) * Changed interface of one RegionGraph constructor * Renamed "Clamped BP" into "Conditioned BP" Bug fixes: * Fixed regression in scripts/regenerate-properties (now all errors are gathered before throwing the exception, as used to be the case) * Fixed FTBFS errors on MACOSX (thanks to Sebastian Riedel for reporting this bug) * [Alexander Schwing] Fixed error in BP that occured with damping and using log-domain updates * Fixed bug in HAK for trivial region graphs (with only one outer region and no inner regions), reported by Alejandro Lage. libDAI-0.2.3 (2009-11-16) ------------------------- New features: * Complete doxygen documentation (although more detailed documentation still has to be written) * [Charles Vaske] Added parameter learning for conditional probabilities by Expectation Maximization * [Patrick Pletscher] Added SWIG wrapper code for experimental python and octave interfaces * Added Max-Product functionality to JTree * [Frederik Eaton] Added Back-Belief-Propagation * [Frederik Eaton] Added approximate inference method "Clamped Belief Propagation" * [Frederik Eaton] Added approximate inference method "Gibbs sampling" Code cleanup: * Updated copyright headers * Cleaned up error handling by introducing the DAI_THROWE macro * Introduced DAI_DEBASSERT macro to abbreviate a common pattern * Replaced the standard assert() macro by DAI_ASSERT, which throws a dai::Exception and is even active if NDEBUG is defined * Removed all the virtual default constructors *::create(), as they are not used * [Frederik Eaton] Removed unnecessary copy constructors and assignment operators * [Frederik Eaton] Change cout to cerr in warnings and error messages Miscellaneous improvements: * BipartiteGraph: - Added eraseEdge( size_t n1, size_t n2 ) - [Frederik Eaton] Improved documentation of Neighbor * TProb: - Added divided_by(const TProb&) const - Added constructor TProb( const std::vector &v ) - Added size_t draw(), which draws a random index - [Frederik Eaton] Added setUniform() - [Frederik Eaton] Added sumAbs() - [Frederik Eaton] Added argmax() - [Giuseppe Passino] Added begin(), end() * TFactor: - [Giuseppe Passino] Added begin(), end() - [Charles Vaske] Added TFactor( const std::vector &vars, const std::vector &p ), which reorders variables to canonical ordering before storing the table - Added constructor TFactor( const VarSet &vars, const std::vector &v ) - Extended functionality of TFactor::operators +,-,+=,-= to handle different VarSets - Added TFactor::maxMarginal (similar to marginal but with max instead of sum) * State: - [Giuseppe Passino] Added prefix ++ operator * Permute: - [Charles Vaske] Added constructor in Permute for canonical variable ordering * FactorGraph: - [Frederik Eaton] Added clampVar() - [Frederik Eaton] Added clampFactor() - [Giuseppe Passino] Added begin(), end() * PropertySet: - Added keys(), for getting all keys - [Frederik Eaton] Added default constructor - [Frederik Eaton] Added constructor from string * InfAlg: - Added setProperties(), getProperties() and printProperties() - [Frederik Eaton] Added beliefV(), beliefF() * ExactInf: - Added calcMarginal(const VarSet &) * HAK: - Added "init" parameter to allow for random initialization * BP: - [Giuseppe Passino] Added findMaximum(), which can be used after running max-product BP to construct a global state with maximum probability * JTree: - Added findMaximum(), which can be used after running max-product JTree to construct a global state with maximum probability * MatLab interface: - MEX file dai now also returns variable and factor beliefs - [Sebastian Nowozin] MEX file dai now also optionally returns the MAP state (only for BP and JTree) * README is now created automatically from doxygen documentation * [Frederik Eaton] Added script for automatically generating properties code (used by CBP and BBP) * [Frederik Eaton] Added newInfAlgFromString to alldai.h/cpp * [Frederik Eaton] Added some utility macros (DAI_PV, DAI_DMSG, DAI_IFVERB) and functions (concat(),rnd()) to util.h * Changed output stream operator<< for Var and VarSet * [Frederik Eaton] Improved parsing code in tests/testdai to allow recursive alias substitutions * [Frederik Eaton] Added useful aliases to aliases.conf * [Giuseppe Passino] Optimised maximum-residual BP by using a reversed ordered set instead of the linear search (which can yield enormous speedups - a factor 500 has been measured on a binary Ising grid with 128x128 variables!) * Added debug assertions to Var which check for inconsistent dimensions of variables with the same labels * toc() now returns POSIX system time with maximum accuracy of microseconds * Exception objects now remember their error code * Examples: - Moved example.cpp to examples/ - Added examples/example_bipgraph.cpp - Added examples/example_varset.cpp - Added examples/example_sprinkler.cpp - Added examples/example_permute.cpp - Added python and octave ports for examples/example_sprinkler.cpp Build system: * Improved Makefile: - Merged Makefile.win and Makefile.shared into Makefile - Macros DAI_VERSION and DAI_DATE have been introduced, in order to store this information in a central place - Introduced CCNODEBUGFLAGS in Makefile - Switched Makefile.win to GNU Make syntax - [Frederik Eaton] Added TAGS, lib targets to Makefile * Compatibility: - [Peter Gober] libDAI can now be built on Cygwin - [Dan Preston] libDAI can now be built on Mac OS X - Changed regression test so that it also works under Windows Interface changes (the old interface is marked obsolete and will be removed in the next release): * Var: - Variable labels are now nonnegative (of type size_t) * VarSet: - Replaced calcState() by non-member calcLinearState() - Replaced calcStates() by non-member calcState() * Permute: - Renamed convert_linear_index into convertLinearIndex * TProb<>: - Replaced log0() by log(true) - Replaced takeLog0() by takeLog(true) - Removed hasNonPositives() - Renamed minVal() to min() - Renamed maxVal() to max() - Renamed totalSum() to sum() * TFactor<>: - Replaced log0() by TFactor::log(true) - Removed divided_by, use operator/ instead - Removed divide, use operator/= instead - Removed partSum(const VarSet&), use marginal(const VarSet&,false) instead - Renamed minVal() to min() - Renamed maxVal() to max() - Renamed totalSum() to sum() * FactorGraph: - Changed clamp and clamp interfaces (the variable to be clamped is now indicated by its index, not as a Var) * RegionGraph: - Renamed Check_Counting_Numbers into checkCountingNumbers - Renamed Calc_Counting_Numbers into calcCountingNumbers * Miscellaneous: - Renamed Treewidth(const FactorGraph &) into boundTreewidth(const FactorGraph &) - Replaced UEdgeVec by Graph - Replaced DEdgeVec by new RootedTree class - Moved functionality of GrowRootedTree() into constructor of RootedTree - Merged calcPairBeliefsNew() into calcPairBeliefs() - Removed calcMarginal2ndO() - Renamed smallSet to SmallSet - Removed class Diffs - [Frederik Eaton] Added backwards compatibility layer for edge interface to BipartiteGraph and FactorGraph (which will be obsoleted soon) Bug fixes: * Fixed reversal of min and max in TFactor min( const TFactor &, const TFactor & ) TFactor max( const TFactor &, const TFactor & ) * [Sebastian Nowozin] Fixed memory leak in MEX file dai * [Frederik Eaton] In PropertySet::getStringAs(), check for typeid(ValueType) before typeid(std::string) (this fixes a strange bug for empty string property) * Added work-around for bug in Boost Graph Library * Fixed bug in MaxSpanningTree (it wrongly assumed that the tree was not empty). * Fixed bug in calcMarginal and calcPairBeliefs where states with zero probability mass were clamped, leading to NaNs or assertion errors (thanks to Dan Preston for reporting this) libDAI-0.2.2 (2008-09-30) ------------------------- New features: * Approximate inference methods now report the number of iterations needed. * Added damping to various algorithms to improve convergence properties. * Added more features to utils/createfg for creating factor graphs. * Added ExactInf class for brute force exact inference. * [Giuseppe Pasino] Added "logdomain" property to BP, a boolean that controls whether calculations are done in the log-domain or in the linear domain; doing calculations in the log-domain may help if the numerical range of a double is too small. * [Claudio Lima] Added Max-Product functionality to BP. * Improved documentation. Improved architecture: * Added Exceptions framework. * Pervasive change of BipartiteGraph implementation (based on an idea by Giuseppe Passino). BipartiteGraph no longer stores the node properties (former _V1 and _V2), nor does it store a dense adjacency matrix anymore, nor an edge list. Instead, it stores the graph structure as lists of neighboring nodes. This yields a significant memory/speed improvement for large factor graphs, and is more elegant as well. Iterating over neighbors is made easy by using boost::foreach. * Added conditional compilation of inference methods. * VarSet is now implemented using a std::vector instead of a std::set, which yields a significant speed improvement. Furthermore, the implementation has been generalized, resulting in the small_set class which can be used to represent sets of small cardinality; VarSet is the specialization with T = Var. * Improved ClusterGraph implementation, yielding significant speedups for the JunctionTree algorithm on large factorgraphs. Code cleanup: * Moved everything into namespace "dai". * Renamed DEBUG to DAI_DEBUG to avoid conflicts. * Replaced ENUM2,ENUM3,ENUM4,ENUM5,ENUM6 by single DAI_ENUM macro. * Removed utils/remove_short_loops and matlab/remove_short_loops. * Replaced sub_nb class in mr.h by boost::dynamic_bitset. * Improved index.h: - Renamed Index -> IndexFor - Added some .reserve()'s to IndexFor methods which yields a 25% speedup of testregression - Replaced multind by Permute - Added MultiFor - Added State * New funcstionality of factor.h. * Moved Properties and MaxDiff frameworks from InfAlg to each individual inference algorithm, because the Properties framework was not as convenient as I hoped, and not every inference algorithm needs a maxdiff variable. Also, replaced some FactorGraph functionality in InfAlg by a function that returns the FactorGraph. The result is cleaner (less entangled) code. * Removed x2x. * Replaced Complex with real numbers (negative potentials are just too rare to warrant the additional "complexity" :)). Miscellaneous improvements: * Now compiles also with MS Visual C++ (thanks to Jiuxiang Hu) and with GCC under cygwin. * Contributions by Peter Gober: - Renamed variable _N in mr.* for compatibility with g++ under cygwin. * Misc contributions by Giuseppe Passino: - removed "using namespace std;" from header files - bad practice; - moved header files in include/dai and sources in src; - changed #ifndefs to GNU style; - added extra warning checks (-W -Wextra) and fixed resulting warnings; - dai::TProb: o removed copy constructor and assignment operators (redundant); o implementation of some methods via STL algorithms; o added methods takeExp, takeLog, takeLog0 for transformation in-place; o explicit constructor (prevents implicit conversion from size_t to TProb); o added operator+,+=,-,-=, with argument T (for calculations in log-scale); * Misc contributions by Christian Wojek: - New FactorGraph constructor that constructs from given ranges of factors and variables; - Optimization of FactorGraph constructors using tr1::unordered_map. * FactorGraph constructors no longer check for short loops (huge speed increase for large factor graphs), nor for negative entries. Also, the normtype is now Prob::NORMPROB by default. * Improved MaxSpanningTreePrims algorithm (uses boost::graph). Interface changes: * VarSet:: - VarSet::stateSpace() -> nrStates(const VarSet &) - VarSet( const std::set ) -> VarSet( begin, end, sizeHint=0 ) - VarSet( const std::vector ) -> VarSet( begin, end, sizeHint=0 ) - removed bool operator|| - operator&&(const VarSet&) -> intersects(const VarSet&) - operator&&(const Var&) -> contains(const Var&) * FactorGraph:: - delta(const Var &) -> delta(size_t) - Delta(const Var &) -> Delta(size_t) - makeCavity(const Var &) -> makeCavity(size_t) - vars() -> vars - factors() -> factors - removed MakeFactorCavity(size_t) - removed ExactMarginal(const VarSet &) - removed ExactlogZ() - removed updatedFactor(size_t) - removed _normtype and NormType() - removed hasShortLoops(...) and removeShortLoops(...) - WriteToDotFile(const char *filename) -> printDot( std::ostream& os ) - undoProb(size_t) -> restoreFactor(size_t) - saveProb(size_t) -> backupFactor(size_t) - undoProbs(const VarSet &) -> restoreFactors(const VarSet &) - saveProbs(const VarSet &) -> backupFactors(const VarSet &) - ReadFromFile(const char*) returns void (throws on error) - WriteToFile(const char*) returns void (throws on error) - removed hasNegatives() * RegionGraph:: - nr_ORs() -> nrORs() - nr_IRs() -> nrIRs() - ORs() -> ORs - IRs() -> IRs * *::Regenerate() -> *::construct() * Renamed Index -> IndexFor * Diffs: - max() -> maxDiff() - max_size() -> maxSize() * Prob::max() -> Prob::maxVal() * Factor:: - max() -> maxVal() - part_sum() -> partSum() * toc() in util.h now returns seconds as a double * VarSet::operator&& * Properties -> PropertySet libDAI-0.2.1 (2008-05-26) ------------------------- Bugfix release. * added missing cstdio header in util.h * fixed Properties in MR_CLAMPING_* and MR_EXACT_* * added description of the factor graph fileformat * improved Makefile libDAI-0.2.0 (2006-11-30) ------------------------- First public release. 0.1.5 (2006-11-30) ------------------ Regressions - tests/testlcbp and tests/testlcbp are broken. - EXACT method does not work anymore. - The Properties framework gives a speed penalty because of the lookup costs involved; inner loops should be optimized. General framework - DAIAlg is now a template class; typedefs for DAIAlg and for DAIAlg are provided. In this way, we do not have to write "wrapper" functions to forward functionality from either FactorGraph or RegionGraph to DAIAlg. Functionality like clamping can be implemented in FactorGraph and in RegionGraph and no explicit interface is needed in descendants. - New abstract base class InfAlg added, representing an inference algorithm, from which DAIAlg inherits. This solves the incompatibility problems of DAIAlg for different T (e.g. DAIAlg was incompatible with DAIAlg). More work is required to reduce code duplication (make FactorGraph part of InfAlg). - Added generic interface (nrVars(), Vars(), nrFactors(), factor(size_t), beliefs(), belief(VarSet &), ...) to InfAlg and descendants. - Added a saveProbs/undoProbs interface to InfAlg and descendants that enables one to save a few factors, modify them (e.g. clamp them), and then restore them to their old values. Undo should also init the corresponding messages / beliefs. This can be used if a given factor graph repeatedly needs to be clamped in different ways and an approximation method is run for each clamping; using the saveProbs/undoProbs can give a significant speed increase. - Switched to a general Properties framework that handles the parameters of all inference methods in a uniform manner. The Properties class is a map of several properties in boost::any objects, indexed by their names (strings). It can read from a stream and write to a stream. It is recursive, in the sense that a Properties object can hold a variable of type Properties as well. - Added a generic way of constructing inference algorithms from a factor graph, name and properties object. Added the newInfAlg function which constructs the requested object. This is used by LCBP, the Matlab interface and the command line (test) interface. - Added a generic enum framework for enum parameters. Although implemented as a hack, it is quite useful in that it drastically simplifies and reduces the amount of code for handling enum parameters. - Provided generic functions for calculating marginals in different ways that work for all approximate inference methods. Bugfixes - Fixed GBP free energy. - Fixed bug in junctiontree (it didn't init the _vars variable). - Corrected two bugs in operator&& and operator|| in VarSet (they returned the logical NOT of what they should return). - Fixed bug in RegionGraph::RecomputeOR(s). - Fixed bug in utils/create_dreg_fg: graph structure was not random for given parameters (forgot to call srand()). - TreeEP bug workaround: use the complete junction tree instead of a subtree. - Fixed bug in JTree::HUGIN() and JTree:ShaferShenoy() in case of junction tree that consists of one outer region only. - Fixed INIT bug in LCBP2::UpdatePancake(). - Fixed MaxDiffs flow (except for MR). New functionality - HAK supports several default cluster choices: minimal (only factors) delta (Markov blankets) loop (all loops consisting of loops consisting of or less variables) Only the maximal clusters are used as outer clusters. - Implemented TreeEP. It generalizes the heuristic method described in the Minka & Qi paper for obtaining a tree with the most relevant interactions to higher order interactions. Almost all optimizations described in the Minka & Qi paper are used, except that evidence is passed over the whole tree instead of relevant subsets (the latter is almost implemented but buggy). Also added alternative (worst-case) algorithm that uses a maximum spanning tree on the weighted graph where the weight between neighbours i and j is given by N(psi,i,j), where psi is the product of all the factors involving both i and j (which is an upper bound on the effective interaction between i and j). - Implemented MR (MontanariRizzo) based on Bastian's code, but extended it to be able to handle connectivities larger than 3 (in principle, up to 32). It supports different initialization methods (the original RESPPROP, the CLAMPING method and EXACT which uses JTree) and different update methods (FULL and LINEAR). - Implemented LCBP2, an analogon of LCBP which represents pancakes as little networks and uses some approximate inference method on them for calculating marginals. - Now there are several LCBP variants (LCBP, LCBPI, LCBPJ, LCBPK, LCBPL); LCBPJ works only for pairwise, LCBPK is LCBP improved for higher order interactions and LCBPL is LCBPI improved for higher-order interactions. - Wrote one single program utils/createfg for creating various types of random factor graphs. - Wrote utility to visualize factor graphs using graphviz. (it uses the BOOST Program Options library) - Added fginfo utility that displays some info about a .fg file. - Implemented Factor::strength function that calculates the potential strength N(psi,i,j) between variables i and j as described in cs.IT:0504030 - Wrote a general MatLab interface matlab/dai (similar to tests/test); this unified the matlab functions dai, dai_bp, dai_mf, dai_jt, dai_tep, dai_cvm. - Added MATLAB routine that returns contraction matrix A for BP convergence analysis. - Implemented a MATLAB interface ai_potstrength for Factor::strength - Added Martijn's x2x Improvements of existing code - Reimplemented RegionGraph and descendants: a RegionGraph ISA FactorGraph and also a BipartiteGraph. It now also keeps a map that associates outer region indices to factor indices (no powers yet, this is deemed superfluous) and provides functions to recompute (some of) the outer regions from the factors. - InfAlg descendants run() methods now stop immediately and return NAN in case they detect NANs. Only BP does not do NAN checking for performance reasons. - LCBP now works with factors containing zeroes (by defining x/0 = 0). - HAK, GBP and DoubleLoop now conform to the standards for verbose reporting, timing and convergence criteria. - Implemented logZ() for JTree. It does the calculation during message-passing. - Marginal2ndO now optionally divides by the single node beliefs (to the power n-2); hopefully this will give more accurate approximations. - Marginal and Marginal2ndO (optionally) use the new saveProbs/undoProbs functionality for a faster way of calculating marginals, which does not require a call to init() nor cloning the whole object for each clamping. This leads to a significant speedup. - LCBP (and LCBP2) now have complete flexibility in the specification of the inner method, i.e. the method used to generate the initial cavity approximations. One can pass two strings, a name and a properties string, and LCBP simply invokes newInfAlg to construct the corresponding inference algorithm and uses the generic marginal functions to approximate cavity marginals. - Replaced the global "method" variable by local properties and removed ai.h - Added some methods to Factor (operators *, *=, /, /= with doubles as second argument, operators -, +=, -= with other Factors as second arguments, randomize(), RemoveFirstOrderInteractions) and similar operations to Prob - Moving towards boost::program_options for handling command line arguments (tests/test is done). - Renamed some FactorGraph methods: nr_vars -> nrVars nr_factors -> nrFactors varind -> findVar factorind -> findFactor makeFacCavity -> makeFactorCavity - LCBP_SEQMAXRES has been removed because it did strange things. - Implemented RandomDRegularGraph - Implemented JTree::calcMarginal for marginals that are not confined within one cluster (using cut-set conditioning). - Added isConnected() method to FactorGraph (some methods do not work with disconnected factor graphs). - Pair beliefs are now calculated in a symmetrical way by calcPairBeliefs - Removed single node interaction "correction" code from clamping methods - Removed calcCavityDist and calcCavityDist2ndO - No longer depends on GSL. - Increased portability by combining platform dependant utility functions in util.{h,cpp}. - Wrote *.m files providing help Testing framework - Made a new and significantly improved testing framework that provides most functionality from the command line. - The basis is provided by tests/test, which uses the newInfAlg functionality and enables the user to easily compare from the command line different inference methods on a given factorgraph. All parameters can be specified. Output consists of CPU time, average and maximum single variable marginal errors, relative logZ error and MaxDiff(). - tests/aliases.conf contains aliases for standard combinations of methods and their options (which can be used in tests/test). - tests/large contains several bash/python scripts that create random factor graphs, compare several approximate inference algorithms (using tests/test) and allow for easy visualization of the results using PyX. - Added several .fg files for test purposes to /tests (e.g. two ALARM versions alarm.fg and alarm_bnt.fg; testfast.fg, a 4x4 periodic Ising grid for regression testing). - Added a regression test to the Makefile which is included in the standard target. It compares all inference methods on tests/testfast.fg with the results stored in tests/testfast.out Miscellaneous - Expanded all tabs to spaces (":set tabstop 4\n:set expandtab\n:retab" in vim) - Experimental MATLAB code added for StarEP approximation on cavity - Renamed project to libDAI and changed directory name accordingly. - Renamed JunctionTree to JTree. - Fixed licensing (now it's officially GPL). - Improved README revision 252 ------------ Functionality - Added RegionGraph, GBP, CVM and HAK (double-loop). - Added JunctionTree (with two update algorithms, HUGIN and Shafer-Shenoy), which is a RegionGraph. - NormType is now chosen automatically (in case of negative factors, Prob::NORMLINF is used, otherwise the default Prob::NORMPROB is used). Also, in case of negative factors, the RegionGraph constructors assign each Factor to a unique outer region instead of dividing it over all subsuming outer regions. See README for when negative factors are known to work and when not. - FactorGraph::FactorGraph(const vector) only gives a warning in case of short loops, it does not automatically merge factors anymore. - Removed BP_SEQMAXRESNOCLEAR (all cavity initialization methods now are implicitly NOCLEAR) - Added MATLAB interface functions ai_readfg, ai_removeshortloops and ai_bp - Added LCBP-III type that should be equivalent to LCBP-II, but can handle zeroes in potentials. Note that it is significantly slower than LCBP-II (and has to be reimplemented such that it does not store the complete pancakes, but represents them as little factor graphs). Implementation / code - Made a seperate type WeightedGraph, which until now only implements Prim's maximal spanning tree algorithm and is only used by the junction tree code. It might be good to make it a class somewhere in the future and extend it's interface. - Made a seperate class ClusterGraph, which is only used by the junction tree code. It's main purpose is a graph-theoretical variable elimination algorithm. - Implemented the heuristic "minimum-new-edges-in-clique-graph" for variable elimination. - Massive code cleanup, moving towards "generic" programming style, using multiple inheritance and polymorphism. o BP, LCBP, MF, HAK and JunctionTree now inherit from a common DAIAlg class o Made generic functions Marginal, Marginal2ndO, calcCavityDist, calcCavityDist2ndO, clamp that can be used by FactorGraph-based DAIAlgs. o Created TProb class, which stores a probability vector (without the accompanying indexing and VarSet) and provides functionality for it (which is used by TFactor). o Rewrote the VarSet class. It now caches its statespace(). It now privately inherits from set. I had to overload the insert methods of set so that they calculate the new statespace. o Rewrote the TFactor class. The TFactor class now HAS a TProb and HAS a VarSet. - Rewrote BP to use the new TProb interface. Performance of BP improved up to a factor 6 by: o using Prob's instead of Factor's; o splitting the multiplication of the messages into two parts (thanks to Vicenc!); o optimizing the calculation of the beliefs (only the message calculations were optimized till now). o replacing FactorGraph::_nb1 and _nb2 (which were set) by vector - LCBP now seperately stores cavitydists and pancakes. Added InitPancakes() method that takes the cavitydists and multiplies them with the relevant factors. This resulted in an API change in AI which now accepts and returns initial cavitydists instead of initial pancakes. Minor changes - Started writing DoxyGen documentation - Renamed lcptab2fg.m matlab/ai_writefg.m - Moved all matlab stuff to matlab/ - More detailed reporting (also reports clocks used). - Marginal and Marginal2ndO now use *differences* in logZ to avoid NaNs. - Improved testing suite. - Removed logreal support. - FactorGraph now also supports input streams and ignores comment lines in .fg files. - Added tests/create_full_fg.cpp and tests/create_ising_fg.cpp which create full and periodic 2D Ising networks according to some command line parameters. - Now logZ really returns logZ instead of -logZ. - Added FactorGraph::WriteToDotFile 0.1.4 (2006-04-13) ------------------ - Added file IO routines to read and write factorgraphs. - Added L-infinity normalization for use with (partially) negative factors. - Renamed BetheF, MFF to logZ, which now use complex numbers to be able to handle (partially) negative factors. - Added test suite. - All probabilities are now represented using double instead of LogReal. - Combined Alg and Alg3 into LCBP. Several update schemes possible. - Combined several variants of BP into doBP. Several update schemes possible. Now uses precalculated indices for optimization. - Renamed Node -> Var and Potential -> Factor. - Extensive code cleanup. More use of OO techniques. Changed API. - MaxIter now means maximum number of passes (corresponding to number of _parallel_ updates). - MaxDiff now means the maximum L-infinity distance between the updated and original single variable beliefs, for all AI methods. - Implemented RBP which converges faster than BP for difficult problems. - Now uses method parameter which is a bitmask combining outmethod and inmethod (see ai.h). 0.1.3 (2006-03-22) -------------------- - All AI methods now return maxdiff - ai.cpp: o Now returns maxdiffinner and maxdiffouter o New BP2ndO innermethod (estimate only 2nd order cavity interactions) o New InitCav outermethod (only create initial cavity distributions) - bp.cpp: o New CavityDist2ndO which estimates 2nd order cavity interactions - Makefile: o Bugfix: removed dependencies on algwim.* 0.1.2 (2006-02-28) -------------------- - Cleaned up alg.cpp (removed Alg2 and its corresponding data structures). - Added the possibility to provide initial cavity distributions as an input argument to ai (not much error checking is done, so be careful). - Potentials2mx now correctly sets the dimensions of the P field (i.e. for the output arguments Q, Q0 of ai). - Removed algwim.* since it does not work. 0.1.1 (2006-02-28) -------------------- - The constructors of (Log)FactorGraph and LogFactorGraph from a vector<(Log)Potential> now merge potentials to prevent short loops (of length 4) in the factor graph. These are used in ai to construct the factor graphs from the psi argument. If compiled with DEBUG defined, the method calc_nb() of BipGraph checks for the existence of short loops. - Changed calling syntax of ai (now the actual syntax *does* correspond to its description in the help). - ai does not hook cout anymore (which caused weird segfaults). - Fixed a bug in an assert statement in the matlab interface code in ai.cpp. - Removed network.* since it is not useful. 0.1.0 (2006-02-28) -------------------- First version worthy a version number. libDAI-0.2.4/Makefile.WINDOWS0000644000263000017630000000417411334764771014271 0ustar jorismkyb# This file is part of libDAI - http://www.libdai.org/ # # libDAI is licensed under the terms of the GNU General Public License version # 2, or (at your option) any later version. libDAI is distributed without any # warranty. See the file COPYING for more details. # # Copyright (C) 2009-2010 Joris Mooij [joris dot mooij at libdai dot org] # This template contains configurations for compiling libDAI with Visual C++ # under Windows (and GNU Make) # # To use it, simply copy this file to 'Makefile.conf' and adapt 'Makefile.conf' # to your local setup # OPERATING SYSTEM # Choose OS from {LINUX, WINDOWS, CYGWIN, MACOSX} OS=WINDOWS # FILE EXTENSIONS # Static library LE=.lib # Object file OE=.obj # Binary executable EE=.exe # MatLab compiled MEX file ME=.mexglx # COMPILER # Compile using Visual C++ Compiler CC=cl # Output filename option of the compiler CCO=/Fe # Flags for the C++ compiler CCFLAGS=/EHsc -DWINDOWS -DNOMINMAX # Flags to add in debugging mode (if DEBUG=true) CCDEBUGFLAGS=/Ox /Zi -DDAI_DEBUG # Flags to add in non-debugging mode (if DEBUG=false) CCNODEBUGFLAGS=/Ox # Standard include directories CCINC=/Iinclude /IE:\boost_1_42_0 # LINKER # Standard libraries to include LIBS=/link $(LIB)/libdai$(LE) # For linking with the BOOST Program Options library BOOSTLIBS=/LIBPATH:E:\boost_1_42_0\stage\lib # Additional library search paths for linker # (For some reason, we have to add the VC library path, although it is in the environment) CCLIB=/LIBPATH:"C:\Program Files\Microsoft Visual Studio 9.0\VC\ATLMFC\LIB" /LIBPATH:"C:\Program Files\Microsoft Visual Studio 9.0\VC\LIB" /LIBPATH:"C:\Program Files\Microsoft SDKs\Windows\v6.0A\lib" # MATLAB # Replace the following by the directory where MatLab has been installed MATLABDIR=c:\matlab # The following should resolve to the MatLab mex compile command MEX=$(MATLABDIR)\bin\mex # Specify the same C++ compiler and flags to mex MEXFLAGS=CXX\#$(CC) CXXFLAGS\#"$(CCFLAGS)" # SWIG PYTHON INTERFACE # The following should resolve to the SWIG command SWIG=swig # Location of Python header files INCLUDE_PYTHON=C:\python2.5 # Location of Boost C++ library header files INCLUDE_BOOST=E:\boost_1_42_0 libDAI-0.2.4/customdoxygen.css0000644000263000017630000002000711334764771015113 0ustar jorismkybBODY,H1,H2,H3,H4,H5,H6,P,CENTER,TD,TH,UL,DL,DIV { font-family: Geneva, Arial, Helvetica, sans-serif; } EM { color: #602020; } BODY,TD { font-size: 90%; } H1 { text-align: center; font-size: 160%; } H2 { font-size: 120%; } H3 { font-size: 100%; } CAPTION { font-weight: bold } DIV.qindex { width: 100%; background-color: #e8eef2; border: 1px solid #84b0c7; text-align: center; margin: 2px; padding: 2px; line-height: 140%; } DIV.navpath { width: 100%; background-color: #e8eef2; border: 1px solid #84b0c7; text-align: center; margin: 2px; padding: 2px; line-height: 140%; } DIV.navtab { background-color: #e8eef2; border: 1px solid #84b0c7; text-align: center; margin: 2px; margin-right: 15px; padding: 2px; } TD.navtab { font-size: 70%; } A.qindex { text-decoration: none; font-weight: bold; color: #1A419D; } A.qindex:visited { text-decoration: none; font-weight: bold; color: #1A419D } A.qindex:hover { text-decoration: none; background-color: #ddddff; } A.qindexHL { text-decoration: none; font-weight: bold; background-color: #6666cc; color: #ffffff; border: 1px double #9295C2; } A.qindexHL:hover { text-decoration: none; background-color: #6666cc; color: #ffffff; } A.qindexHL:visited { text-decoration: none; background-color: #6666cc; color: #ffffff } A.el { text-decoration: none; font-weight: bold } A.elRef { font-weight: bold } A.code:link { text-decoration: none; font-weight: normal; color: #0000FF } A.code:visited { text-decoration: none; font-weight: normal; color: #0000FF } A.codeRef:link { font-weight: normal; color: #0000FF } A.codeRef:visited { font-weight: normal; color: #0000FF } A:hover { text-decoration: none; background-color: #f2f2ff } DL.el { margin-left: -1cm } .fragment { font-family: monospace, fixed; font-size: 95%; } PRE.fragment { border: 1px solid #CCCCCC; background-color: #f5f5f5; margin-top: 4px; margin-bottom: 4px; margin-left: 2px; margin-right: 8px; padding-left: 6px; padding-right: 6px; padding-top: 4px; padding-bottom: 4px; } DIV.ah { background-color: black; font-weight: bold; color: #ffffff; margin-bottom: 3px; margin-top: 3px } DIV.groupHeader { margin-left: 16px; margin-top: 12px; margin-bottom: 6px; font-weight: bold; } DIV.groupText { margin-left: 16px; font-style: italic; font-size: 90% } BODY { background: white; color: black; margin-right: 20px; margin-left: 20px; } TD.indexkey { background-color: #e8eef2; font-weight: bold; padding-right : 10px; padding-top : 2px; padding-left : 10px; padding-bottom : 2px; margin-left : 0px; margin-right : 0px; margin-top : 2px; margin-bottom : 2px; border: 1px solid #CCCCCC; } TD.indexvalue { background-color: #e8eef2; font-style: italic; padding-right : 10px; padding-top : 2px; padding-left : 10px; padding-bottom : 2px; margin-left : 0px; margin-right : 0px; margin-top : 2px; margin-bottom : 2px; border: 1px solid #CCCCCC; } TR.memlist { background-color: #f0f0f0; } P.formulaDsp { text-align: center; } IMG.formulaDsp { } IMG.formulaInl { vertical-align: middle; } SPAN.keyword { color: #008000 } SPAN.keywordtype { color: #604020 } SPAN.keywordflow { color: #e08000 } SPAN.comment { color: #800000 } SPAN.preprocessor { color: #806020 } SPAN.stringliteral { color: #002080 } SPAN.charliteral { color: #008080 } SPAN.vhdldigit { color: #ff00ff } SPAN.vhdlchar { color: #000000 } SPAN.vhdlkeyword { color: #700070 } SPAN.vhdllogic { color: #ff0000 } .mdescLeft { padding: 0px 8px 4px 8px; font-size: 80%; font-style: italic; background-color: #FAFAFA; border-top: 1px none #E0E0E0; border-right: 1px none #E0E0E0; border-bottom: 1px none #E0E0E0; border-left: 1px none #E0E0E0; margin: 0px; } .mdescRight { padding: 0px 8px 4px 8px; font-size: 80%; font-style: italic; background-color: #FAFAFA; border-top: 1px none #E0E0E0; border-right: 1px none #E0E0E0; border-bottom: 1px none #E0E0E0; border-left: 1px none #E0E0E0; margin: 0px; } .memItemLeft { padding: 1px 0px 0px 8px; margin: 4px; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-top-color: #E0E0E0; border-right-color: #E0E0E0; border-bottom-color: #E0E0E0; border-left-color: #E0E0E0; border-top-style: solid; border-right-style: none; border-bottom-style: none; border-left-style: none; background-color: #FAFAFA; font-size: 80%; } .memItemRight { padding: 1px 8px 0px 8px; margin: 4px; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-top-color: #E0E0E0; border-right-color: #E0E0E0; border-bottom-color: #E0E0E0; border-left-color: #E0E0E0; border-top-style: solid; border-right-style: none; border-bottom-style: none; border-left-style: none; background-color: #FAFAFA; font-size: 80%; } .memTemplItemLeft { padding: 1px 0px 0px 8px; margin: 4px; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-top-color: #E0E0E0; border-right-color: #E0E0E0; border-bottom-color: #E0E0E0; border-left-color: #E0E0E0; border-top-style: none; border-right-style: none; border-bottom-style: none; border-left-style: none; background-color: #FAFAFA; font-size: 80%; } .memTemplItemRight { padding: 1px 8px 0px 8px; margin: 4px; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-top-color: #E0E0E0; border-right-color: #E0E0E0; border-bottom-color: #E0E0E0; border-left-color: #E0E0E0; border-top-style: none; border-right-style: none; border-bottom-style: none; border-left-style: none; background-color: #FAFAFA; font-size: 80%; } .memTemplParams { padding: 1px 0px 0px 8px; margin: 4px; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-top-color: #E0E0E0; border-right-color: #E0E0E0; border-bottom-color: #E0E0E0; border-left-color: #E0E0E0; border-top-style: solid; border-right-style: none; border-bottom-style: none; border-left-style: none; color: #606060; background-color: #FAFAFA; font-size: 80%; } .search { color: #003399; font-weight: bold; } FORM.search { margin-bottom: 0px; margin-top: 0px; } INPUT.search { font-size: 75%; color: #000080; font-weight: normal; background-color: #e8eef2; } TD.tiny { font-size: 75%; } a { color: #1A41A8; } a:visited { color: #2A3798; } .dirtab { padding: 4px; border-collapse: collapse; border: 1px solid #84b0c7; } TH.dirtab { background: #e8eef2; font-weight: bold; } HR { height: 1px; border: none; border-top: 1px solid black; } /* Style for detailed member documentation */ .memtemplate { font-size: 80%; color: #606060; font-weight: normal; margin-left: 3px; } .memnav { background-color: #e8eef2; border: 1px solid #84b0c7; text-align: center; margin: 2px; margin-right: 15px; padding: 2px; } .memitem { padding: 4px; background-color: #eef3f5; border-width: 1px; border-style: solid; border-color: #dedeee; -moz-border-radius: 8px 8px 8px 8px; } .memname { white-space: nowrap; font-weight: bold; } .memdoc{ padding-left: 10px; } .memproto { background-color: #d5e1e8; width: 100%; border-width: 1px; border-style: solid; border-color: #84b0c7; font-weight: bold; -moz-border-radius: 8px 8px 8px 8px; } .paramkey { text-align: right; } .paramtype { white-space: nowrap; } .paramname { color: #602020; font-style: italic; white-space: nowrap; } /* End Styling for detailed member documentation */ /* for the tree view */ .ftvtree { font-family: sans-serif; margin:0.5em; } .directory { font-size: 9pt; font-weight: bold; } .directory h3 { margin: 0px; margin-top: 1em; font-size: 11pt; } .directory > h3 { margin-top: 0; } .directory p { margin: 0px; white-space: nowrap; } .directory div { display: none; margin: 0px; } .directory img { vertical-align: -30%; } libDAI-0.2.4/scripts/0000755000263000017630000000000011334764771013161 5ustar jorismkyblibDAI-0.2.4/scripts/makeREADME0000755000263000017630000000264711334764771014713 0ustar jorismkyb#!/bin/bash echo "libDAI - A free/open source C++ library for Discrete Approximate Inference" > README echo >> README echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━" >> README echo >> README echo "Version: $DAI_VERSION" >> README echo "Date: $DAI_DATE" >> README echo "See also: http://www.libdai.org" >> README echo >> README w3m -dump doc/html/license.html | awk 'BEGIN {start=0}; $1 ~ /━/ {start=start+1; if (start<2) print $0}; $1 !~ /━/ {if (start>0 && start<2) print $0}' >> README echo "You should have received a copy of the GNU General Public License" >> README echo "along with libDAI in the file COPYING. If not, see http://www.gnu.org/licenses/" >> README echo >> README w3m -dump doc/html/citations.html | awk 'BEGIN {start=0}; $1 ~ /━/ {start=start+1; if (start<2) print $0}; $1 !~ /━/ {if (start>0 && start<2) print $0}' >> README w3m -dump doc/html/index.html | awk 'BEGIN {start=0}; $1 ~ /━/ {start=start+1; if (start<2) print $0}; $1 !~ /━/ {if (start>0 && start<2) print $0}' >> README w3m -dump doc/html/build.html | awk 'BEGIN {start=0}; $1 ~ /━/ {start=start+1; if (start>0 && start<5) print $0}; $1 !~ /━/ {if (start>0 && start<5) print $0}' >> README sed -i 's/━/-/g' README sed -i 's/•/*/g' README libDAI-0.2.4/scripts/regenerate-properties0000755000263000017630000002206511334764771017427 0ustar jorismkyb#!/usr/bin/perl # # This file is part of libDAI - http://www.libdai.org/ # # libDAI is licensed under the terms of the GNU General Public License version # 2, or (at your option) any later version. libDAI is distributed without any # warranty. See the file COPYING for more details. # # Copyright (C) 2009 Frederik Eaton [frederik at ofb dot net] use warnings; use strict; use Cwd 'abs_path'; @ARGV == 2 or die "Need 2 arguments"; my ($header_file,$source_file) = @ARGV; @ARGV=(); # Regular expressions for nested brackets (uses perl 5.10 features) my ($nested_angle_brackets) = qr/(<(?:[^<>]++|(?1))*>)/; my ($nested_curly_brackets) = qr/({(?:[^{}]++|(?1))*})/; my ($nested_parentheses) = qr/(\((?:[^()]++|(?1))*\))/; # Patterns to match generated code blocks my ($gen_code_start_pat, $gen_code_end_pat, $props_start_pat) = (qr(/\*.*GENERATED CODE: DO NOT EDIT.*), qr(/\*.*END OF GENERATED CODE.*\*/), qr(/\*.*PROPERTIES)); # Actual delimiters to use for generated code blocks my ($gen_code_start, $gen_code_end) = ("/* {{{ GENERATED CODE: DO NOT EDIT. Created by\n". " $0 $header_file $source_file\n*/\n", "/* }}} END OF GENERATED CODE */\n"); # Strings to hold text of files my $header_buffer=""; my $source_buffer=""; # ---------------------------------------------------------------- # Useful routines # remove leading and trailing whitespace sub stripws ($) { my ($s) = @_; $s =~ s/^\s*//s; $s =~ s/\s*$//s; return $s; } # split comments and non-comments, returning 2-element array # of (uncommented part, comments) my $comment_pat = qr#(/\*[^*]*\*+(?:[^/*][^*]*\*+)*/|//[^\n]*)|("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|.[^/"'\\]*)#; sub sepcomment ($) { my ($c) = @_; my ($u) = $c; $u =~ s#$comment_pat#defined $2 ? $2 : ""#gse; $c =~ s#$comment_pat#defined $1 ? $1 : ""#gse; return ($u, $c); } # Run diff, return output sub getdiff ($$) { my ($a,$b) = @_; my $diff=""; open DIFF, "diff -u \Q$a\E \Q$b\E |" or die "Couldn't run diff"; while() { $diff .= $_; } close DIFF; return $diff; } sub myrename ($$) { my ($a,$b) = @_; $b = abs_path $b; rename($a, $b) or die "Couldn't rename $a to $b"; } sub writefile ($$) { my ($buf, $f) = @_; open OUT, ">", $f or die "Couldn't open $f for writing"; print OUT $buf; close OUT; } our ($buffer); # Step through file, appending lines to buffer # - Lines which match generated code blocks are omitted # - Other lines are passed to the subroutine. They are added to buffer # unless the subroutine returns 1 (e.g. if it has already added them) sub process_file (&$) { my ($sub, $file) = @_; local ($buffer) = ""; # step through lines of file, appending each one to buffer open IN, "<", $file or die "Couldn't open $file for reading"; while () { # delete anything between GENERATED CODE etc. if (/$gen_code_end_pat/) { die "Unmatched generated code block end at $file line $."; } elsif (/$gen_code_start_pat/) { my $s = $.; my $found=0; while () { chomp; if (/$gen_code_end_pat/) { $found=1; last; } } die "Unterminated generated code block at $file line $s" unless $found; next; } else { my ($res) = &$sub; next if $res; } $buffer .= $_; } close IN; return $buffer; } # Parse a PROPERTIES() block sub process_properties ($$$) { my ($file, $start_line, $props_text) = @_; my ($errline)="$file:$start_line"; $props_text =~ s/^.*PROPERTIES\s*($nested_parentheses)//s or die "Malformed PROPERTIES, $errline: expected PROPERTIES(args)"; my ($args) = $1; $args =~ s/^\(//g; $args =~ s/\)$//g; my (@args) = split /,/, $args; @args == 2 or die "PROPERTIES needs two arguments at $errline"; my ($struct_name, $class) = @args; $props_text =~ m/^\s*($nested_curly_brackets)\s*$/s or die "Malformed PROPERTIES, $errline: expected {} after PROPERTIES"; my ($body) = $1; $body =~ s/^{(.*)}$/$1/s; # get rid of curly brackets my (@stmts) = split /;\s*\n/s, $body; # split on ";" my (@typedecls) = (); my (@vars) = (); foreach my $s (@stmts) { my ($s, $cmt) = sepcomment $s; $cmt = stripws $cmt; if($s =~ /^\s*$/s) { # extra ";" next; } elsif($s =~ /DAI_ENUM|typedef/) { push @typedecls, [stripws $s, $cmt]; } else { $s =~ /^\s*[a-zA-Z_][\w:]+\s*$nested_angle_brackets?/ or die "Couldn't match statement $s in PROPERTIES at $errline"; my $type = stripws $&; my $name = stripws $'; my $default = undef; if($name =~ /^(.*)=(.*)$/) { $name = stripws $1; $default = stripws $2; } push @vars, [$type, $name, $default, $cmt]; } } my ($stext) = ""; my ($text) = < &keys = opts.keys(); std::string errormsg; for( std::set::const_iterator i = keys.begin(); i != keys.end(); i++ ) { EOF for my $v (@vars) { my ($type,$name,$default,$cmt) = @$v; $stext .= <("$name"); } else { $name = $default; } EOF } else { $stext .= <("$name"); EOF } } $stext .= <) { last if(m(\*/)); $props_text .= $_; } $buffer .= $props_text; $buffer .= $_; my ($htext, $stext) = process_properties($header_file, $start_line, $props_text); $buffer .= $htext; $source_buffer .= "\n\n\n".$stext; return 1; } return 0; } $header_file; # Write new contents of files to temporary locations my $header_tmp = "$header_file.new"; my $source_tmp = "$source_file.new"; writefile ($header_buffer, $header_tmp); writefile ($source_buffer, $source_tmp); # Get a diff of changes, show it to the user, and ask for confirmation my ($diff); $diff = getdiff ($header_file, $header_tmp); $diff .= getdiff ($source_file, $source_tmp); if($diff eq '') { warn "No differences\n"; } else { my $pager = $ENV{PAGER} || "less"; open PAGER, "|$pager"; print PAGER $diff; close PAGER; print STDERR "Replace old with new version? (y|N) "; $_=<>; if (/^y/i) { myrename($header_tmp, $header_file); myrename($source_tmp, $source_file); } else { warn "Aborted\n"; } } libDAI-0.2.4/matlab/0000755000263000017630000000000011334764771012732 5ustar jorismkyblibDAI-0.2.4/matlab/dai_potstrength.m0000644000263000017630000000045211334764771016307 0ustar jorismkyb% N = dai_potstrength (psi, i, j) % % INPUT: psi = structure with a Member field and a P field, like a CPTAB. % i = label of a variable in psi. % j = label of another variable in psi. % % OUTPUT: N = strength of psi in direction i->j. libDAI-0.2.4/matlab/dai_readfg.m0000644000263000017630000000042511334764771015156 0ustar jorismkyb% [psi] = dai_readfg (filename) % % INPUT: filename = filename of a .fg file % % OUTPUT: psi = linear cell array containing the factors % (psi{i} is a structure with a Member field % and a P field, like a CPTAB). libDAI-0.2.4/matlab/dai_writefg.m0000644000263000017630000000042611334764771015376 0ustar jorismkyb% dai_writefg(psi,filename) % % INPUT: psi = linear cell array containing the factors % (psi{i} should be a structure with a Member field % and a P field, like a CPTAB). % filename = filename of a .fg file libDAI-0.2.4/matlab/dai.m0000644000263000017630000000113311334764771013643 0ustar jorismkyb% [logZ,q,md] = dai (psi, method, opts) % % INPUT: psi = linear cell array containing the factors % psi{i} should be a structure with a Member field % and a P field, like a CPTAB). % method = name of the method (see README) % opts = string of options (see README) % % OUTPUT: logZ = approximation of the logarithm of the partition sum. % q = linear cell array containing all final beliefs. % md = maxdiff (final linf-dist between new and old single node beliefs). libDAI-0.2.4/doc/0000755000263000017630000000000011334764771012237 5ustar jorismkyblibDAI-0.2.4/doc/html/0000755000263000017630000000000011334764774013206 5ustar jorismkyblibDAI-0.2.4/doc/html/classdai_1_1EMAlg-members.html0000644000263000017630000001731011334764771020614 0ustar jorismkyb libDAI: Member List

dai::EMAlg Member List

This is the complete list of members for dai::EMAlg, including all inherited members.

_estepdai::EMAlg [private]
_evidencedai::EMAlg [private]
_itersdai::EMAlg [private]
_lastLogZdai::EMAlg [private]
_log_z_toldai::EMAlg [private]
_max_itersdai::EMAlg [private]
_mstepsdai::EMAlg [private]
const_s_iterator typedefdai::EMAlg
EMAlg(const Evidence &evidence, InfAlg &estep, std::vector< MaximizationStep > &msteps, const PropertySet &termconditions)dai::EMAlg [inline]
EMAlg(const Evidence &evidence, InfAlg &estep, std::istream &mstep_file)dai::EMAlg
eStep() const dai::EMAlg [inline]
hasSatisfiedTermConditions() const dai::EMAlg
iterate()dai::EMAlg
iterate(MaximizationStep &mstep)dai::EMAlg
Iterations() const dai::EMAlg [inline]
LOG_Z_TOL_DEFAULTdai::EMAlg [static]
LOG_Z_TOL_KEYdai::EMAlg [static]
logZ() const dai::EMAlg [inline]
MAX_ITERS_DEFAULTdai::EMAlg [static]
MAX_ITERS_KEYdai::EMAlg [static]
run()dai::EMAlg
s_begin()dai::EMAlg [inline]
s_begin() const dai::EMAlg [inline]
s_end()dai::EMAlg [inline]
s_end() const dai::EMAlg [inline]
s_iterator typedefdai::EMAlg
setTermConditions(const PropertySet &p)dai::EMAlg

Generated on Thu Feb 11 12:26:03 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/varset_8h-source.html0000644000263000017630000003207111334764771017275 0ustar jorismkyb libDAI: include/dai/varset.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/namespacedai.html0000644000263000017630000053276511334764771016525 0ustar jorismkyb libDAI: dai Namespace Reference

dai Namespace Reference

Namespace for libDAI. More...


Classes

class  BBPCostFunction
 Predefined cost functions that can be used with BBP. More...
class  BBP
 Implements BBP (Back-Belief-Propagation) [EaG09]. More...
class  BipartiteGraph
 Represents the neighborhood structure of nodes in an undirected, bipartite graph. More...
class  BP
 Approximate inference algorithm "(Loopy) Belief Propagation". More...
class  BP_dual
 Calculates both types of BP messages and their normalizers from an InfAlg. More...
class  CBP
 Class for CBP (Conditioned Belief Propagation) [EaG09]. More...
class  ClusterGraph
 A ClusterGraph is a hypergraph with variables as nodes, and "clusters" (sets of variables) as hyperedges. More...
class  sequentialVariableElimination
 Helper object for dai::ClusterGraph::VarElim(). More...
class  greedyVariableElimination
 Helper object for dai::ClusterGraph::VarElim(). More...
class  InfAlg
 InfAlg is an abstract base class, defining the common interface of all inference algorithms in libDAI. More...
class  DAIAlg
 Combines the abstract base class InfAlg with a graphical model (e.g., a FactorGraph or RegionGraph). More...
class  ParameterEstimation
 Base class for parameter estimation methods. More...
class  CondProbEstimation
 Estimates the parameters of a conditional probability table, using pseudocounts. More...
class  SharedParameters
 Represents a single factor or set of factors whose parameters should be estimated. More...
class  MaximizationStep
 A MaximizationStep groups together several parameter estimation tasks (SharedParameters objects) into a single unit. More...
class  EMAlg
 EMAlg performs Expectation Maximization to learn factor parameters. More...
class  Evidence
 Stores a data set consisting of multiple samples, where each sample is the observed joint state of some variables. More...
class  ExactInf
 Exact inference algorithm using brute force enumeration (mainly useful for testing purposes). More...
class  Exception
 Error handling in libDAI is done by throwing an instance of the Exception class. More...
class  TFactor
 Represents a (probability) factor. More...
class  FactorGraph
 Represents a factor graph. More...
class  FBP
 Approximate inference algorithm "Fractional Belief Propagation" [WiH03]. More...
class  Gibbs
 Approximate inference algorithm "Gibbs sampling". More...
class  GraphAL
 Represents the neighborhood structure of nodes in an undirected graph. More...
class  HAK
 Approximate inference algorithm: implementation of single-loop ("Generalized Belief Propagation") and double-loop algorithms by Heskes, Albers and Kappen [HAK03]. More...
class  IndexFor
 Tool for looping over the states of several variables. More...
class  Permute
 Tool for calculating permutations of linear indices of multi-dimensional arrays. More...
class  multifor
 multifor makes it easy to perform a dynamic number of nested for loops. More...
class  State
 Makes it easy to iterate over all possible joint states of variables within a VarSet. More...
class  JTree
 Exact inference algorithm using junction tree. More...
class  LC
 Approximate inference algorithm "Loop Corrected Belief Propagation" [MoK07]. More...
class  MF
 Approximate inference algorithm "Mean Field". More...
class  MR
 Approximate inference algorithm by Montanari and Rizzo [MoR05]. More...
struct  fo_id
 Function object that returns the value itself. More...
struct  fo_abs
 Function object that takes the absolute value. More...
struct  fo_exp
 Function object that takes the exponent. More...
struct  fo_log
 Function object that takes the logarithm. More...
struct  fo_log0
 Function object that takes the logarithm, except that log(0) is defined to be 0. More...
struct  fo_inv
 Function object that takes the inverse. More...
struct  fo_inv0
 Function object that takes the inverse, except that 1/0 is defined to be 0. More...
struct  fo_plog0p
 Function object that returns p*log0(p). More...
struct  fo_divides0
 Function object similar to std::divides(), but different in that dividing by zero results in zero. More...
struct  fo_KL
 Function object useful for calculating the KL distance. More...
struct  fo_Hellinger
 Function object useful for calculating the Hellinger distance. More...
struct  fo_pow
 Function object that returns x to the power y. More...
struct  fo_max
 Function object that returns the maximum of two values. More...
struct  fo_min
 Function object that returns the minimum of two values. More...
struct  fo_absdiff
 Function object that returns the absolute difference of x and y. More...
class  TProb
 Represents a vector with entries of type T. More...
class  PropertySet
 Represents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue). More...
class  Region
 A Region is a set of variables with a counting number. More...
class  FRegion
 An FRegion is a factor with a counting number. More...
class  RegionGraph
 A RegionGraph combines a bipartite graph consisting of outer regions (type FRegion) and inner regions (type Region) with a FactorGraph. More...
class  SmallSet
 Represents a set; the implementation is optimized for a small number of elements. More...
class  TreeEP
 Approximate inference algorithm "Tree Expectation Propagation" [MiQ04]. More...
class  TRWBP
 Approximate inference algorithm "Tree-Reweighted Belief Propagation" [WJW03]. More...
class  hash_map
 hash_map is an alias for std::tr1::unordered_map. More...
class  Var
 Represents a discrete random variable. More...
class  VarSet
 Represents a set of variables. More...
class  DEdge
 Represents a directed edge. More...
class  UEdge
 Represents an undirected edge. More...
class  GraphEL
 Represents an undirected graph, implemented as a std::set of undirected edges. More...
class  WeightedGraph
 Represents an undirected weighted graph, with weights of type T, implemented as a std::map mapping undirected edges to weights. More...
class  RootedTree
 Represents a rooted tree, implemented as a vector of directed edges. More...

Typedefs

typedef BipartiteGraph::Neighbor Neighbor
 Convenience typedef.
typedef boost::minstd_rand _rnd_gen_type
 Type of global random number generator.
typedef DAIAlg< FactorGraph > DAIAlgFG
 Base class for inference algorithms that operate on a FactorGraph.
typedef DAIAlg< RegionGraph > DAIAlgRG
 Base class for inference algorithms that operate on a RegionGraph.
typedef TFactor< Real > Factor
 Represents a factor with values of type dai::Real.
typedef TProb< Real > Prob
 Represents a vector with entries of type dai::Real.
typedef std::string PropertyKey
 Type of the key of a Property.
typedef boost::any PropertyValue
 Type of the value of a Property.
typedef std::pair< PropertyKey,
PropertyValue > 		Property
 A Property is a pair of a key and a corresponding value.
typedef double Real
 Real number (alias for double, which could be changed to long double if necessary).
typedef GraphEL Graph

Functions

InfAlg * newInfAlg (const std::string &name, const FactorGraph &fg, const PropertySet &opts)
 Constructs a new inference algorithm.
InfAlg * newInfAlgFromString (const std::string &nameOpts, const FactorGraph &fg)
 Constructs a new inference algorithm.
InfAlg * newInfAlgFromString (const std::string &nameOpts, const FactorGraph &fg, const std::map< std::string, std::string > &aliases)
 Constructs a new inference algorithm.
std::pair< std::string,
PropertySet > 		parseNameProperties (const std::string &s)
 Extracts the name and property set from a string s in the format "name[key1=val1,key2=val2,...]" or "name".
std::pair< std::string,
PropertySet > 		parseNameProperties (const std::string &s, const std::map< std::string, std::string > &aliases)
 Extracts the name and property set from a string s in the format "name[key1=val1,key2=val2,...]" or "name", performing alias substitution.
std::map< std::string,
std::string > 		readAliasesFile (const std::string &filename)
 Reads aliases from file named filename.
size_t getFactorEntryForState (const FactorGraph &fg, size_t I, const vector< size_t > &state)
 Returns the entry of the I'th factor corresponding to a global state.
Real numericBBPTest (const InfAlg &bp, const std::vector< size_t > *state, const PropertySet &bbp_props, const BBPCostFunction &cfn, Real h)
vector< size_t > complement (vector< size_t > &xis, size_t n_states)
 Given a sorted vector of states xis and total state count n_states, return a vector of states not in xis.
Real unSoftMax (Real a, Real b)
 Computes $\frac{\exp(a)}{\exp(a)+\exp(b)}$.
Real logSumExp (Real a, Real b)
 Computes log of sum of exponents, i.e., $\log\left(\exp(a) + \exp(b)\right)$.
Real dist (const vector< Factor > &b1, const vector< Factor > &b2, size_t nv)
 Compute sum of pairwise L-infinity distances of the first nv factors in each vector.
static vector< Factor > mixBeliefs (Real p, const vector< Factor > &b, const vector< Factor > &c)
 Calculates a vector of mixtures p * b + (1-p) * c.
pair< size_t, size_t > BBPFindClampVar (const InfAlg &in_bp, bool clampingVar, const PropertySet &bbp_props, const BBPCostFunction &cfn, Real *maxVarOut)
size_t eliminationCost_MinNeighbors (const ClusterGraph &cl, size_t i)
 Calculates cost of eliminating the i 'th variable from cluster graph cl according to the "MinNeighbors" criterion.
size_t eliminationCost_MinWeight (const ClusterGraph &cl, size_t i)
 Calculates cost of eliminating the i 'th variable from cluster graph cl according to the "MinWeight" criterion.
size_t eliminationCost_MinFill (const ClusterGraph &cl, size_t i)
 Calculates cost of eliminating the i 'th variable from cluster graph cl according to the "MinFill" criterion.
size_t eliminationCost_WeightedMinFill (const ClusterGraph &cl, size_t i)
 Calculates cost of eliminating the i 'th variable from cluster graph cl according to the "WeightedMinFill" criterion.
Factor calcMarginal (const InfAlg &obj, const VarSet &vs, bool reInit)
 Calculates the marginal probability distribution for vs using inference algorithm obj.
vector< Factor > calcPairBeliefs (const InfAlg &obj, const VarSet &vs, bool reInit, bool accurate=false)
 Calculates beliefs for all pairs of variables in vs using inference algorithm obj.
std::vector< Factor > calcPairBeliefsNew (const InfAlg &obj, const VarSet &vs, bool reInit)
Factor calcMarginal2ndO (const InfAlg &obj, const VarSet &vs, bool reInit)
Factor createFactorIsing (const Var &x, Real h)
 Returns a binary single-variable factor $ \exp(hx) $ where $ x = \pm 1 $.
Factor createFactorIsing (const Var &x1, const Var &x2, Real J)
 Returns a binary pairwise factor $ \exp(J x_1 x_2) $ where $ x_1, x_2 = \pm 1 $.
Factor createFactorExpGauss (const VarSet &vs, Real beta)
 Returns a random factor on the variables vs with strength beta.
Factor createFactorPotts (const Var &x1, const Var &x2, Real J)
 Returns a pairwise Potts factor $ \exp( J \delta_{x_1, x_2} ) $.
Factor createFactorDelta (const Var &v, size_t state)
 Returns a Kronecker delta point mass.
std::ostream & operator<< (std::ostream &os, const FactorGraph &fg)
 Writes a FactorGraph to an output stream.
std::istream & operator>> (std::istream &is, FactorGraph &fg)
 Reads a FactorGraph from an input stream.
std::vector< size_t > getGibbsState (const FactorGraph &fg, size_t iters)
GraphAL createGraphFull (size_t N)
 Creates a fully-connected graph with N nodes.
GraphAL createGraphGrid (size_t n1, size_t n2, bool periodic)
 Creates a two-dimensional rectangular grid of n1 by n2 nodes, which can be periodic.
GraphAL createGraphGrid3D (size_t n1, size_t n2, size_t n3, bool periodic)
 Creates a three-dimensional rectangular grid of n1 by n2 by n3 nodes, which can be periodic.
GraphAL createGraphLoop (size_t N)
 Creates a graph consisting of a single loop of N nodes.
GraphAL createGraphTree (size_t N)
 Creates a random tree-structured graph of N nodes.
GraphAL createGraphRegular (size_t N, size_t d)
 Creates a random regular graph of N nodes with uniform connectivity d.
template<class T>
TFactor< T > & makePositive (TFactor< T > &f, T epsilon)
 Sets factor entries that lie between 0 and epsilon to epsilon.
template<class T>
TFactor< T > & makeZero (TFactor< T > &f, T epsilon)
 Sets factor entries that are smaller (in absolute value) than epsilon to 0.
std::pair< size_t, double > boundTreewidth (const FactorGraph &fg, greedyVariableElimination::eliminationCostFunction fn)
std::ostream & operator<< (std::ostream &os, const Property &p)
 Writes a Property object (key-value pair) to an output stream.
std::ostream & operator<< (std::ostream &os, const PropertySet &ps)
 Writes a PropertySet object to an output stream.
std::istream & operator>> (std::istream &is, PropertySet &ps)
 Reads a PropertySet object from an input stream, storing values as strings.
ostream & operator<< (ostream &os, const RegionGraph &rg)
 Send RegionGraph to output stream.
Real max (const std::vector< Real > &v)
 Returns maximum value of a std::vector<Real>.
double toc ()
 Returns wall clock time in seconds.
_rnd_gen_type _rnd_gen (42U)
 Global random number generator.
boost::uniform_real< Real > _uni_dist (0, 1)
 Uniform distribution with values between 0 and 1 (0 inclusive, 1 exclusive).
boost::variate_generator
< _rnd_gen_type
&, boost::uniform_real< Real > > 		_uni_rnd (_rnd_gen, _uni_dist)
 Global uniform random random number.
boost::variate_generator
< _rnd_gen_type
&, boost::normal_distribution
< Real > > 		_normal_rnd (_rnd_gen, _normal_dist)
 Global random number generator with standard normal distribution.
void rnd_seed (size_t seed)
 Sets the random seed.
Real rnd_uniform ()
 Returns a real number, distributed uniformly on [0,1).
Real rnd_stdnormal ()
 Returns a real number from a standard-normal distribution.
int rnd_int (int min, int max)
 Returns a random integer in interval [min, max].
void tokenizeString (const std::string &s, std::vector< std::string > &outTokens, const std::string &delim="\t\n")
 Split a string into tokens delimited by one of the characters in delim.
size_t calcLinearState (const VarSet &vs, const std::map< Var, size_t > &state)
 Calculates the linear index in the Cartesian product of the variables in vs that corresponds to a particular joint assignment of the variables, specified by state.
std::map< Var, size_t > calcState (const VarSet &vs, size_t linearState)
 Calculates the joint assignment of the variables in vs corresponding to the linear index linearState.
GraphEL RandomDRegularGraph (size_t N, size_t d)
 Constructs a random undirected graph of N nodes, where each node has connectivity d.
mxArray * Factors2mx (const std::vector< Factor > &Ps)
 Convert vector<Factor> structure to a cell vector of CPTAB-like structs.
vector< Factor > mx2Factors (const mxArray *psi, long verbose)
 Convert cell vector of CPTAB-like structs to vector<Factor>.
Factor mx2Factor (const mxArray *psi)
 Convert CPTAB-like struct to Factor.
 DAI_ENUM (BBPCostFunctionBase, CFN_GIBBS_B, CFN_GIBBS_B2, CFN_GIBBS_EXP, CFN_GIBBS_B_FACTOR, CFN_GIBBS_B2_FACTOR, CFN_GIBBS_EXP_FACTOR, CFN_VAR_ENT, CFN_FACTOR_ENT, CFN_BETHE_ENT)
 Enumeration of several cost functions that can be used with BBP.
Real log (Real x)
 Returns logarithm of x.
Real log0 (Real x)
 Returns logarithm of x, or 0 if x == 0.
Real exp (Real x)
 Returns exponent of x.
template<class T>
T abs (const T &t)
 Returns absolute value of t.
int rnd (int n)
 Returns a random integer in the half-open interval [0, n).
template<class T>
std::ostream & operator<< (std::ostream &os, const std::vector< T > &x)
 Writes a std::vector<> to a std::ostream.
template<class T>
std::ostream & operator<< (std::ostream &os, const std::set< T > &x)
 Writes a std::set<> to a std::ostream.
template<class T1, class T2>
std::ostream & operator<< (std::ostream &os, const std::map< T1, T2 > &x)
 Writes a std::map<> to a std::ostream.
template<class T1, class T2>
std::ostream & operator<< (std::ostream &os, const std::pair< T1, T2 > &x)
 Writes a std::pair<> to a std::ostream.
template<class T>
std::vector< T > concat (const std::vector< T > &u, const std::vector< T > &v)
 Concatenates two vectors.
template<typename T>
RootedTree MinSpanningTreePrims (const WeightedGraph< T > &G)
 Uses Prim's algorithm to construct a minimal spanning tree from the (positively) weighted graph G.
template<typename T>
RootedTree MaxSpanningTreePrims (const WeightedGraph< T > &G)
 Use Prim's algorithm to construct a maximal spanning tree from the (positively) weighted graph G.

Variables

boost::normal_distribution< Real > _normal_dist
 Normal distribution with mean 0 and standard deviation 1.
static const char * DAINames []
 Contains the names of all inference algorithms compiled into libDAI.

Detailed Description

Namespace for libDAI.

Typedef Documentation

typedef BipartiteGraph::Neighbor dai::Neighbor

Convenience typedef.

typedef boost::minstd_rand dai::_rnd_gen_type

Type of global random number generator.

typedef DAIAlg<FactorGraph> dai::DAIAlgFG

Base class for inference algorithms that operate on a FactorGraph.

typedef DAIAlg<RegionGraph> dai::DAIAlgRG

Base class for inference algorithms that operate on a RegionGraph.

typedef TFactor<Real> dai::Factor

Represents a factor with values of type dai::Real.

typedef TProb<Real> dai::Prob

Represents a vector with entries of type dai::Real.

typedef std::string dai::PropertyKey

Type of the key of a Property.

typedef boost::any dai::PropertyValue

Type of the value of a Property.

typedef std::pair<PropertyKey, PropertyValue> dai::Property

A Property is a pair of a key and a corresponding value.

typedef double dai::Real

Real number (alias for double, which could be changed to long double if necessary).

Examples:
example.cpp, example_sprinkler.cpp, and example_sprinkler_em.cpp.

typedef GraphEL dai::Graph

Deprecated:
Please use dai::GraphEL instead.

Function Documentation

InfAlg * dai::newInfAlg ( const std::string &  name,
const FactorGraph &  fg,
const PropertySet &  opts 
)

Constructs a new inference algorithm.

Parameters:
name The name of the inference algorithm (should be one of the names in DAINames).
fg The FactorGraph that the algorithm should be applied to.
opts A PropertySet specifying the options for the algorithm.
Returns:
Returns a pointer to the new InfAlg object; it is the responsibility of the caller to delete it later.
Exceptions:
UNKNOWN_DAI_ALGORITHM if the requested name is not known/compiled in.

InfAlg * dai::newInfAlgFromString ( const std::string &  nameOpts,
const FactorGraph &  fg 
)

Constructs a new inference algorithm.

Parameters:
nameOpts The name and options of the inference algorithm (should be in the format "name[key1=val1,key2=val2,...,keyn=valn]").
fg The FactorGraph that the algorithm should be applied to.
Returns:
Returns a pointer to the new InfAlg object; it is the responsibility of the caller to delete it later.
Exceptions:
UNKNOWN_DAI_ALGORITHM if the requested name is not known/compiled in.

InfAlg * dai::newInfAlgFromString ( const std::string &  nameOpts,
const FactorGraph &  fg,
const std::map< std::string, std::string > &  aliases 
)

Constructs a new inference algorithm.

Parameters:
aliases Maps names to strings in the format "name[key1=val1,key2=val2,...,keyn=valn]"; if not empty, alias substitution will be performed when parsing nameOpts by invoking parseNameProperties(const std::string &,const std::map<std::string,std::string> &)
See also:
newInfAlgFromString(const std::string &, const FactorGraph &)

std::pair< std::string, PropertySet > dai::parseNameProperties ( const std::string &  s  ) 

Extracts the name and property set from a string s in the format "name[key1=val1,key2=val2,...]" or "name".

std::pair< std::string, PropertySet > dai::parseNameProperties ( const std::string &  s,
const std::map< std::string, std::string > &  aliases 
)

Extracts the name and property set from a string s in the format "name[key1=val1,key2=val2,...]" or "name", performing alias substitution.

Alias substitution is performed as follows: as long as name appears as a key in aliases, it is substituted by its value. Properties in s override those of the alias (in case of recursion, the "outer" properties override those of the "inner" aliases).

std::map< std::string, std::string > dai::readAliasesFile ( const std::string &  filename  ) 

Reads aliases from file named filename.

Parameters:
filename Name of the alias file
Returns:
A map that maps aliases to the strings they should be substituted with.
See also:
Aliases file format

size_t dai::getFactorEntryForState ( const FactorGraph &  fg,
size_t  I,
const vector< size_t > &  state 
)

Returns the entry of the I'th factor corresponding to a global state.

vector<size_t> dai::complement ( vector< size_t > &  xis,
size_t  n_states 
)

Given a sorted vector of states xis and total state count n_states, return a vector of states not in xis.

Real dai::unSoftMax ( Real  a,
Real  b 
)

Computes $\frac{\exp(a)}{\exp(a)+\exp(b)}$.

Real dai::logSumExp ( Real  a,
Real  b 
)

Computes log of sum of exponents, i.e., $\log\left(\exp(a) + \exp(b)\right)$.

Real dai::dist ( const vector< Factor > &  b1,
const vector< Factor > &  b2,
size_t  nv 
)

Compute sum of pairwise L-infinity distances of the first nv factors in each vector.

static vector<Factor> dai::mixBeliefs ( Real  p,
const vector< Factor > &  b,
const vector< Factor > &  c 
) [static]

Calculates a vector of mixtures p * b + (1-p) * c.

size_t dai::eliminationCost_MinNeighbors ( const ClusterGraph &  cl,
size_t  i 
)

Calculates cost of eliminating the i 'th variable from cluster graph cl according to the "MinNeighbors" criterion.

The cost is measured as "number of neigboring nodes in the current adjacency graph", where the adjacency graph has the variables as its nodes and connects nodes i1 and i2 iff i1 and i2 occur together in some common cluster.

size_t dai::eliminationCost_MinWeight ( const ClusterGraph &  cl,
size_t  i 
)

Calculates cost of eliminating the i 'th variable from cluster graph cl according to the "MinWeight" criterion.

The cost is measured as "product of weights of neighboring nodes in the current adjacency graph", where the adjacency graph has the variables as its nodes and connects nodes i1 and i2 iff i1 and i2 occur together in some common cluster. The weight of a node is the number of states of the corresponding variable.

size_t dai::eliminationCost_MinFill ( const ClusterGraph &  cl,
size_t  i 
)

Calculates cost of eliminating the i 'th variable from cluster graph cl according to the "MinFill" criterion.

The cost is measured as "number of added edges in the adjacency graph", where the adjacency graph has the variables as its nodes and connects nodes i1 and i2 iff i1 and i2 occur together in some common cluster.

size_t dai::eliminationCost_WeightedMinFill ( const ClusterGraph &  cl,
size_t  i 
)

Calculates cost of eliminating the i 'th variable from cluster graph cl according to the "WeightedMinFill" criterion.

The cost is measured as "total weight of added edges in the adjacency graph", where the adjacency graph has the variables as its nodes and connects nodes i1 and i2 iff i1 and i2 occur together in some common cluster. The weight of an edge is the product of the number of states of the variables corresponding with its nodes.

Factor dai::calcMarginal ( const InfAlg &  obj,
const VarSet &  vs,
bool  reInit 
)

Calculates the marginal probability distribution for vs using inference algorithm obj.

calcMarginal() works by clamping all variables in vs and calculating the partition sum for each clamped state. Therefore, it can be used in combination with any inference algorithm that can calculate/approximate partition sums.

Parameters:
obj instance of inference algorithm to be used
vs variables for which the marginal should be calculated
reInit should be set to true if at least one of the possible clamped states would be invalid (leading to a factor graph with zero partition sum).

std::vector< Factor > dai::calcPairBeliefs ( const InfAlg &  obj,
const VarSet &  vs,
bool  reInit,
bool  accurate = false 
)

Calculates beliefs for all pairs of variables in vs using inference algorithm obj.

calcPairBeliefs() works by

  • clamping single variables in vs and calculating the partition sum and the single variable beliefs for each clamped state, if accurate == false;
  • clamping pairs of variables in vs and calculating the partition sum for each clamped state, if accurate == true.

Therefore, it can be used in combination with any inference algorithm that can calculate/approximate partition sums (and single variable beliefs, if accurate == true).

Parameters:
obj instance of inference algorithm to be used
vs variables for which the pair beliefs should be calculated
reInit should be set to true if at least one of the possible clamped states would be invalid (leading to a factor graph with zero partition sum).
accurate if true, uses a slower but more accurate approximation algorithm

Factor dai::createFactorIsing ( const Var &  x,
Real  h 
)

Returns a binary single-variable factor $ \exp(hx) $ where $ x = \pm 1 $.

Parameters:
x Variable (should be binary)
h Field strength

Factor dai::createFactorIsing ( const Var &  x1,
const Var &  x2,
Real  J 
)

Returns a binary pairwise factor $ \exp(J x_1 x_2) $ where $ x_1, x_2 = \pm 1 $.

Parameters:
x1 First variable (should be binary)
x2 Second variable (should be binary)
J Coupling strength

Factor dai::createFactorExpGauss ( const VarSet &  vs,
Real  beta 
)

Returns a random factor on the variables vs with strength beta.

Each entry are set by drawing a normally distributed random with mean 0 and standard-deviation beta, and taking its exponent.

Parameters:
vs Variables
beta Factor strength (inverse temperature)

Factor dai::createFactorPotts ( const Var &  x1,
const Var &  x2,
Real  J 
)

Returns a pairwise Potts factor $ \exp( J \delta_{x_1, x_2} ) $.

Parameters:
x1 First variable
x2 Second variable (should have the same number of states as x1)
J Factor strength

Factor dai::createFactorDelta ( const Var &  v,
size_t  state 
)

Returns a Kronecker delta point mass.

Parameters:
v Variable
state The state of v that should get value 1

std::ostream& dai::operator<< ( std::ostream &  os,
const FactorGraph &  fg 
)

Writes a FactorGraph to an output stream.

Writes a factor graph to an output stream.

See also:
Factor graph (.fg) file format

std::istream& dai::operator>> ( std::istream &  is,
FactorGraph &  fg 
)

Reads a FactorGraph from an input stream.

Reads a factor graph from an input stream.

See also:
Factor graph (.fg) file format
Exceptions:
INVALID_FACTORGRAPH_FILE if the input stream is not valid

GraphAL dai::createGraphFull ( size_t  N  ) 

Creates a fully-connected graph with N nodes.

GraphAL dai::createGraphGrid ( size_t  n1,
size_t  n2,
bool  periodic 
)

Creates a two-dimensional rectangular grid of n1 by n2 nodes, which can be periodic.

GraphAL dai::createGraphGrid3D ( size_t  n1,
size_t  n2,
size_t  n3,
bool  periodic 
)

Creates a three-dimensional rectangular grid of n1 by n2 by n3 nodes, which can be periodic.

GraphAL dai::createGraphLoop ( size_t  N  ) 

Creates a graph consisting of a single loop of N nodes.

GraphAL dai::createGraphTree ( size_t  N  ) 

Creates a random tree-structured graph of N nodes.

GraphAL dai::createGraphRegular ( size_t  N,
size_t  d 
)

Creates a random regular graph of N nodes with uniform connectivity d.

template<class T>
TFactor<T>& dai::makePositive ( TFactor< T > &  f,
T  epsilon 
) [inline]

Sets factor entries that lie between 0 and epsilon to epsilon.

template<class T>
TFactor<T>& dai::makeZero ( TFactor< T > &  f,
T  epsilon 
) [inline]

Sets factor entries that are smaller (in absolute value) than epsilon to 0.

std::ostream & dai::operator<< ( std::ostream &  os,
const Property &  p 
)

Writes a Property object (key-value pair) to an output stream.

std::ostream& dai::operator<< ( std::ostream &  os,
const PropertySet &  ps 
)

Writes a PropertySet object to an output stream.

It uses the format "[key1=val1,key2=val2,...,keyn=valn]".

Note:
Only a subset of all possible types is supported (see the implementation of this function). Adding support for more types has to be done by hand.
Exceptions:
UNKNOWN_PROPERTY_TYPE if the type of a property value is not supported.

std::istream& dai::operator>> ( std::istream &  is,
PropertySet &  ps 
)

Reads a PropertySet object from an input stream, storing values as strings.

Reads a PropertySet object from an input stream.

It expects a string in the format "[key1=val1,key2=val2,...,keyn=valn]". Values are stored as strings.

Exceptions:
MALFORMED_PROPERTY if the string is not in the expected format

ostream& dai::operator<< ( ostream &  os,
const RegionGraph &  rg 
)

Send RegionGraph to output stream.

Real dai::max ( const std::vector< Real > &  v  ) 

Returns maximum value of a std::vector<Real>.

double dai::toc (  ) 

Returns wall clock time in seconds.

_rnd_gen_type dai::_rnd_gen ( 42U   ) 

Global random number generator.

boost::uniform_real<Real> dai::_uni_dist ( 0  ,
1   
)

Uniform distribution with values between 0 and 1 (0 inclusive, 1 exclusive).

boost::variate_generator<_rnd_gen_type&, boost::uniform_real<Real> > dai::_uni_rnd ( _rnd_gen  ,
_uni_dist   
)

Global uniform random random number.

boost::variate_generator<_rnd_gen_type&, boost::normal_distribution<Real> > dai::_normal_rnd ( _rnd_gen  ,
_normal_dist   
)

Global random number generator with standard normal distribution.

void dai::rnd_seed ( size_t  seed  ) 

Sets the random seed.

Real dai::rnd_uniform (  ) 

Returns a real number, distributed uniformly on [0,1).

Real dai::rnd_stdnormal (  ) 

Returns a real number from a standard-normal distribution.

int dai::rnd_int ( int  min,
int  max 
)

Returns a random integer in interval [min, max].

void dai::tokenizeString ( const std::string &  s,
std::vector< std::string > &  outTokens,
const std::string &  delim 
)

Split a string into tokens delimited by one of the characters in delim.

size_t dai::calcLinearState ( const VarSet &  vs,
const std::map< Var, size_t > &  state 
)

Calculates the linear index in the Cartesian product of the variables in vs that corresponds to a particular joint assignment of the variables, specified by state.

Parameters:
vs Set of variables for which the linear state should be calculated;
state Specifies the states of some variables.
Returns:
The linear index in the Cartesian product of the variables in vs corresponding with the joint assignment specified by state, where variables for which no state is specified are assumed to be in state 0.
The linear index is calculated as follows. The variables in vs are ordered according to their label (in ascending order); say vs corresponds with the set $\{x_{l(0)},x_{l(1)},\dots,x_{l(n-1)}\}$ with $l(0) < l(1) < \dots < l(n-1)$, where variable $x_l$ has label l. Denote by $S_l$ the number of possible values ("states") of variable $x_l$. The argument state corresponds with a mapping s that assigns to each variable $x_l$ a state $s(x_l) \in \{0,1,\dots,S_l-1\}$, where $s(x_l)=0$ if $x_l$ is not specified in state. The linear index $S$ corresponding with state is now calculated by:

\begin{eqnarray*} S &:=& \sum_{i=0}^{n-1} s(x_{l(i)}) \prod_{j=0}^{i-1} S_{l(j)} \\ &= & s(x_{l(0)}) + s(x_{l(1)}) S_{l(0)} + s(x_{l(2)}) S_{l(0)} S_{l(1)} + \dots + s(x_{l(n-1)}) S_{l(0)} \cdots S_{l(n-2)}. \end{eqnarray*}

Note:
If vs corresponds with $\{x_l\}_{l\in L}$, and state specifies a state for each variable $x_l$ for $l\in L$, calcLinearState() induces a mapping $\sigma : \prod_{l\in L} X_l \to \{0,1,\dots,\prod_{l\in L} S_l-1\}$ that maps a joint state to a linear index; this is the inverse of the mapping $\sigma^{-1}$ induced by calcState().
See also:
calcState()

std::map< Var, size_t > dai::calcState ( const VarSet &  vs,
size_t  linearState 
)

Calculates the joint assignment of the variables in vs corresponding to the linear index linearState.

Parameters:
vs Set of variables to which linearState refers
linearState should be smaller than vs.nrStates().
Returns:
A mapping $s$ that maps each Var $x_l$ in vs to its state $s(x_l)$, as specified by linearState.
The variables in vs are ordered according to their label (in ascending order); say vs corresponds with the set $\{x_{l(0)},x_{l(1)},\dots,x_{l(n-1)}\}$ with $l(0) < l(1) < \dots < l(n-1)$, where variable $x_l$ has label l. Denote by $S_l$ the number of possible values ("states") of variable $x_l$ with label l. The mapping $s$ returned by this function is defined as:

\begin{eqnarray*} s(x_{l(i)}) = \left\lfloor\frac{S \mbox { mod } \prod_{j=0}^{i} S_{l(j)}}{\prod_{j=0}^{i-1} S_{l(j)}}\right\rfloor \qquad \mbox{for all $i=0,\dots,n-1$}. \end{eqnarray*}

where $S$ denotes the value of linearState.

Note:
If vs corresponds with $\{x_l\}_{l\in L}$, calcState() induces a mapping $\sigma^{-1} : \{0,1,\dots,\prod_{l\in L} S_l-1\} \to \prod_{l\in L} X_l$ that maps a linear index to a joint state; this is the inverse of the mapping $\sigma$ induced by calcLinearState().
See also:
calcLinearState()

GraphEL dai::RandomDRegularGraph ( size_t  N,
size_t  d 
)

Constructs a random undirected graph of N nodes, where each node has connectivity d.

Algorithm 1 in [StW99]. Draws a random graph of size N and uniform degree d from an almost uniform probability distribution over these graphs (which becomes uniform in the limit that d is small and N goes to infinity).

mxArray * dai::Factors2mx ( const vector< Factor > &  Ps  ) 

Convert vector<Factor> structure to a cell vector of CPTAB-like structs.

std::vector< Factor > dai::mx2Factors ( const mxArray *  psi,
long  verbose 
)

Convert cell vector of CPTAB-like structs to vector<Factor>.

Factor dai::mx2Factor ( const mxArray *  psi  ) 

Convert CPTAB-like struct to Factor.

dai::DAI_ENUM ( BBPCostFunctionBase  ,
CFN_GIBBS_B  ,
CFN_GIBBS_B2  ,
CFN_GIBBS_EXP  ,
CFN_GIBBS_B_FACTOR  ,
CFN_GIBBS_B2_FACTOR  ,
CFN_GIBBS_EXP_FACTOR  ,
CFN_VAR_ENT  ,
CFN_FACTOR_ENT  ,
CFN_BETHE_ENT   
)

Enumeration of several cost functions that can be used with BBP.

Note:
This class is meant as a base class for BBPCostFunction, which provides additional functionality.

Real dai::log ( Real  x  )  [inline]

Returns logarithm of x.

Real dai::log0 ( Real  x  )  [inline]

Returns logarithm of x, or 0 if x == 0.

Real dai::exp ( Real  x  )  [inline]

Returns exponent of x.

template<class T>
T dai::abs ( const T &  t  )  [inline]

Returns absolute value of t.

int dai::rnd ( int  n  )  [inline]

Returns a random integer in the half-open interval [0, n).

template<class T>
std::ostream& dai::operator<< ( std::ostream &  os,
const std::vector< T > &  x 
) [inline]

Writes a std::vector<> to a std::ostream.

template<class T>
std::ostream& dai::operator<< ( std::ostream &  os,
const std::set< T > &  x 
) [inline]

Writes a std::set<> to a std::ostream.

template<class T1, class T2>
std::ostream& dai::operator<< ( std::ostream &  os,
const std::map< T1, T2 > &  x 
) [inline]

Writes a std::map<> to a std::ostream.

template<class T1, class T2>
std::ostream& dai::operator<< ( std::ostream &  os,
const std::pair< T1, T2 > &  x 
) [inline]

Writes a std::pair<> to a std::ostream.

template<class T>
std::vector<T> dai::concat ( const std::vector< T > &  u,
const std::vector< T > &  v 
) [inline]

Concatenates two vectors.

template<typename T>
RootedTree dai::MinSpanningTreePrims ( const WeightedGraph< T > &  G  )  [inline]

Uses Prim's algorithm to construct a minimal spanning tree from the (positively) weighted graph G.

Uses implementation in Boost Graph Library.

template<typename T>
RootedTree dai::MaxSpanningTreePrims ( const WeightedGraph< T > &  G  )  [inline]

Use Prim's algorithm to construct a maximal spanning tree from the (positively) weighted graph G.

Uses implementation in Boost Graph Library.

Variable Documentation

boost::normal_distribution<Real> dai::_normal_dist

Normal distribution with mean 0 and standard deviation 1.

const char* dai::DAINames[] [static]

Contains the names of all inference algorithms compiled into libDAI.

Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/namespacemembers_type.html0000644000263000017630000000537611334764771020454 0ustar jorismkyb libDAI: Class Members
 

  • _rnd_gen_type : dai
  • DAIAlgFG : dai
  • DAIAlgRG : dai
  • Factor : dai
  • Graph : dai
  • Neighbor : dai
  • Prob : dai
  • Property : dai
  • PropertyKey : dai
  • PropertyValue : dai
  • Real : dai
Generated on Thu Feb 11 12:26:08 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/globals.html0000644000263000017630000000530211334764771015514 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented file members with links to the documentation:

Generated on Thu Feb 11 12:26:08 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_0x76.html0000644000263000017630000001466511334764771016701 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- v -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/bipgraph_8h-source.html0000644000263000017630000013703111334764771017567 0ustar jorismkyb libDAI: include/dai/bipgraph.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_139.png0000644000263000017630000000037511334764771015255 0ustar jorismkybPNG  IHDR#  0PLTEppp```PPP@@@000 4tRNS@f{IDATc`87 `\3$fN B@D0 j?KA쁸@5lVCH)D$4bKAhb`\9sLnJ^IENDB`libDAI-0.2.4/doc/html/classdai_1_1GraphEL.html0000644000263000017630000001206111334764771017517 0ustar jorismkyb libDAI: dai::GraphEL Class Reference

dai::GraphEL Class Reference

Represents an undirected graph, implemented as a std::set of undirected edges. More...

#include <dai/weightedgraph.h>

List of all members.

Public Member Functions

 GraphEL ()
 Default constructor.
template<class InputIterator>
 GraphEL (InputIterator begin, InputIterator end)
 Construct from range of objects that can be cast to DEdge.

Detailed Description

Represents an undirected graph, implemented as a std::set of undirected edges.

Constructor & Destructor Documentation

dai::GraphEL::GraphEL (  )  [inline]

Default constructor.

template<class InputIterator>
dai::GraphEL::GraphEL ( InputIterator  begin,
InputIterator  end 
) [inline]

Construct from range of objects that can be cast to DEdge.

The documentation for this class was generated from the following file:
Generated on Thu Feb 11 12:26:08 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/emalg_8h.html0000644000263000017630000001226011334764771015556 0ustar jorismkyb libDAI: include/dai/emalg.h File Reference

include/dai/emalg.h File Reference

Defines classes related to Expectation Maximization (EMAlg, ParameterEstimation, CondProbEstimation and SharedParameters). More...

#include <vector>
#include <map>
#include <dai/factor.h>
#include <dai/daialg.h>
#include <dai/evidence.h>
#include <dai/index.h>
#include <dai/properties.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::ParameterEstimation
 Base class for parameter estimation methods. More...
class  dai::CondProbEstimation
 Estimates the parameters of a conditional probability table, using pseudocounts. More...
class  dai::SharedParameters
 Represents a single factor or set of factors whose parameters should be estimated. More...
class  dai::MaximizationStep
 A MaximizationStep groups together several parameter estimation tasks (SharedParameters objects) into a single unit. More...
class  dai::EMAlg
 EMAlg performs Expectation Maximization to learn factor parameters. More...

Detailed Description

Defines classes related to Expectation Maximization (EMAlg, ParameterEstimation, CondProbEstimation and SharedParameters).

Todo:
Implement parameter estimation for undirected models / factor graphs.
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_52.png0000644000263000017630000000045711334764771015170 0ustar jorismkybPNG  IHDR+ i0PLTEppp```PPP@@@000 4tRNS@fIDATc` )BO0 "o3A![at^Ǡ  :}ga<$ngaH``+V`fp(3/]1:\AA}C6ɦ a l!f d${hTQ' _h#TIENDB`libDAI-0.2.4/doc/html/structdai_1_1fo__log.html0000644000263000017630000000710511334764771020063 0ustar jorismkyb libDAI: dai::fo_log< T > Struct Template Reference

dai::fo_log< T > Struct Template Reference

Function object that takes the logarithm. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &x) const
 Returns log(x).

Detailed Description

template<typename T>
struct dai::fo_log< T >

Function object that takes the logarithm.

Member Function Documentation

template<typename T>
T dai::fo_log< T >::operator() ( const T &  x  )  const [inline]

Returns log(x).

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/ideas.html0000644000263000017630000001650011334764771015160 0ustar jorismkyb libDAI: Ideas worth exploring

Ideas worth exploring

Class dai::BipartiteGraph
Cache second-order neighborhoods in BipartiteGraph.

Member dai::CBP::runRecurse (InfAlg *bp, Real orig_logZ, std::vector< size_t > clamped_vars_list, size_t &num_leaves, size_t &choose_count, Real &sum_level, Real &lz_out, std::vector< Factor > &beliefs_out)
dai::CBP::runRecurse() could be implemented more efficiently with a nesting version of backupFactors/restoreFactors

Class dai::DAIAlg< GRM >
A DAIAlg should not inherit from a FactorGraph or RegionGraph, but should store a reference to the graphical model object. This prevents needless copying of (possibly large) data structures. Disadvantage: the caller must not change the graphical model between calls to the inference algorithm (maybe a smart_ptr or some locking mechanism would help here?).

Class dai::FactorGraph
Alternative implementation of undo factor changes: the only things that have to be undone currently are setting a factor to 1 and setting a factor to a Kronecker delta. This could also be implemented in the TFactor itself, which could maintain its state (ones/delta/full) and act accordingly. Update: it seems that the proposed functionality would not be enough for CBP, for which it would make more sense to add more levels of backup/restore.

Class dai::IndexFor
Optimize all indices as follows: keep a cache of all (or only relatively small) indices that have been computed (use a hash). Then, instead of computing on the fly, use the precomputed ones. Here the labels of the variables don't matter, but the ranges of the variables do.

Class dai::InfAlg
General marginalization functions like calcMarginal() now copy a complete InfAlg object. Instead, it would make more sense that they construct a new object without copying the FactorGraph or RegionGraph. Or they can simply be made methods of the general InfAlg class.

Class dai::InfAlg
Use a PropertySet as output of an InfAlg, instead of functions like maxDiff() and Iterations().

Class dai::State
Make the State class a more prominent part of libDAI (and document it clearly, explaining the concept of state); add more optimized variants of the State class like IndexFor (e.g. for TFactor<>::slice()).

File bp_dual.h
BP_dual replicates a large part of the functionality of BP; would it not be more efficient to adapt BP instead?

File doc.h
Adapt (part of the) guidelines in http://www.boost.org/development/requirements.html#Design_and_Programming

File doc.h
Use "gcc -MM" to generate dependencies for targets: http://make.paulandlesley.org/autodep.html

File doc.h
Disentangle structures. In particular, ensure that graphical properties are not entangled with probabilistic properties. For example, a FactorGraph contains several components:
  • a BipartiteGraph
  • an array of variable labels
  • an array of variable state space sizes
  • an array of pointers to factor value vectors In this way, each factor could be implemented differently, e.g., we could have some sparse factors, some noisy-OR factors, some dense factors, some arbitrary precision factors, etcetera.

File doc.h
Use boost::uBLAS framework to deal with matrices, especially, with 2D sparse matrices. See http://www.boost.org/libs/numeric/ublas/doc/matrix_sparse.htm However: I read somewhere that boost::uBLAS concentrates more on correct implementation than on performance.

File doc.h
Introduce naming scheme:
  • all Vars should be named v_..., e.g. v_i instead of i
  • all VarSets should be named vs_..., e.g. v_i instead of i
  • all Factors should be named f_..., e.g. f_I instead of I
  • all indices should be named _..., e.g. _k instead of k
  • all iterators should be named i_, e.g. i_i is an iterator to i
  • all const_iterators should be named ci_, e.g. ci_i is an iterator to i

File hak.h
Implement more general region graphs and corresponding Generalized Belief Propagation updates as described in [YFW05].
Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1greedyVariableElimination-members.html0000644000263000017630000000554011334764771025007 0ustar jorismkyb libDAI: Member List

dai::greedyVariableElimination Member List

This is the complete list of members for dai::greedyVariableElimination, including all inherited members.

eliminationCostFunction typedefdai::greedyVariableElimination
greedyVariableElimination(eliminationCostFunction h)dai::greedyVariableElimination [inline]
heuristicdai::greedyVariableElimination [private]
operator()(const ClusterGraph &cl, const std::set< size_t > &remainingVars)dai::greedyVariableElimination

Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1CondProbEstimation.html0000644000263000017630000004252111334764771022004 0ustar jorismkyb libDAI: dai::CondProbEstimation Class Reference

dai::CondProbEstimation Class Reference

Estimates the parameters of a conditional probability table, using pseudocounts. More...

#include <dai/emalg.h>

Inheritance diagram for dai::CondProbEstimation:

dai::ParameterEstimation

List of all members.

Public Member Functions

 CondProbEstimation (size_t target_dimension, const Prob &pseudocounts)
 Constructor.
virtual ParameterEstimation * clone () const
 Virtual copy constructor.
virtual ~CondProbEstimation ()
 Virtual destructor.
virtual Prob estimate ()
 Returns an estimate of the conditional probability distribution.
virtual void addSufficientStatistics (const Prob &p)
 Accumulate sufficient statistics from the expectations in p.
virtual size_t probSize () const
 Returns the required size for arguments to addSufficientStatistics().

Static Public Member Functions

static ParameterEstimation * factory (const PropertySet &p)
 Virtual constructor, using a PropertySet.

Private Attributes

size_t _target_dim
 Number of states of the variable of interest.
Prob _stats
 Current pseudocounts.
Prob _initial_stats
 Initial pseudocounts.

Detailed Description

Estimates the parameters of a conditional probability table, using pseudocounts.

Author:
Charles Vaske

Constructor & Destructor Documentation

dai::CondProbEstimation::CondProbEstimation ( size_t  target_dimension,
const Prob &  pseudocounts 
)

Constructor.

For a conditional probability $ P( X | Y ) $,

Parameters:
target_dimension should equal $ | X | $
pseudocounts are the initial pseudocounts, of length $ |X| \cdot |Y| $

virtual dai::CondProbEstimation::~CondProbEstimation (  )  [inline, virtual]

Virtual destructor.

Member Function Documentation

ParameterEstimation * dai::CondProbEstimation::factory ( const PropertySet &  p  )  [static]

Virtual constructor, using a PropertySet.

Some keys in the PropertySet are required. For a conditional probability $ P( X | Y ) $,

  • target_dimension should be equal to $ | X | $
  • total_dimension should be equal to $ |X| \cdot |Y| $

An optional key is:

  • pseudo_count which specifies the initial counts (defaults to 1)

virtual ParameterEstimation* dai::CondProbEstimation::clone (  )  const [inline, virtual]

Virtual copy constructor.

Implements dai::ParameterEstimation.

Prob dai::CondProbEstimation::estimate (  )  [virtual]

Returns an estimate of the conditional probability distribution.

The format of the resulting Prob keeps all the values for $ P(X | Y=y) $ in sequential order in the array.

Implements dai::ParameterEstimation.

void dai::CondProbEstimation::addSufficientStatistics ( const Prob &  p  )  [virtual]

Accumulate sufficient statistics from the expectations in p.

Implements dai::ParameterEstimation.

virtual size_t dai::CondProbEstimation::probSize (  )  const [inline, virtual]

Returns the required size for arguments to addSufficientStatistics().

Implements dai::ParameterEstimation.

Member Data Documentation

size_t dai::CondProbEstimation::_target_dim [private]

Number of states of the variable of interest.

Prob dai::CondProbEstimation::_stats [private]

Current pseudocounts.

Prob dai::CondProbEstimation::_initial_stats [private]

Initial pseudocounts.

The documentation for this class was generated from the following files:
Generated on Thu Feb 11 12:26:03 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_vars_0x73.html0000644000263000017630000001011611334764771017714 0ustar jorismkyb libDAI: Class Members - Variables
 

- s -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/inline_dotgraph_2.dot.png0000644000263000017630000000101711334764771020064 0ustar jorismkybPNG  IHDRD`VɡPLTE???___.NtRNS@fIDATH՗Kn L=@e=IlܶmE؎nA'MYAB 04"<}9i=G&HNIE ;0uR5.Ms T! BHRo܅5G vDZ' L㘍ǂ0݄M*JZ|NG5TEln+d/êq['y4./Xf#m IM +GlyR ^fт_VpG+7]RK1 Muc#1#U!BHS6-bD:  2!#Xrڡ)ƒ̱(61zg ba s#u'8*u2GEDE"C{JւErEk9}>L{| {=[IENDB`libDAI-0.2.4/doc/html/structdai_1_1JTree_1_1Properties-members.html0000644000263000017630000000662311334764771023641 0ustar jorismkyb libDAI: Member List

dai::JTree::Properties Member List

This is the complete list of members for dai::JTree::Properties, including all inherited members.

DAI_ENUM(UpdateType, HUGIN, SHSH)dai::JTree::Properties
DAI_ENUM(InfType, SUMPROD, MAXPROD)dai::JTree::Properties
DAI_ENUM(HeuristicType, MINNEIGHBORS, MINWEIGHT, MINFILL, WEIGHTEDMINFILL)dai::JTree::Properties
heuristicdai::JTree::Properties
inferencedai::JTree::Properties
updatesdai::JTree::Properties
verbosedai::JTree::Properties

Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1fo__log0-members.html0000644000263000017630000000356611334764771021602 0ustar jorismkyb libDAI: Member List

dai::fo_log0< T > Member List

This is the complete list of members for dai::fo_log0< T >, including all inherited members.

operator()(const T &x) const dai::fo_log0< T > [inline]

Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/util_8h.html0000644000263000017630000004121611334764771015451 0ustar jorismkyb libDAI: include/dai/util.h File Reference

include/dai/util.h File Reference

Defines general utility functions and adds an abstraction layer for platform-dependent functionality. More...

#include <string>
#include <vector>
#include <set>
#include <map>
#include <iostream>
#include <boost/foreach.hpp>
#include <boost/functional/hash.hpp>
#include <algorithm>
#include <tr1/unordered_map>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::hash_map< T, U, H >
 hash_map is an alias for std::tr1::unordered_map. More...

Defines

#define foreach   BOOST_FOREACH
 An alias to the BOOST_FOREACH macro from the boost::foreach library.
#define DAI_PV(x)   do {std::cerr << #x "= " << (x) << std::endl;} while(0)
 "Print variable". Prints the text of an expression, followed by its value (only if DAI_DEBUG is defined)
#define DAI_DMSG(str)   do {std::cerr << str << std::endl;} while(0)
 "Debugging message": Prints a message (only if DAI_DEBUG is defined)
#define DAI_IFVERB(n, stmt)   if(props.verbose>=n) { std::cerr << stmt; }
 Macro to write message stmt to std::cerr if props.verbose >= n.

Typedefs

typedef double dai::Real
 Real number (alias for double, which could be changed to long double if necessary).

Functions

Real dai::log (Real x)
 Returns logarithm of x.
Real dai::log0 (Real x)
 Returns logarithm of x, or 0 if x == 0.
Real dai::exp (Real x)
 Returns exponent of x.
Real dai::max (const std::vector< Real > &v)
 Returns maximum value of a std::vector<Real>.
double dai::toc ()
 Returns wall clock time in seconds.
template<class T>
T dai::abs (const T &t)
 Returns absolute value of t.
void dai::rnd_seed (size_t seed)
 Sets the random seed.
Real dai::rnd_uniform ()
 Returns a real number, distributed uniformly on [0,1).
Real dai::rnd_stdnormal ()
 Returns a real number from a standard-normal distribution.
int dai::rnd_int (int min, int max)
 Returns a random integer in interval [min, max].
int dai::rnd (int n)
 Returns a random integer in the half-open interval [0, n).
template<class T>
std::ostream & dai::operator<< (std::ostream &os, const std::vector< T > &x)
 Writes a std::vector<> to a std::ostream.
template<class T>
std::ostream & dai::operator<< (std::ostream &os, const std::set< T > &x)
 Writes a std::set<> to a std::ostream.
template<class T1, class T2>
std::ostream & dai::operator<< (std::ostream &os, const std::map< T1, T2 > &x)
 Writes a std::map<> to a std::ostream.
template<class T1, class T2>
std::ostream & dai::operator<< (std::ostream &os, const std::pair< T1, T2 > &x)
 Writes a std::pair<> to a std::ostream.
template<class T>
std::vector< T > dai::concat (const std::vector< T > &u, const std::vector< T > &v)
 Concatenates two vectors.
void dai::tokenizeString (const std::string &s, std::vector< std::string > &outTokens, const std::string &delim="\t\n")
 Split a string into tokens delimited by one of the characters in delim.

Detailed Description

Defines general utility functions and adds an abstraction layer for platform-dependent functionality.

Define Documentation

#define foreach   BOOST_FOREACH

An alias to the BOOST_FOREACH macro from the boost::foreach library.

#define DAI_PV ( x   )     do {std::cerr << #x "= " << (x) << std::endl;} while(0)

"Print variable". Prints the text of an expression, followed by its value (only if DAI_DEBUG is defined)

Useful debugging macro to see what your code is doing. Example: 

 DAI_PV(3+4)
Output: 
 3+4= 7

#define DAI_DMSG ( str   )     do {std::cerr << str << std::endl;} while(0)

"Debugging message": Prints a message (only if DAI_DEBUG is defined)

#define DAI_IFVERB ( n,
stmt   )     if(props.verbose>=n) { std::cerr << stmt; }

Macro to write message stmt to std::cerr if props.verbose >= n.

Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_func_0x76.html0000644000263000017630000001212711334764771017703 0ustar jorismkyb libDAI: Class Members - Functions
 

- v -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_121.png0000644000263000017630000000112311334764771015234 0ustar jorismkybPNG  IHDRj"0PLTEppp```PPP@@@000 4tRNS@fIDAT8K#AƟDf؈;!rhXzwPD-\B!-,9iZ]Ga#lbS>3w>~#> :Y{UjqQuwnٛR#eVUR?j(R8`Z8td%Q=%*cLqh~t8/tNfPJ,ǂ U41=p%/M4UlŬT=>ciX~.dJʃ5.mC6TV3qFe[b)HE <1< ]:l3T?%HOK)286N G9S}?vVzM?b;Em| z.4efրs W:8_U6MpgO6pBOh! 8MIN@OF* C ,m)'Y chvkzajF]:IENDB`libDAI-0.2.4/doc/html/classdai_1_1WeightedGraph.html0000644000263000017630000000474111334764771020765 0ustar jorismkyb libDAI: dai::WeightedGraph< T > Class Template Reference

dai::WeightedGraph< T > Class Template Reference

Represents an undirected weighted graph, with weights of type T, implemented as a std::map mapping undirected edges to weights. More...

#include <dai/weightedgraph.h>

Detailed Description

template<class T>
class dai::WeightedGraph< T >

Represents an undirected weighted graph, with weights of type T, implemented as a std::map mapping undirected edges to weights.
The documentation for this class was generated from the following file:
Generated on Thu Feb 11 12:26:08 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_0x6a.html0000644000263000017630000001007511334764771016742 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- j -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_13.png0000644000263000017630000000035011334764771015155 0ustar jorismkybPNG  IHDR0PLTEppp```PPP@@@000 4tRNS@ffIDATc`@^QB()yq lQXa@bB%6b Wjօ 2\ $c@unBpBINfXIENDB`libDAI-0.2.4/doc/html/form_21.png0000644000263000017630000000027711334764771015164 0ustar jorismkybPNG  IHDR Ol0PLTEppp```PPP@@@000 4tRNS@f=IDATc`@ 3?-H3>ЇIuύ4U` 2za7f*  @$IENDB`libDAI-0.2.4/doc/html/form_28.png0000644000263000017630000000124611334764771015170 0ustar jorismkybPNG  IHDRv"x00PLTEppp```PPP@@@000 4tRNS@f$IDAT8ݔk`ǿi6 B́a頊*UD0 ܰ;,20(c(ې<ð'x런qu'oV*24+i!$_ȓ7|}yM|őeڒ$mTXhӰ67x ;Sa;rۮ`tG~XAC*4pg[ci, Z?^C%bOe;*"^&Q@D$U#}2)+o4juy!WU԰ ؿ0~ \O;{ڀ3IPj]w_l+S谒ob9Tb#&Ah_=jPQ#9+mL2YDT7ö/T)_2J.䵧/uBuf9P]olBƊ 8;ݵqwbxbk:M;,HzИqQ24d?5A?=ǣ]3_$Л#H'GN_^AH;㟴p~Wր77Jtztxq(f}Q3}lwgMIENDB`libDAI-0.2.4/doc/html/classdai_1_1ParameterEstimation-members.html0000644000263000017630000001074011334764771023644 0ustar jorismkyb libDAI: Member List

dai::ParameterEstimation Member List

This is the complete list of members for dai::ParameterEstimation, including all inherited members.

_registrydai::ParameterEstimation [private, static]
addSufficientStatistics(const Prob &p)=0dai::ParameterEstimation [pure virtual]
clone() const =0dai::ParameterEstimation [pure virtual]
construct(const std::string &method, const PropertySet &p)dai::ParameterEstimation [static]
estimate()=0dai::ParameterEstimation [pure virtual]
loadDefaultRegistry()dai::ParameterEstimation [private, static]
ParamEstFactory typedefdai::ParameterEstimation
probSize() const =0dai::ParameterEstimation [pure virtual]
registerMethod(const std::string &method, const ParamEstFactory &f)dai::ParameterEstimation [inline, static]
~ParameterEstimation()dai::ParameterEstimation [inline, virtual]

Generated on Thu Feb 11 12:26:03 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_vars_0x71.html0000644000263000017630000000751311334764771017721 0ustar jorismkyb libDAI: Class Members - Variables
 

- q -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1FBP.html0000644000263000017630000007004711334764771016654 0ustar jorismkyb libDAI: dai::FBP Class Reference

dai::FBP Class Reference

Approximate inference algorithm "Fractional Belief Propagation" [WiH03]. More...

#include <dai/fbp.h>

Inheritance diagram for dai::FBP:

dai::BP dai::DAIAlg< GRM > dai::InfAlg

List of all members.

FBP accessors/mutators for weights

Real Weight (size_t I) const
 Returns weight of the I 'th factor.
const std::vector< Real > & Weights () const
 Returns constant reference to vector of all factor weights.
void setWeight (size_t I, Real c)
 Sets the weight of the I 'th factor to c.
void setWeights (const std::vector< Real > &c)
 Sets the weights of all factors simultaenously.
virtual Prob calcIncomingMessageProduct (size_t I, bool without_i, size_t i) const
 Calculate the product of factor I and the incoming messages.
virtual void calcNewMessage (size_t i, size_t _I)
 Calculate the updated message from the _I 'th neighbor of variable i to variable i.
virtual void calcBeliefF (size_t I, Prob &p) const
 Calculates unnormalized belief of factor I.
virtual void construct ()
 Helper function for constructors.

Public Member Functions

Constructors/destructors
 FBP ()
 Default constructor.
 FBP (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts.
General InfAlg interface
virtual FBP * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
virtual std::string identify () const
 Identifies itself for logging purposes.
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Static Public Attributes

static const char * Name = "FBP"
 Name of this inference algorithm.

Protected Attributes

std::vector< Real > _weight
 Factor weights (indexed by factor ID).

Detailed Description

Approximate inference algorithm "Fractional Belief Propagation" [WiH03].

The Fractional Belief Propagation algorithm is like Belief Propagation, but associates each factor with a weight (scale parameter) which controls the divergence measure being minimized. Standard Belief Propagation corresponds to the case of FBP where each weight is 1. When cast as an EP algorithm, BP (and EP) minimize the inclusive KL-divergence, i.e. $\min_q KL(p||q)$ (note that the Bethe free energy is typically derived from $ KL(q||p) $). If each factor I has weight $ c_I $, then FBP minimizes the alpha-divergence with $ \alpha=1/c_I $ for that factor, which also corresponds to Power EP [Min05].

The messages $m_{I\to i}(x_i)$ are passed from factors $I$ to variables $i$. The update equation is given by:

\[ m_{I\to i}(x_i) \propto \left( \sum_{x_{N_I\setminus\{i\}}} f_I(x_I)^{1/c_I} \prod_{j\in N_I\setminus\{i\}} m_{I\to j}^{1-1/c_I} \prod_{J\in N_j\setminus\{I\}} m_{J\to j} \right)^{c_I} \]

After convergence, the variable beliefs are calculated by:

\[ b_i(x_i) \propto \prod_{I\in N_i} m_{I\to i} \]

and the factor beliefs are calculated by:

\[ b_I(x_I) \propto f_I(x_I)^{1/c_I} \prod_{j \in N_I} m_{I\to j}^{1-1/c_I} \prod_{J\in N_j\setminus\{I\}} m_{J\to j} \]

The logarithm of the partition sum is approximated by:

\[ \log Z = \sum_{I} \sum_{x_I} b_I(x_I) \big( \log f_I(x_I) - c_I \log b_I(x_I) \big) + \sum_{i} (c_i - 1) \sum_{x_i} b_i(x_i) \log b_i(x_i) \]

where the variable weights are defined as

\[ c_i := \sum_{I \in N_i} c_I \]

Todo:
Add nice way to set weights
Author:
Frederik Eaton

Constructor & Destructor Documentation

dai::FBP::FBP (  )  [inline]

Default constructor.

dai::FBP::FBP ( const FactorGraph &  fg,
const PropertySet &  opts 
) [inline]

Construct from FactorGraph fg and PropertySet opts.

Parameters:
opts Parameters
See also:
BP::Properties

Member Function Documentation

virtual FBP* dai::FBP::clone (  )  const [inline, virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Reimplemented from dai::BP.

string dai::FBP::identify (  )  const [virtual]

Identifies itself for logging purposes.

Reimplemented from dai::BP.

Real dai::FBP::logZ (  )  const [virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::BP.

Real dai::FBP::Weight ( size_t  I  )  const [inline]

Returns weight of the I 'th factor.

const std::vector<Real>& dai::FBP::Weights (  )  const [inline]

Returns constant reference to vector of all factor weights.

void dai::FBP::setWeight ( size_t  I,
Real  c 
) [inline]

Sets the weight of the I 'th factor to c.

void dai::FBP::setWeights ( const std::vector< Real > &  c  )  [inline]

Sets the weights of all factors simultaenously.

Note:
Faster than calling setWeight(size_t,Real) for each factor

Prob dai::FBP::calcIncomingMessageProduct ( size_t  I,
bool  without_i,
size_t  i 
) const [protected, virtual]

Calculate the product of factor I and the incoming messages.

If without_i == true, the message coming from variable i is omitted from the product

Note:
This function is used by calcNewMessage() and calcBeliefF()

Reimplemented from dai::BP.

void dai::FBP::calcNewMessage ( size_t  i,
size_t  _I 
) [protected, virtual]

Calculate the updated message from the _I 'th neighbor of variable i to variable i.

Reimplemented from dai::BP.

virtual void dai::FBP::calcBeliefF ( size_t  I,
Prob &  p 
) const [inline, protected, virtual]

Calculates unnormalized belief of factor I.

Reimplemented from dai::BP.

void dai::FBP::construct (  )  [protected, virtual]

Helper function for constructors.

Reimplemented from dai::BP.

Member Data Documentation

std::vector<Real> dai::FBP::_weight [protected]

Factor weights (indexed by factor ID).

const char * dai::FBP::Name = "FBP" [static]

Name of this inference algorithm.

Reimplemented from dai::BP.

The documentation for this class was generated from the following files:
  • include/dai/fbp.h
  • src/fbp.cpp
Generated on Thu Feb 11 12:26:04 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1LC.png0000644000263000017630000000103211334764771016347 0ustar jorismkybPNG  IHDR<)PLTE`{tRNS@fIDAThAr0 P :텺G(66JBC>mx]iE @L"j1. HH|,Ȝl|rJX zIspT΁I4@]دNzv 6ƫ~~P?LOndwp<7^Ef5 W- kLyK^MtQ`"9`BI1ExOHhݙށk@PR2 3@`9,򎌌CERKa1uLbl`5&Hzzf., xF3ul`3,6_<7:8z8}:y#;f05ws Y|_B'0u8{L"N<?zֿIENDB`libDAI-0.2.4/doc/html/form_50.png0000644000263000017630000000031311334764771015155 0ustar jorismkybPNG  IHDR Rio0PLTEppp```PPP@@@000 4tRNS@fIIDATc`,)`f #!0 $d|H+t03_@6n -)P׮ 1ihIENDB`libDAI-0.2.4/doc/html/tab_r.gif0000644000263000017630000000503111334764771014760 0ustar jorismkybGIF89a,薴ŝɯͻ,,@pH,Ȥrl:ШtJZجv h d@L"F:򑐌$9 (8&Nz (GFB^!˨)WVl)1 w̥.wY0Ib|Hpf:e pJ}Ȧ6nz 80%"8v~ @JЂMBІ:D'ZPKF ּ&16юz HGJRb L5Җ0LgJӚ#(e>Ӟ@ PJԢHMRԦ:PTJժ&5;%Uծz` XJVCjYֶp\Uxͫ^׾i)$Mb:v, ಘͬf7z hGKҚMjWֺ*$SPͭnwm +Mr:E?9Zͮv9" xKbLz^A|ͯ0/LN(; n0'LaJ0{/{ؘG|(SCr. v1wc6@LdHNd/PLeOXp|+s2L_153M5t3_:wsgʹπp?/FFЎt!-JҖ1NӞuA-Pԝ>53UWծ4cYZѶsA׀5,aƶ3=e3~-3Sc6mo2Mq>7ӭn$D~7,y1m}v\/N3#S\gu-mO0C\'_S^|.c.0ל49~s=3d:u)?F;ˮW|;W)vt˽w|=xA;libDAI-0.2.4/doc/html/functions_vars_0x75.html0000644000263000017630000001051111334764771017715 0ustar jorismkyb libDAI: Class Members - Variables
 

- u -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/example__permute_8cpp-example.html0000644000263000017630000002647711334764771022027 0ustar jorismkyb libDAI: example_permute.cpp

example_permute.cpp

This example shows how to use the Permute, multifor and State classes.

Output

V = (x1, x2, x0)
X = {x0, x1, x2}
Note that the ordering of the variables in X is the canonical ordering
(ascendingly according to their labels) but the ordering in V is different.

The permutation between both variable orderings is sigma = (2, 0, 1), or more verbosely:
  sigma[0] = 2
  sigma[1] = 0
  sigma[2] = 1
This means that variable V[sigma[n]] should correspond with the n'th variable in X (for n=0,...,2)...OK. 

The states of the variables x0,x1,x2 are, according to the ordering in V:
SV:  x0:  x1:  x2:
 0    0    0    0
 1    0    1    0
 2    0    2    0
 3    0    0    1
 4    0    1    1
 5    0    2    1
 6    1    0    0
 7    1    1    0
 8    1    2    0
 9    1    0    1
10    1    1    1
11    1    2    1

The states of the variables x0,x1,x2 are, according to the canonical ordering in X:
SX:  x0:  x1:  x2:
 0    0    0    0
 1    1    0    0
 2    0    1    0
 3    1    1    0
 4    0    2    0
 5    1    2    0
 6    0    0    1
 7    1    0    1
 8    0    1    1
 9    1    1    1
10    0    2    1
11    1    2    1

The permutation sigma induces the following permutation of linear indices of joint states:
SV:  SX:
 0    0
 1    2
 2    4
 3    6
 4    8
 5   10
 6    1
 7    3
 8    5
 9    7
10    9
11   11

Source

/*  This file is part of libDAI - http://www.libdai.org/
 *
 *  libDAI is licensed under the terms of the GNU General Public License version
 *  2, or (at your option) any later version. libDAI is distributed without any
 *  warranty. See the file COPYING for more details.
 *
 *  Copyright (C) 2008-2009  Joris Mooij  [joris dot mooij at libdai dot org]
 */


#include <dai/varset.h>
#include <dai/index.h>
#include <iostream>
#include <iomanip>

using namespace std;
using namespace dai;

int main() {
    Var x0(0, 2);   // Define binary  variable x0 (with label 0)
    Var x1(1, 3);   // Define ternary variable x1 (with label 1)
    Var x2(2, 2);   // Define binary  variable x2 (with label 2)

    // Define vector V = (x1, x2, x0)
    vector<Var> V;      // Define a vector of variables
    V.push_back( x1 );  // V[0] = x1;
    V.push_back( x2 );  // V[1] = x2;
    V.push_back( x0 );  // V[2] = x0;
    cout << "V = " << V << endl; // Note that the elements of X are not necessarily ordered according to their labels

    // Define set X = {x0, x1, x2}
    VarSet X; // empty
    X |= x2;  // X = {x2}
    X |= x0;  // X = {x0, x2}
    X |= x1;  // X = {x0, x1, x2}
    cout << "X = " << X << endl; // Note that the elements of X are ordered according to their labels

    cout << "Note that the ordering of the variables in X is the canonical ordering" << endl;
    cout << "(ascendingly according to their labels) but the ordering in V is different." << endl << endl;

    // N = number of variables in V (and X)
    size_t N = V.size();

    // Define a Permute object based on the variables in V
    Permute sigma(V);
    // Each Var in V corresponds with a dimension in a multi-dimensional array.
    // The permutation sigma permutes these dimensions from the canonical ordering
    // (sorted ascendingly on the label of the variable, i.e., the same ordering as
    // in X) into the ordering these variables have in V.
    cout << "The permutation between both variable orderings is sigma = " << sigma.sigma() << ", or more verbosely:" << endl;
    for( size_t n = 0; n < N; n++ )
        cout << "  sigma[" << n << "] = " << sigma[n] << endl;
    cout << "This means that variable V[sigma[n]] should correspond with the n'th variable in X (for n=0,...," << (N-1) << ")...";
    // Check whether the permutation works as advertised
    VarSet::const_iterator X_n = X.begin();
    for( size_t n = 0; n < N; n++, X_n++ )
        DAI_ASSERT( V[sigma[n]] == *X_n );
    cout << "OK. " << endl << endl;

    // Iterate over the joint states of the variables, according to the ordering in V
    cout << "The states of the variables x0,x1,x2 are, according to the ordering in V:" << endl;
    cout << "SV:  x0:  x1:  x2:" << endl;
    std::vector<size_t> ranges;
    for( size_t i = 0; i < V.size(); i++ )
        ranges.push_back( V[i].states() );
    for( multifor SV(ranges); SV.valid(); ++SV )
        cout << setw(2) << (size_t)SV << "    " << SV[sigma[0]] << "    " << SV[sigma[1]] << "    " << SV[sigma[2]] << endl;
    cout << endl;

    // Iterate over the joint states of the variables, according to the canonical ordering in X
    cout << "The states of the variables x0,x1,x2 are, according to the canonical ordering in X:" << endl;
    cout << "SX:  x0:  x1:  x2:" << endl;
    for( State SX(X); SX.valid(); SX++ )
        cout << setw(2) << SX << "    " << SX(x0) << "    " << SX(x1) << "    " << SX(x2) << endl;
    cout << endl;

    // The main functionality of the Permute object is to calculate the induced permutation of linear indices of joint states
    cout << "The permutation sigma induces the following permutation of linear indices of joint states:" << endl;
    cout << "SV:  SX:" << endl;
    for( size_t li = 0; li < X.nrStates(); li++ )
        cout << setw(2) << li << "   " << setw(2) << sigma.convertLinearIndex( li ) << endl;

    return 0;
}
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_func_0x6a.html0000644000263000017630000001015411334764771017753 0ustar jorismkyb libDAI: Class Members - Functions
 

- j -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_69.png0000644000263000017630000000054711334764771015200 0ustar jorismkybPNG  IHDR00PLTEppp```PPP@@@000 4tRNS@fIDATc` `H3TL``=c!3D  dBR X~oa`OĐtd%/P3M101Lcg+n  ?0%>u%n%.3>```ΐh'[|vtgx'uV}) p` 4*%pϱ}p8K,V b;5!idfIENDB`libDAI-0.2.4/doc/html/globals_defs.html0000644000263000017630000000517211334764771016522 0ustar jorismkyb libDAI: Class Members
 

Generated on Thu Feb 11 12:26:08 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1sequentialVariableElimination.html0000644000263000017630000002002611334764771024246 0ustar jorismkyb libDAI: dai::sequentialVariableElimination Class Reference

dai::sequentialVariableElimination Class Reference

Helper object for dai::ClusterGraph::VarElim(). More...

#include <dai/clustergraph.h>

List of all members.

Public Member Functions

 sequentialVariableElimination (const std::vector< Var > s)
 Construct from vector of variables.
size_t operator() (const ClusterGraph &cl, const std::set< size_t > &)
 Returns next variable in sequence.

Private Attributes

std::vector< Var > seq
 The variable elimination sequence.
size_t i
 Counter.

Detailed Description

Helper object for dai::ClusterGraph::VarElim().

Chooses the next variable to eliminate by picking them sequentially from a given vector of variables.

Constructor & Destructor Documentation

dai::sequentialVariableElimination::sequentialVariableElimination ( const std::vector< Var >  s  )  [inline]

Construct from vector of variables.

Member Function Documentation

size_t dai::sequentialVariableElimination::operator() ( const ClusterGraph &  cl,
const std::set< size_t > &   
)

Returns next variable in sequence.

Member Data Documentation

std::vector<Var> dai::sequentialVariableElimination::seq [private]

The variable elimination sequence.

size_t dai::sequentialVariableElimination::i [private]

Counter.

The documentation for this class was generated from the following files:
Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_func_0x69.html0000644000263000017630000002652311334764771017712 0ustar jorismkyb libDAI: Class Members - Functions
 

- i -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/inline_dotgraph_4.dot.png0000644000263000017630000000113311334764771020065 0ustar jorismkybPNG  IHDR9v%PLTE???___.NtRNS@fIDATXMN0 F9@#p9 Żs[69mM%2/髛:N.|W:JC[44Tl # ^MJb1;Sg A D!̤2e . .|]¤󖈾1"$3b|G yy-y7i&eG晅VWy/xMOΫci]!^IuT1c>앿{j XTZțLC8^Hל9=CEDȻK;l; `IENDB`libDAI-0.2.4/doc/html/util_8h-source.html0000644000263000017630000004705211334764771016753 0ustar jorismkyb libDAI: include/dai/util.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_0x63.html0000644000263000017630000003560511334764771016672 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- c -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_87.png0000644000263000017630000000064011334764771015172 0ustar jorismkybPNG  IHDRK)0PLTEppp```PPP@@@000 4tRNS@fIDAT(c` bv@2 ("+`6"b T17 ؚ Da@`RPy رH 'B  G5soBR\8 e]3gN# Z~*c&V aWg`HrIq3,aV`^e\О q 1U2O!3(ĸد ڸ .5 00#`13i07ec!́a*(`cL9Qb@4AIENDB`libDAI-0.2.4/doc/html/form_1.png0000644000263000017630000000120011334764771015065 0ustar jorismkybPNG  IHDR{0PLTEppp```PPP@@@000 4tRNS@fIDAT(OhPǿY (KKHs(; aE`AM<-v٢^{II< <;y4 e\{^^8NңnjFʢNAϢE=À2dtR$Ⅸb=h`02@98S@ϰ3LJf w4C)2`#6E{(nݾktPHxV.p}|śX y|\MR;IJs(MT#j8(m.5E2ë4 /%FvLA9q+/h1l2o$XۿOB6I4og߶>.'/ |[[Wq8; libDAI: include/dai/treeep.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_71.png0000644000263000017630000000067311334764771015171 0ustar jorismkybPNG  IHDRD]"`0PLTEppp```PPP@@@000 4tRNS@f9IDAT(c` Thl"XdSbT1WsGDMf60bR2 V(.o,7f3xmdPsRl >pl*`C;C=Bh.v30`RAh͋Jb y@%7JY?xJ1)L)aΐh'[40XT2#;v[df:3:N/@%Wۜ  Z$t%.`H4¹A }bX (01C 4@EmIENDB`libDAI-0.2.4/doc/html/structdai_1_1BBP_1_1Properties-members.html0000644000263000017630000000744011334764771023231 0ustar jorismkyb libDAI: Member List

dai::BBP::Properties Member List

This is the complete list of members for dai::BBP::Properties, including all inherited members.

DAI_ENUM(UpdateType, SEQ_FIX, SEQ_MAX, SEQ_BP_REV, SEQ_BP_FWD, PAR)dai::BBP::Properties
dampingdai::BBP::Properties
get() const dai::BBP::Properties
maxiterdai::BBP::Properties
set(const PropertySet &opts)dai::BBP::Properties
toldai::BBP::Properties
toString() const dai::BBP::Properties
updatesdai::BBP::Properties
verbosedai::BBP::Properties

Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1multifor.html0000644000263000017630000003525311334764771020106 0ustar jorismkyb libDAI: dai::multifor Class Reference

dai::multifor Class Reference

multifor makes it easy to perform a dynamic number of nested for loops. More...

#include <dai/index.h>

List of all members.

Public Member Functions

 multifor ()
 Default constructor.
 multifor (const std::vector< size_t > &d)
 Initialize from vector of index ranges.
 operator size_t () const
 Returns linear index (i.e., the index in the Cartesian product space).
size_t operator[] (size_t k) const
 Returns k 'th index.
multifor & operator++ ()
 Increments the current indices (prefix).
void operator++ (int)
 Increments the current indices (postfix).
bool valid () const
 Returns true if the current indices are valid.

Private Attributes

std::vector< size_t > _ranges
 Stores the number of possible values of all indices.
std::vector< size_t > _indices
 Stores the current values of all indices.
long _linear_index
 Stores the current linear index.

Detailed Description

multifor makes it easy to perform a dynamic number of nested for loops.

An example of the usage is as follows: 

  std::vector<size_t> ranges;
  ranges.push_back( 3 );
  ranges.push_back( 4 );
  ranges.push_back( 5 );
  for( multifor s(ranges); s.valid(); ++s )
      cout << "linear index: " << (size_t)s << " corresponds to indices " << s[2] << ", " << s[1] << ", " << s[0] << endl;
which would be equivalent to: 
  size_t s = 0;
  for( size_t s2 = 0; s2 < 5; s2++ )
      for( size_t s1 = 0; s1 < 4; s1++ )
          for( size_t s0 = 0; s0 < 3; s++, s0++ )
              cout << "linear index: " << (size_t)s << " corresponds to indices " << s2 << ", " << s1 << ", " << s0 << endl;
Examples:

example_permute.cpp.

Constructor & Destructor Documentation

dai::multifor::multifor (  )  [inline]

Default constructor.

dai::multifor::multifor ( const std::vector< size_t > &  d  )  [inline]

Initialize from vector of index ranges.

Member Function Documentation

dai::multifor::operator size_t (  )  const [inline]

Returns linear index (i.e., the index in the Cartesian product space).

size_t dai::multifor::operator[] ( size_t  k  )  const [inline]

Returns k 'th index.

multifor& dai::multifor::operator++ (  )  [inline]

Increments the current indices (prefix).

void dai::multifor::operator++ ( int   )  [inline]

Increments the current indices (postfix).

bool dai::multifor::valid (  )  const [inline]

Returns true if the current indices are valid.

Member Data Documentation

std::vector<size_t> dai::multifor::_ranges [private]

Stores the number of possible values of all indices.

std::vector<size_t> dai::multifor::_indices [private]

Stores the current values of all indices.

long dai::multifor::_linear_index [private]

Stores the current linear index.

The documentation for this class was generated from the following file:
Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1BipartiteGraph_1_1Neighbor.html0000644000263000017630000003774311334764771023515 0ustar jorismkyb libDAI: dai::BipartiteGraph::Neighbor Struct Reference

dai::BipartiteGraph::Neighbor Struct Reference

Describes the neighbor relationship of two nodes in a BipartiteGraph. More...

#include <dai/bipgraph.h>

List of all members.

Public Member Functions

 Neighbor ()
 Default constructor.
 Neighbor (size_t iter, size_t node, size_t dual)
 Constructor that sets the Neighbor members according to the parameters.
 operator size_t () const
 Cast to size_t returns node member.

Public Attributes

size_t iter
 Corresponds to the index of this Neighbor entry in the vector of neighbors.
size_t node
 Contains the number of the neighboring node.
size_t dual
 Contains the "dual" iter.

Detailed Description

Describes the neighbor relationship of two nodes in a BipartiteGraph.

Sometimes we want to do an action, such as sending a message, for all edges in a graph. However, most graphs will be sparse, so we need some way of storing a set of the neighbors of a node, which is both fast and memory-efficient. We also need to be able to go between viewing node a as a neighbor of node b, and node b as a neighbor of node a. The Neighbor struct solves both of these problems. Each node has a list of neighbors, stored as a std::vector<Neighbor>, and extra information is included in the Neighbor struct which allows us to access a node as a neighbor of its neighbor (the dual member).

By convention, variable identifiers naming indices into a vector of neighbors are prefixed with an underscore ("_"). The neighbor list which they point into is then understood from context. For example:

  void BP::calcNewMessage( size_t i, size_t _I )

Here, i is the "absolute" index of node i, but _I is understood as a "relative" index, giving node I 's entry in nb1(i). The corresponding Neighbor structure can be accessed as nb1(i,_I) or nb1(i)[_I]. The absolute index of _I, which would be called I, can be recovered from the node member: nb1(i,_I).node. The iter member gives the relative index _I, and the dual member gives the "dual" relative index, i.e., the index of i in I 's neighbor list.

  Neighbor n = nb1(i,_I);
  n.node == I &&
  n.iter == _I &&
  nb2(n.node,n.dual).node == i

In a FactorGraph, the nodes of type 1 represent variables, and the nodes of type 2 represent factors. For convenience, nb1() is called FactorGraph::nbV(), and nb2() is called FactorGraph::nbF().

There is no easy way to transform a pair of absolute node indices i and I into a Neighbor structure relative to one of the nodes. Such a feature has never yet been found to be necessary. Iteration over edges can always be accomplished using the Neighbor lists, and by writing functions that accept relative indices: 

  for( size_t i = 0; i < nrVars(); ++i )
      foreach( const Neighbor &I, nbV(i) )
          calcNewMessage( i, I.iter );
Examples:

example_bipgraph.cpp.

Constructor & Destructor Documentation

dai::BipartiteGraph::Neighbor::Neighbor (  )  [inline]

Default constructor.

dai::BipartiteGraph::Neighbor::Neighbor ( size_t  iter,
size_t  node,
size_t  dual 
) [inline]

Constructor that sets the Neighbor members according to the parameters.

Member Function Documentation

dai::BipartiteGraph::Neighbor::operator size_t (  )  const [inline]

Cast to size_t returns node member.

Member Data Documentation

size_t dai::BipartiteGraph::Neighbor::iter

Corresponds to the index of this Neighbor entry in the vector of neighbors.

Examples:
example_bipgraph.cpp.

size_t dai::BipartiteGraph::Neighbor::node

Contains the number of the neighboring node.

Examples:
example_bipgraph.cpp.

size_t dai::BipartiteGraph::Neighbor::dual

Contains the "dual" iter.

Examples:
example_bipgraph.cpp.

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1fo__inv0-members.html0000644000263000017630000000356611334764771021615 0ustar jorismkyb libDAI: Member List

dai::fo_inv0< T > Member List

This is the complete list of members for dai::fo_inv0< T >, including all inherited members.

operator()(const T &x) const dai::fo_inv0< T > [inline]

Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1Gibbs.html0000644000263000017630000015556011334764771017277 0ustar jorismkyb libDAI: dai::Gibbs Class Reference

dai::Gibbs Class Reference

Approximate inference algorithm "Gibbs sampling". More...

#include <dai/gibbs.h>

Inheritance diagram for dai::Gibbs:

dai::DAIAlg< GRM > dai::InfAlg

List of all members.

Public Member Functions

 Gibbs ()
 Default constructor.
 Gibbs (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts.
General InfAlg interface
virtual Gibbs * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
virtual std::string identify () const
 Identifies itself for logging purposes.
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable.
virtual Factor belief (const VarSet &vs) const
 Returns the (approximate) marginal probability distribution of a set of variables.
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i.
virtual Factor beliefF (size_t I) const
 Returns the (approximate) marginal probability distribution of the variables on which factor I depends.
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).
virtual void init ()
 Initializes all data structures of the approximate inference algorithm.
virtual void init (const VarSet &)
 Initializes all data structures corresponding to some set of variables.
virtual Real run ()
 Runs the approximate inference algorithm.
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration.
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph).
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm.
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet.
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".
Additional interface specific for Gibbs
void randomizeState ()
 Draw the current joint state of all variables from a uniform random distribution.
std::vector< size_t > & state ()
 Return reference to current state of all variables.
const std::vector< size_t > & state () const
 Return constant reference to current state of all variables.

Public Attributes

struct dai::Gibbs::Properties props

Static Public Attributes

static const char * Name = "GIBBS"
 Name of this inference algorithm.

Private Types

typedef std::vector< size_t > _count_t
 Type used to store the counts of various states.
typedef std::vector< size_t > _state_t
 Type used to store the joint state of all variables.

Private Member Functions

void construct ()
 Helper function for constructors.
void updateCounts ()
 Updates all counts (_sample_count, _var_counts, _factor_counts) based on current state.
Prob getVarDist (size_t i)
 Calculate conditional distribution of variable i, given the current state.
void resampleVar (size_t i)
 Draw state of variable i randomly from its conditional distribution and update the current state.
size_t getFactorEntry (size_t I)
 Calculates linear index into factor I corresponding to the current state.
size_t getFactorEntryDiff (size_t I, size_t i)
 Calculates the differences between linear indices into factor I corresponding with a state change of variable i.

Private Attributes

size_t _sample_count
 Number of samples counted so far (excluding burn-in).
std::vector< _count_t > _var_counts
 State counts for each variable.
std::vector< _count_t > _factor_counts
 State counts for each factor.
_state_t _state
 Current joint state of all variables.

Related Functions

(Note that these are not member functions.)

std::vector< size_t > getGibbsState (const FactorGraph &fg, size_t iters)
 Runs Gibbs sampling for iters iterations (of which burnin for burn-in) on FactorGraph fg, and returns the resulting state.

Classes

struct  Properties
 Parameters for Gibbs. More...

Detailed Description

Approximate inference algorithm "Gibbs sampling".

Author:
Frederik Eaton
Examples:

example_sprinkler_gibbs.cpp.

Member Typedef Documentation

typedef std::vector<size_t> dai::Gibbs::_count_t [private]

Type used to store the counts of various states.

typedef std::vector<size_t> dai::Gibbs::_state_t [private]

Type used to store the joint state of all variables.

Constructor & Destructor Documentation

dai::Gibbs::Gibbs (  )  [inline]

Default constructor.

dai::Gibbs::Gibbs ( const FactorGraph &  fg,
const PropertySet &  opts 
) [inline]

Construct from FactorGraph fg and PropertySet opts.

Parameters:
opts Parameters
See also:
Properties

Member Function Documentation

virtual Gibbs* dai::Gibbs::clone (  )  const [inline, virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Implements dai::InfAlg.

virtual std::string dai::Gibbs::identify (  )  const [inline, virtual]

Identifies itself for logging purposes.

Implements dai::InfAlg.

virtual Factor dai::Gibbs::belief ( const Var &  v  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of a variable.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

Factor dai::Gibbs::belief ( const VarSet &  vs  )  const [virtual]

Returns the (approximate) marginal probability distribution of a set of variables.

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported.
BELIEF_NOT_AVAILABLE if the requested belief cannot be calculated with this algorithm.

Implements dai::InfAlg.

Factor dai::Gibbs::beliefV ( size_t  i  )  const [virtual]

Returns the (approximate) marginal probability distribution of the variable with index i.

For some approximate inference algorithms, using beliefV() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

Factor dai::Gibbs::beliefF ( size_t  I  )  const [virtual]

Returns the (approximate) marginal probability distribution of the variables on which factor I depends.

For some approximate inference algorithms, using beliefF() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

vector< Factor > dai::Gibbs::beliefs (  )  const [virtual]

Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.

Note:
Before this method is called, run() should have been called.

Implements dai::InfAlg.

virtual Real dai::Gibbs::logZ (  )  const [inline, virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

void dai::Gibbs::init (  )  [virtual]

Initializes all data structures of the approximate inference algorithm.

Note:
This method should be called at least once before run() is called.

Implements dai::InfAlg.

virtual void dai::Gibbs::init ( const VarSet &  vs  )  [inline, virtual]

Initializes all data structures corresponding to some set of variables.

This method can be used to do a partial initialization after a part of the factor graph has changed. Instead of initializing all data structures, it only initializes those involving the variables in vs.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

Real dai::Gibbs::run (  )  [virtual]

Runs the approximate inference algorithm.

Note:
Before run() is called the first time, init() should have been called.

Implements dai::InfAlg.

Examples:
example_sprinkler_gibbs.cpp.

virtual Real dai::Gibbs::maxDiff (  )  const [inline, virtual]

Returns maximum difference between single variable beliefs in the last iteration.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

virtual size_t dai::Gibbs::Iterations (  )  const [inline, virtual]

Returns number of iterations done (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

void dai::Gibbs::setProperties ( const PropertySet &  opts  )  [virtual]

Set parameters of this inference algorithm.

The parameters are set according to the PropertySet opts. The values can be stored either as std::string or as the type of the corresponding MF::props member.

Implements dai::InfAlg.

PropertySet dai::Gibbs::getProperties (  )  const [virtual]

Returns parameters of this inference algorithm converted into a PropertySet.

Implements dai::InfAlg.

string dai::Gibbs::printProperties (  )  const [virtual]

Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Implements dai::InfAlg.

void dai::Gibbs::randomizeState (  ) 

Draw the current joint state of all variables from a uniform random distribution.

std::vector<size_t>& dai::Gibbs::state (  )  [inline]

Return reference to current state of all variables.

Examples:
example_sprinkler_gibbs.cpp.

const std::vector<size_t>& dai::Gibbs::state (  )  const [inline]

Return constant reference to current state of all variables.

void dai::Gibbs::construct (  )  [private]

Helper function for constructors.

void dai::Gibbs::updateCounts (  )  [private]

Updates all counts (_sample_count, _var_counts, _factor_counts) based on current state.

Prob dai::Gibbs::getVarDist ( size_t  i  )  [private]

Calculate conditional distribution of variable i, given the current state.

void dai::Gibbs::resampleVar ( size_t  i  )  [inline, private]

Draw state of variable i randomly from its conditional distribution and update the current state.

size_t dai::Gibbs::getFactorEntry ( size_t  I  )  [inline, private]

Calculates linear index into factor I corresponding to the current state.

size_t dai::Gibbs::getFactorEntryDiff ( size_t  I,
size_t  i 
) [inline, private]

Calculates the differences between linear indices into factor I corresponding with a state change of variable i.

Friends And Related Function Documentation

std::vector< size_t > getGibbsState ( const FactorGraph &  fg,
size_t  iters 
) [related]

Runs Gibbs sampling for iters iterations (of which burnin for burn-in) on FactorGraph fg, and returns the resulting state.

Member Data Documentation

size_t dai::Gibbs::_sample_count [private]

Number of samples counted so far (excluding burn-in).

std::vector<_count_t> dai::Gibbs::_var_counts [private]

State counts for each variable.

std::vector<_count_t> dai::Gibbs::_factor_counts [private]

State counts for each factor.

_state_t dai::Gibbs::_state [private]

Current joint state of all variables.

const char * dai::Gibbs::Name = "GIBBS" [static]

Name of this inference algorithm.

The documentation for this class was generated from the following files:
Generated on Thu Feb 11 12:26:04 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1ClusterGraph.html0000644000263000017630000010444311334764771020646 0ustar jorismkyb libDAI: dai::ClusterGraph Class Reference

dai::ClusterGraph Class Reference

A ClusterGraph is a hypergraph with variables as nodes, and "clusters" (sets of variables) as hyperedges. More...

#include <dai/clustergraph.h>

List of all members.

Public Types

typedef BipartiteGraph::Neighbor Neighbor
 Shorthand for BipartiteGraph::Neighbor.
typedef BipartiteGraph::Edge Edge
 Shorthand for BipartiteGraph::Edge.

Public Member Functions

Constructors and destructors
 ClusterGraph ()
 Default constructor.
 ClusterGraph (const std::vector< VarSet > &cls)
 Construct from vector of VarSet 's.
Queries
const std::vector< VarSet > & toVector () const
 Returns a constant reference to the clusters.
size_t size () const
 Returns number of clusters.
size_t findVar (const Var &n) const
 Returns the index of variable n.
VarSet Delta (size_t i) const
 Returns union of clusters that contain the i 'th variable.
VarSet delta (size_t i) const
 Returns union of clusters that contain the i 'th (except this variable itself).
bool adj (size_t i1, size_t i2) const
 Returns true if variables with indices i1 and i2 are adjacent, i.e., both contained in the same cluster.
bool isMaximal (size_t I) const
 Returns true if cluster I is not contained in a larger cluster.
Operations
void insert (const VarSet &cl)
 Inserts a cluster (if it does not already exist).
ClusterGraph & eraseNonMaximal ()
 Erases all clusters that are not maximal.
ClusterGraph & eraseSubsuming (size_t i)
 Erases all clusters that contain the i 'th variable.
Variable elimination
template<class EliminationChoice>
ClusterGraph VarElim (EliminationChoice f) const
 Performs Variable Elimination, only keeping track of the interactions that are created along the way.
size_t eliminationCost (size_t i) const
 Calculates cost of eliminating the i 'th variable.
ClusterGraph VarElim (const std::vector< Var > &ElimSeq) const
 Performs Variable Elimination, only keeping track of the interactions that are created along the way.
ClusterGraph VarElim_MinFill () const
 Performs Variable Elimination using the "MinFill" heuristic.

Public Attributes

BipartiteGraph G
 Stores the neighborhood structure.
std::vector< Var > vars
 Stores the variables corresponding to the nodes.
std::vector< VarSet > clusters
 Stores the clusters corresponding to the hyperedges.

Friends

Input/Ouput
std::ostream & operator<< (std::ostream &os, const ClusterGraph &cl)
 Writes a ClusterGraph to an output stream.

Detailed Description

A ClusterGraph is a hypergraph with variables as nodes, and "clusters" (sets of variables) as hyperedges.

It is implemented as a bipartite graph with variable (Var) nodes and cluster (VarSet) nodes.

Member Typedef Documentation

typedef BipartiteGraph::Neighbor dai::ClusterGraph::Neighbor

Shorthand for BipartiteGraph::Neighbor.

typedef BipartiteGraph::Edge dai::ClusterGraph::Edge

Shorthand for BipartiteGraph::Edge.

Constructor & Destructor Documentation

dai::ClusterGraph::ClusterGraph (  )  [inline]

Default constructor.

dai::ClusterGraph::ClusterGraph ( const std::vector< VarSet > &  cls  ) 

Construct from vector of VarSet 's.

Member Function Documentation

const std::vector<VarSet>& dai::ClusterGraph::toVector (  )  const [inline]

Returns a constant reference to the clusters.

size_t dai::ClusterGraph::size (  )  const [inline]

Returns number of clusters.

size_t dai::ClusterGraph::findVar ( const Var &  n  )  const [inline]

Returns the index of variable n.

VarSet dai::ClusterGraph::Delta ( size_t  i  )  const [inline]

Returns union of clusters that contain the i 'th variable.

VarSet dai::ClusterGraph::delta ( size_t  i  )  const [inline]

Returns union of clusters that contain the i 'th (except this variable itself).

bool dai::ClusterGraph::adj ( size_t  i1,
size_t  i2 
) const [inline]

Returns true if variables with indices i1 and i2 are adjacent, i.e., both contained in the same cluster.

bool dai::ClusterGraph::isMaximal ( size_t  I  )  const [inline]

Returns true if cluster I is not contained in a larger cluster.

void dai::ClusterGraph::insert ( const VarSet &  cl  )  [inline]

Inserts a cluster (if it does not already exist).

ClusterGraph& dai::ClusterGraph::eraseNonMaximal (  )  [inline]

Erases all clusters that are not maximal.

ClusterGraph& dai::ClusterGraph::eraseSubsuming ( size_t  i  )  [inline]

Erases all clusters that contain the i 'th variable.

template<class EliminationChoice>
ClusterGraph dai::ClusterGraph::VarElim ( EliminationChoice  f  )  const [inline]

Performs Variable Elimination, only keeping track of the interactions that are created along the way.

Template Parameters:
EliminationChoice should support "size_t operator()( const ClusterGraph &cl, const std::set<size_t> &remainingVars )"
Parameters:
f function object which returns the next variable index to eliminate; for example, a dai::greedyVariableElimination object.
Returns:
A set of elimination "cliques".

size_t dai::ClusterGraph::eliminationCost ( size_t  i  )  const

Calculates cost of eliminating the i 'th variable.

The cost is measured as "number of added edges in the adjacency graph", where the adjacency graph has the variables as its nodes and connects nodes i1 and i2 iff i1 and i2 occur together in some common cluster.

Deprecated:
Please use dai::eliminationCost_MinFill() instead.

ClusterGraph dai::ClusterGraph::VarElim ( const std::vector< Var > &  ElimSeq  )  const

Performs Variable Elimination, only keeping track of the interactions that are created along the way.

Parameters:
ElimSeq The sequence in which to eliminate the variables
Returns:
A set of elimination "cliques"
Deprecated:
Please use dai::ClusterGraph::VarElim( sequentialVariableElimination( ElimSeq ) ) instead.

ClusterGraph dai::ClusterGraph::VarElim_MinFill (  )  const

Performs Variable Elimination using the "MinFill" heuristic.

The "MinFill" heuristic greedily minimizes the cost of eliminating a variable, measured with eliminationCost().

Returns:
A set of elimination "cliques".
Deprecated:
Please use dai::ClusterGraph::VarElim( greedyVariableElimination( eliminationCost_MinFill ) ) instead.

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os,
const ClusterGraph &  cl 
) [friend]

Writes a ClusterGraph to an output stream.

Member Data Documentation

BipartiteGraph dai::ClusterGraph::G

Stores the neighborhood structure.

std::vector<Var> dai::ClusterGraph::vars

Stores the variables corresponding to the nodes.

std::vector<VarSet> dai::ClusterGraph::clusters

Stores the clusters corresponding to the hyperedges.

The documentation for this class was generated from the following files:
Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1BipartiteGraph-members.html0000644000263000017630000002774311334764771022607 0ustar jorismkyb libDAI: Member List

dai::BipartiteGraph Member List

This is the complete list of members for dai::BipartiteGraph, including all inherited members.

_nb1dai::BipartiteGraph [private]
_nb2dai::BipartiteGraph [private]
add1()dai::BipartiteGraph [inline]
add1(NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0)dai::BipartiteGraph [inline]
add2()dai::BipartiteGraph [inline]
add2(NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0)dai::BipartiteGraph [inline]
addEdge(size_t n1, size_t n2, bool check=true)dai::BipartiteGraph
addNode1()dai::BipartiteGraph [inline]
addNode1(NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0)dai::BipartiteGraph [inline]
addNode2()dai::BipartiteGraph [inline]
addNode2(NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0)dai::BipartiteGraph [inline]
BipartiteGraph()dai::BipartiteGraph [inline]
BipartiteGraph(size_t nrNodes1, size_t nrNodes2, EdgeInputIterator begin, EdgeInputIterator end)dai::BipartiteGraph [inline]
checkConsistency() const dai::BipartiteGraph
construct(size_t nrNodes1, size_t nrNodes2, EdgeInputIterator begin, EdgeInputIterator end)dai::BipartiteGraph [inline]
delta1(size_t n1, bool include=false) const dai::BipartiteGraph
delta2(size_t n2, bool include=false) const dai::BipartiteGraph
Edge typedefdai::BipartiteGraph
erase1(size_t n1)dai::BipartiteGraph [inline]
erase2(size_t n2)dai::BipartiteGraph [inline]
eraseEdge(size_t n1, size_t n2)dai::BipartiteGraph
eraseNode1(size_t n1)dai::BipartiteGraph
eraseNode2(size_t n2)dai::BipartiteGraph
isConnected() const dai::BipartiteGraph
isTree() const dai::BipartiteGraph
nb1(size_t i1, size_t _i2) const dai::BipartiteGraph [inline]
nb1(size_t i1, size_t _i2)dai::BipartiteGraph [inline]
nb1(size_t i1) const dai::BipartiteGraph [inline]
nb1(size_t i1)dai::BipartiteGraph [inline]
nb2(size_t i2, size_t _i1) const dai::BipartiteGraph [inline]
nb2(size_t i2, size_t _i1)dai::BipartiteGraph [inline]
nb2(size_t i2) const dai::BipartiteGraph [inline]
nb2(size_t i2)dai::BipartiteGraph [inline]
Neighbors typedefdai::BipartiteGraph
nr1() const dai::BipartiteGraph [inline]
nr2() const dai::BipartiteGraph [inline]
nrEdges() const dai::BipartiteGraph [inline]
nrNodes1() const dai::BipartiteGraph [inline]
nrNodes2() const dai::BipartiteGraph [inline]
printDot(std::ostream &os) const dai::BipartiteGraph

Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/evidence_8h.html0000644000263000017630000000473211334764771016260 0ustar jorismkyb libDAI: include/dai/evidence.h File Reference

include/dai/evidence.h File Reference

Defines class Evidence, which stores multiple observations of joint states of variables. More...

#include <istream>
#include <dai/daialg.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::Evidence
 Stores a data set consisting of multiple samples, where each sample is the observed joint state of some variables. More...

Detailed Description

Defines class Evidence, which stores multiple observations of joint states of variables.

Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_rela.html0000644000263000017630000000653611334764771017116 0ustar jorismkyb libDAI: Class Members - Related Functions
 

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_vars_0x65.html0000644000263000017630000000755411334764771017731 0ustar jorismkyb libDAI: Class Members - Variables
 

- e -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_104.png0000644000263000017630000000116311334764771015241 0ustar jorismkybPNG  IHDRr#!C0PLTEppp```PPP@@@000 4tRNS@fIDAT8ݔ?h@ǿ%//I lVpW[tV MA(:E,)ć*dQRt-|C("Yt.8t wɫ}{~rc,),G5]]300Hm*V|8 !@ Z] 2 P'uʏ@,v2lEbQ J8&0 `Yg`dX80|nʰߊ3b 0p2`!Meax52A(C$`FMjBj`*!F@ VG )GTC$0 n.Rv5r%@ , *]`ZbKDp(066`_`Ñpr.30ci \. @::P4,`, !`0A N`P V'rlLj zc$1/IENDB`libDAI-0.2.4/doc/html/classdai_1_1MaximizationStep-members.html0000644000263000017630000001134111334764771023172 0ustar jorismkyb libDAI: Member List

dai::MaximizationStep Member List

This is the complete list of members for dai::MaximizationStep, including all inherited members.

_paramsdai::MaximizationStep [private]
addExpectations(InfAlg &alg)dai::MaximizationStep
begin()dai::MaximizationStep [inline]
begin() const dai::MaximizationStep [inline]
const_iterator typedefdai::MaximizationStep
end()dai::MaximizationStep [inline]
end() const dai::MaximizationStep [inline]
iterator typedefdai::MaximizationStep
MaximizationStep()dai::MaximizationStep [inline]
MaximizationStep(std::vector< SharedParameters > &maximizations)dai::MaximizationStep [inline]
MaximizationStep(std::istream &is, const FactorGraph &fg_varlookup)dai::MaximizationStep
maximize(FactorGraph &fg)dai::MaximizationStep

Generated on Thu Feb 11 12:26:03 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/hierarchy.html0000644000263000017630000002066711334764771016062 0ustar jorismkyb libDAI: Hierarchical Index

Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/alldai_8h-source.html0000644000263000017630000004001111334764771017210 0ustar jorismkyb libDAI: include/dai/alldai.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_0x66.html0000644000263000017630000001524611334764771016674 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- f -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1Permute.html0000644000263000017630000003243711334764771017667 0ustar jorismkyb libDAI: dai::Permute Class Reference

dai::Permute Class Reference

Tool for calculating permutations of linear indices of multi-dimensional arrays. More...

#include <dai/index.h>

List of all members.

Public Member Functions

 Permute ()
 Default constructor.
 Permute (const std::vector< size_t > &rs, const std::vector< size_t > &sigma)
 Construct from vector of index ranges and permutation.
 Permute (const std::vector< Var > &vars)
 Construct from vector of variables.
size_t convertLinearIndex (size_t li) const
 Calculates a permuted linear index.
const std::vector< size_t > & sigma () const
 Returns const reference to the permutation.
std::vector< size_t > & sigma ()
 Returns reference to the permutation.
size_t operator[] (size_t i) const
 Returns the result of applying the permutation on i.

Private Attributes

std::vector< size_t > _ranges
 Stores the number of possible values of all indices.
std::vector< size_t > _sigma
 Stores the permutation.

Detailed Description

Tool for calculating permutations of linear indices of multi-dimensional arrays.

Note:
This is mainly useful for converting indices into multi-dimensional arrays corresponding to joint states of variables to and from the canonical ordering used in libDAI.
Examples:

example_permute.cpp.

Constructor & Destructor Documentation

dai::Permute::Permute (  )  [inline]

Default constructor.

dai::Permute::Permute ( const std::vector< size_t > &  rs,
const std::vector< size_t > &  sigma 
) [inline]

Construct from vector of index ranges and permutation.

dai::Permute::Permute ( const std::vector< Var > &  vars  )  [inline]

Construct from vector of variables.

The implied permutation maps the index of each variable in vars according to the canonical ordering (i.e., sorted ascendingly according to their label) to the index it has in vars.

Member Function Documentation

size_t dai::Permute::convertLinearIndex ( size_t  li  )  const [inline]

Calculates a permuted linear index.

Converts the linear index li to a vector index, permutes its components, and converts it back to a linear index.

Examples:
example_permute.cpp.

const std::vector<size_t>& dai::Permute::sigma (  )  const [inline]

Returns const reference to the permutation.

Examples:
example_permute.cpp.

std::vector<size_t>& dai::Permute::sigma (  )  [inline]

Returns reference to the permutation.

size_t dai::Permute::operator[] ( size_t  i  )  const [inline]

Returns the result of applying the permutation on i.

Member Data Documentation

std::vector<size_t> dai::Permute::_ranges [private]

Stores the number of possible values of all indices.

std::vector<size_t> dai::Permute::_sigma [private]

Stores the permutation.

The documentation for this class was generated from the following file:
Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_33.png0000644000263000017630000000100211334764771015152 0ustar jorismkybPNG  IHDRԖL0PLTEppp```PPP@@@000 4tRNS@fIDAT8c`!&^)l`l"ӈ[S;P+k{HC(13 8̽ P?4C|c GSka #TwÍ/ $y0j $T O``ZV 9s̩@n0x@6sTt$@ CaX1UC-@: W2LE$H&0g`/Z3QPPP,c n0U`aV(60_̫$r/?x @H$rjbKpS8/F1; cX2G020|A&1cg$c " ƠhE`$*\ɤT$UIENDB`libDAI-0.2.4/doc/html/structdai_1_1BP_1_1Properties-members.html0000644000263000017630000000735311334764771023132 0ustar jorismkyb libDAI: Member List

dai::BP::Properties Member List

This is the complete list of members for dai::BP::Properties, including all inherited members.

DAI_ENUM(UpdateType, SEQFIX, SEQRND, SEQMAX, PARALL)dai::BP::Properties
DAI_ENUM(InfType, SUMPROD, MAXPROD)dai::BP::Properties
dampingdai::BP::Properties
inferencedai::BP::Properties
logdomaindai::BP::Properties
maxiterdai::BP::Properties
toldai::BP::Properties
updatesdai::BP::Properties
verbosedai::BP::Properties

Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1MR_1_1Properties.html0000644000263000017630000002414311334764771021513 0ustar jorismkyb libDAI: dai::MR::Properties Struct Reference

dai::MR::Properties Struct Reference

Parameters for MR. More...

#include <dai/mr.h>

List of all members.

Public Member Functions

 DAI_ENUM (UpdateType, FULL, LINEAR)
 Enumeration of different types of update equations.
 DAI_ENUM (InitType, RESPPROP, CLAMPING, EXACT)
 Enumeration of different ways of initializing the cavity correlations.

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr).
Real tol
 Tolerance for convergence test.
UpdateType updates
 Update equations.
InitType inits
 How to initialize the cavity correlations.

Detailed Description

Parameters for MR.

Member Function Documentation

dai::MR::Properties::DAI_ENUM ( UpdateType  ,
FULL  ,
LINEAR   
)

Enumeration of different types of update equations.

The possible update equations are:

  • FULL full updates, slow but accurate
  • LINEAR linearized updates, faster but less accurate

dai::MR::Properties::DAI_ENUM ( InitType  ,
RESPPROP  ,
CLAMPING  ,
EXACT   
)

Enumeration of different ways of initializing the cavity correlations.

The possible cavity initializations are:

  • RESPPROP using response propagation ("linear response")
  • CLAMPING using clamping and BP
  • EXACT using JunctionTree

Member Data Documentation

size_t dai::MR::Properties::verbose

Verbosity (amount of output sent to stderr).

Real dai::MR::Properties::tol

Tolerance for convergence test.

UpdateType dai::MR::Properties::updates

Update equations.

InitType dai::MR::Properties::inits

How to initialize the cavity correlations.

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_0x71.html0000644000263000017630000001052111334764771016657 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- q -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_0x62.html0000644000263000017630000002465111334764771016670 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- b -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_116.png0000644000263000017630000000051511334764771015244 0ustar jorismkybPNG  IHDR#s0PLTEppp```PPP@@@000 4tRNS@fIDATc`1&0(Hp(0$20 0\@fpyphbp.$Q5* \Bl B b Bm@,ķH00)vЬ @6Vv/C | )0i l'4„.a0chw`h ]`kH +*@+fd`> HW%0uIENDB`libDAI-0.2.4/doc/html/functions_vars_0x7a.html0000644000263000017630000001020311334764771017767 0ustar jorismkyb libDAI: Class Members - Variables
 

- z -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_0x77.html0000644000263000017630000001073211334764771016671 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- w -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/bibliography.html0000644000263000017630000001521611334764771016551 0ustar jorismkyb libDAI: Bibliography

Bibliography

EaG09 F. Eaton and Z. Ghahramani (2009): "Choosing a Variable to Clamp", Proceedings of the Twelfth International Conference on Artificial Intelligence and Statistics (AISTATS 2009) 5:145-152, http://jmlr.csail.mit.edu/proceedings/papers/v5/eaton09a/eaton09a.pdf

EMK06 G. Elidan and I. McGraw and D. Koller (2006): "Residual Belief Propagation: Informed Scheduling for Asynchronous Message Passing", Proceedings of the 22nd Annual Conference on Uncertainty in Artificial Intelligence (UAI-06), http://uai.sis.pitt.edu/papers/06/UAI2006_0091.pdf

HAK03 T. Heskes and C. A. Albers and H. J. Kappen (2003): "Approximate Inference and Constrained Optimization", Proceedings of the 19th Annual Conference on Uncertainty in Artificial Intelligence (UAI-03) pp. 313-320, http://www.snn.ru.nl/reports/Heskes.uai2003.ps.gz

KFL01 F. R. Kschischang and B. J. Frey and H.-A. Loeliger (2001): "Factor Graphs and the Sum-Product Algorithm", IEEE Transactions on Information Theory 47(2):498-519, http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?arnumber=910572

KoF09 D. Koller and N. Friedman (2009): Probabilistic Graphical Models - Principles and Techniques, The MIT Press, Cambridge, Massachusetts, London, England.

Min05 T. Minka (2005): "Divergence measures and message passing", MicroSoft Research Technical Report MSR-TR-2005-173, http://research.microsoft.com/en-us/um/people/minka/papers/message-passing/minka-divergence.pdf

MiQ04 T. Minka and Y. Qi (2004): "Tree-structured Approximations by Expectation Propagation", Advances in Neural Information Processing Systems (NIPS) 16, http://books.nips.cc/papers/files/nips16/NIPS2003_AA25.pdf

MoK07 J. M. Mooij and H. J. Kappen (2007): "Loop Corrections for Approximate Inference on Factor Graphs", Journal of Machine Learning Research 8:1113-1143, http://www.jmlr.org/papers/volume8/mooij07a/mooij07a.pdf

MoK07b J. M. Mooij and H. J. Kappen (2007): "Sufficient Conditions for Convergence of the Sum-Product Algorithm", IEEE Transactions on Information Theory 53(12):4422-4437, http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?arnumber=4385778

MoR05 A. Montanari and T. Rizzo (2005): "How to Compute Loop Corrections to the Bethe Approximation", Journal of Statistical Mechanics: Theory and Experiment 2005(10)-P10011, http://stacks.iop.org/1742-5468/2005/P10011

StW99 A. Steger and N. C. Wormald (1999): "Generating Random Regular Graphs Quickly", Combinatorics, Probability and Computing Vol 8, Issue 4, pp. 377-396, http://www.math.uwaterloo.ca/~nwormald/papers/randgen.pdf

WiH03 W. Wiegerinck and T. Heskes (2003): "Fractional Belief Propagation", Advances in Neural Information Processing Systems (NIPS) 15, pp. 438-445, http://books.nips.cc/papers/files/nips15/LT16.pdf

WJW03 M. J. Wainwright, T. S. Jaakkola and A. S. Willsky (2003): "Tree-reweighted belief propagation algorithms and approximate ML estimation by pseudo-moment matching", 9th Workshop on Artificial Intelligence and Statistics, http://www.eecs.berkeley.edu/~wainwrig/Papers/WJW_AIStat03.pdf

YFW05 J. S. Yedidia and W. T. Freeman and Y. Weiss (2005): "Constructing Free-Energy Approximations and Generalized Belief Propagation Algorithms", IEEE Transactions on Information Theory 51(7):2282-2312, http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?arnumber=1459044

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_30.png0000644000263000017630000000030411334764771015153 0ustar jorismkybPNG  IHDR Rio0PLTEppp```PPP@@@000 4tRNS@fBIDATc`,)`c#!,d0 D+t03\1>9N:fI HIENDB`libDAI-0.2.4/doc/html/classdai_1_1UEdge.html0000644000263000017630000002566011334764771017237 0ustar jorismkyb libDAI: dai::UEdge Class Reference

dai::UEdge Class Reference

Represents an undirected edge. More...

#include <dai/weightedgraph.h>

List of all members.

Public Member Functions

 UEdge ()
 Default constructor.
 UEdge (size_t m1, size_t m2)
 Constructs an undirected edge between m1 and m2.
 UEdge (const DEdge &e)
 Construct from DEdge.
bool operator== (const UEdge &x)
 Tests for inequality (disregarding the ordering of the nodes).
bool operator< (const UEdge &x) const
 Smaller-than operator.

Public Attributes

union {
   size_t   n1
   size_t   first
}; 
union {
   size_t   n2
   size_t   second
}; 

Friends

std::ostream & operator<< (std::ostream &os, const UEdge &e)
 Writes an undirected edge to an output stream.

Detailed Description

Represents an undirected edge.

Constructor & Destructor Documentation

dai::UEdge::UEdge (  )  [inline]

Default constructor.

dai::UEdge::UEdge ( size_t  m1,
size_t  m2 
) [inline]

Constructs an undirected edge between m1 and m2.

dai::UEdge::UEdge ( const DEdge &  e  )  [inline]

Construct from DEdge.

Member Function Documentation

bool dai::UEdge::operator== ( const UEdge &  x  )  [inline]

Tests for inequality (disregarding the ordering of the nodes).

bool dai::UEdge::operator< ( const UEdge &  x  )  const [inline]

Smaller-than operator.

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os,
const UEdge &  e 
) [friend]

Writes an undirected edge to an output stream.

The documentation for this class was generated from the following file:
Generated on Thu Feb 11 12:26:08 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/smallset_8h-source.html0000644000263000017630000011375211334764771017623 0ustar jorismkyb libDAI: include/dai/smallset.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1RootedTree.html0000644000263000017630000001225011334764771020311 0ustar jorismkyb libDAI: dai::RootedTree Class Reference

dai::RootedTree Class Reference

Represents a rooted tree, implemented as a vector of directed edges. More...

#include <dai/weightedgraph.h>

Inherits std::vector< T >.

List of all members.

Public Member Functions

 RootedTree ()
 Default constructor.
 RootedTree (const GraphEL &T, size_t Root)
 Constructs a rooted tree from a tree and a root.

Detailed Description

Represents a rooted tree, implemented as a vector of directed edges.

By convention, the edges are stored such that they point away from the root and such that edges nearer to the root come before edges farther away from the root.

Constructor & Destructor Documentation

dai::RootedTree::RootedTree (  )  [inline]

Default constructor.

dai::RootedTree::RootedTree ( const GraphEL &  T,
size_t  Root 
)

Constructs a rooted tree from a tree and a root.

Precondition:
T has no cycles and contains node Root

The documentation for this class was generated from the following files:
Generated on Thu Feb 11 12:26:08 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1State-members.html0000644000263000017630000001376711334764771020763 0ustar jorismkyb libDAI: Member List

dai::State Member List

This is the complete list of members for dai::State, including all inherited members.

begin() const dai::State [inline]
const_iterator typedefdai::State
end() const dai::State [inline]
get() const dai::State [inline]
insert(InputIterator b, InputIterator e)dai::State [inline]
operator const std::map< Var, size_t > &() const dai::State [inline]
operator size_t() const dai::State [inline]
operator()(const Var &v) const dai::State [inline]
operator()(const VarSet &vs) const dai::State [inline]
operator++()dai::State [inline]
operator++(int)dai::State [inline]
reset()dai::State [inline]
statedai::State [private]
State()dai::State [inline]
State(const VarSet &vs, size_t linearState=0)dai::State [inline]
State(const std::map< Var, size_t > &s)dai::State [inline]
statesdai::State [private]
states_type typedefdai::State [private]
valid() const dai::State [inline]

Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_24.png0000644000263000017630000000067611334764771015172 0ustar jorismkybPNG  IHDRK)0PLTEppp```PPP@@@000 4tRNS@f;d!vnZ*0o2͇9-IENDB`libDAI-0.2.4/doc/html/classdai_1_1SmallSet.png0000644000263000017630000000103511334764771017600 0ustar jorismkybPNG  IHDRr1PLTE`{tRNS@fIDATXMr &knA;tH p[߇=ekЦNnyZ% libDAI: Change Log

Change Log 

libDAI-0.2.4 (2010-02-11)
-------------------------

New features:
* Implemented Tree-Reweighted BP
* [Frederik Eaton] Implemented Fractional Belief Propagation

Miscellaneous improvements:
* Improved documentation
* [Frederik Eaton] Added constructors for BBPCostFunction
* [Frederik Eaton] Added accessor/mutator for the elements of a SmallSet<>
* [Frederik Eaton] Added unary minus to TProb<>
* [Frederik Eaton] Added Hellinger distance to TProb<>::DistType
* [Frederik Eaton] Two small patches for src/jtree.cpp and utils/createfg.cpp
* tests/testdai option "marginals" now has three possible values: NONE
  outputs no marginals, VAR only variable marginals, and ALL outputs all
  marginals calculated by the algorithm.
* Strengthened convergence criteria of various algorithms
* Added GraphAL, an adjacency list implementation for graphs,
  similar to (but simpler than) BipartiteGraph
* Added some functionality to create various standard factors
  (the functions whose names start with "createFactor")
* Added examples example_sprinkler_gibbs and example_sprinkler_em
* Implemented various heuristics for choosing a variable elimination sequence 
  in JTree
* Added BETHE method for GBP/HAK cluster choice

Build system:
* Moved platform independent build options into Makefile.ALL
* Windows platform now needs Boost 1.37 or higher

Code cleanup:
* Cleaned up utils/createfg and tests/testdai

Interface changes (the old interface is marked obsolete and will be removed in the next release):
* Removed obsolete/deprecated stuff
* Renamed Graph into GraphEL (for Graph, implemented as Edge List)
* Renamed some functions of BipartiteGraph:
    add1() -> addNode1()
    erase1() -> eraseNode1()
    nr1() -> nrNodes1()
    add2() -> addNode2()
    erase2() -> eraseNode2()
    nr2() -> nrNodes2()
* Renamed some functions in ClusterGraph:
    ClusterGraph::eliminationCost() -> ::eliminationCost_MinFill() 
    ClusterGraph::VarElim() -> ClusterGraph::VarElim( sequentialVariableElimination( ElimSeq ) ) 
    ClusterGraph::VarElim_MinFill() -> ClusterGraph::VarElim( greedyVariableElimination( eliminationCost_MinFill ) )
* Changed interface of one RegionGraph constructor
* Renamed "Clamped BP" into "Conditioned BP"

Bug fixes:
* Fixed regression in scripts/regenerate-properties (now all errors are 
  gathered before throwing the exception, as used to be the case)
* Fixed FTBFS errors on MACOSX (thanks to Sebastian Riedel for reporting this bug)
* [Alexander Schwing] Fixed error in BP that occured with damping
  and using log-domain updates
* Fixed bug in HAK for trivial region graphs (with only one outer region
  and no inner regions), reported by Alejandro Lage.


libDAI-0.2.3 (2009-11-16)
-------------------------

New features:
* Complete doxygen documentation (although more detailed documentation still
  has to be written)
* [Charles Vaske] Added parameter learning for conditional probabilities by 
  Expectation Maximization
* [Patrick Pletscher] Added SWIG wrapper code for experimental python and 
  octave interfaces
* Added Max-Product functionality to JTree
* [Frederik Eaton] Added Back-Belief-Propagation
* [Frederik Eaton] Added approximate inference method "Clamped Belief Propagation"
* [Frederik Eaton] Added approximate inference method "Gibbs sampling"

Code cleanup:
* Updated copyright headers
* Cleaned up error handling by introducing the DAI_THROWE macro
* Introduced DAI_DEBASSERT macro to abbreviate a common pattern
* Replaced the standard assert() macro by DAI_ASSERT, which throws a
  dai::Exception and is even active if NDEBUG is defined
* Removed all the virtual default constructors *::create(), as they are not used
* [Frederik Eaton] Removed unnecessary copy constructors and assignment operators
* [Frederik Eaton] Change cout to cerr in warnings and error messages

Miscellaneous improvements:
* BipartiteGraph:
  - Added eraseEdge( size_t n1, size_t n2 )
  - [Frederik Eaton] Improved documentation of Neighbor
* TProb<T>:
  - Added divided_by(const TProb<T>&) const
  - Added constructor TProb<T>( const std::vector<S> &v )
  - Added size_t draw(), which draws a random index
  - [Frederik Eaton] Added setUniform()
  - [Frederik Eaton] Added sumAbs()
  - [Frederik Eaton] Added argmax()
  - [Giuseppe Passino] Added begin(), end()
* TFactor<T>:
  - [Giuseppe Passino] Added begin(), end()
  - [Charles Vaske] Added TFactor( const std::vector<Var> &vars, const std::vector<T> &p ),
    which reorders variables to canonical ordering before storing the table
  - Added constructor TFactor<T>( const VarSet &vars, const std::vector<S> &v )
  - Extended functionality of TFactor<T>::operators +,-,+=,-= to handle different VarSets
  - Added TFactor<T>::maxMarginal (similar to marginal but with max instead of sum)
* State:
  - [Giuseppe Passino] Added prefix ++ operator
* Permute:
  - [Charles Vaske] Added constructor in Permute for canonical variable ordering
* FactorGraph:
  - [Frederik Eaton] Added clampVar()
  - [Frederik Eaton] Added clampFactor()
  - [Giuseppe Passino] Added begin(), end()
* PropertySet:
  - Added keys(), for getting all keys
  - [Frederik Eaton] Added default constructor
  - [Frederik Eaton] Added constructor from string
* InfAlg:
  - Added setProperties(), getProperties() and printProperties()
  - [Frederik Eaton] Added beliefV(), beliefF()
* ExactInf:
  - Added calcMarginal(const VarSet &)
* HAK:
  - Added "init" parameter to allow for random initialization
* BP:
  - [Giuseppe Passino] Added findMaximum(), which can be used after running
    max-product BP to construct a global state with maximum probability
* JTree:
  - Added findMaximum(), which can be used after running
    max-product JTree to construct a global state with maximum probability
* MatLab interface:
  - MEX file dai now also returns variable and factor beliefs
  - [Sebastian Nowozin] MEX file dai now also optionally returns the MAP state
    (only for BP and JTree)
* README is now created automatically from doxygen documentation
* [Frederik Eaton] Added script for automatically generating properties code (used by CBP and BBP)
* [Frederik Eaton] Added newInfAlgFromString to alldai.h/cpp
* [Frederik Eaton] Added some utility macros (DAI_PV, DAI_DMSG, DAI_IFVERB)
  and functions (concat(),rnd()) to util.h
* Changed output stream operator<< for Var and VarSet
* [Frederik Eaton] Improved parsing code in tests/testdai to allow recursive
  alias substitutions
* [Frederik Eaton] Added useful aliases to aliases.conf
* [Giuseppe Passino] Optimised maximum-residual BP by using a reversed ordered
  set instead of the linear search (which can yield enormous speedups - a
  factor 500 has been measured on a binary Ising grid with 128x128 variables!)
* Added debug assertions to Var which check for inconsistent dimensions of
  variables with the same labels
* toc() now returns POSIX system time with maximum accuracy of microseconds
* Exception objects now remember their error code
* Examples:
  - Moved example.cpp to examples/
  - Added examples/example_bipgraph.cpp
  - Added examples/example_varset.cpp
  - Added examples/example_sprinkler.cpp
  - Added examples/example_permute.cpp
  - Added python and octave ports for examples/example_sprinkler.cpp

Build system:
* Improved Makefile:
  - Merged Makefile.win and Makefile.shared into Makefile
  - Macros DAI_VERSION and DAI_DATE have been introduced,
    in order to store this information in a central place
  - Introduced CCNODEBUGFLAGS in Makefile
  - Switched Makefile.win to GNU Make syntax
  - [Frederik Eaton] Added TAGS, lib targets to Makefile
* Compatibility:
  - [Peter Gober] libDAI can now be built on Cygwin
  - [Dan Preston] libDAI can now be built on Mac OS X
  - Changed regression test so that it also works under Windows

Interface changes (the old interface is marked obsolete and will be removed in the next release):
* Var:
  - Variable labels are now nonnegative (of type size_t)
* VarSet:
  - Replaced calcState() by non-member calcLinearState()
  - Replaced calcStates() by non-member calcState()
* Permute:
  - Renamed convert_linear_index into convertLinearIndex
* TProb<>:
  - Replaced log0() by log(true)
  - Replaced takeLog0() by takeLog(true)
  - Removed hasNonPositives()
  - Renamed minVal() to min()
  - Renamed maxVal() to max()
  - Renamed totalSum() to sum()
* TFactor<>:
  - Replaced log0() by TFactor<T>::log(true)
  - Removed divided_by, use operator/ instead
  - Removed divide, use operator/= instead
  - Removed partSum(const VarSet&), use marginal(const VarSet&,false) instead
  - Renamed minVal() to min()
  - Renamed maxVal() to max()
  - Renamed totalSum() to sum()
* FactorGraph:
  - Changed clamp and clamp interfaces (the variable to be
    clamped is now indicated by its index, not as a Var)
* RegionGraph:
  - Renamed Check_Counting_Numbers into checkCountingNumbers
  - Renamed Calc_Counting_Numbers into calcCountingNumbers
* Miscellaneous:
  - Renamed Treewidth(const FactorGraph &) into boundTreewidth(const FactorGraph &)
  - Replaced UEdgeVec by Graph
  - Replaced DEdgeVec by new RootedTree class
  - Moved functionality of GrowRootedTree() into constructor of RootedTree
  - Merged calcPairBeliefsNew() into calcPairBeliefs()
  - Removed calcMarginal2ndO()
  - Renamed smallSet<T> to SmallSet<T>
  - Removed class Diffs
  - [Frederik Eaton] Added backwards compatibility layer for edge interface to
    BipartiteGraph and FactorGraph (which will be obsoleted soon)

Bug fixes:
* Fixed reversal of min and max in 
  TFactor<T> min( const TFactor<T> &, const TFactor<T> & )
  TFactor<T> max( const TFactor<T> &, const TFactor<T> & )
* [Sebastian Nowozin] Fixed memory leak in MEX file dai
* [Frederik Eaton] In PropertySet::getStringAs(), check for typeid(ValueType) 
  before typeid(std::string) (this fixes a strange bug for empty string property)
* Added work-around for bug in Boost Graph Library
* Fixed bug in MaxSpanningTree (it wrongly assumed that the tree was not empty).
* Fixed bug in calcMarginal and calcPairBeliefs where states with zero probability 
  mass were clamped, leading to NaNs or assertion errors (thanks to Dan Preston 
  for reporting this)


libDAI-0.2.2 (2008-09-30)
-------------------------

New features:
* Approximate inference methods now report the number of iterations needed.
* Added damping to various algorithms to improve convergence properties.
* Added more features to utils/createfg for creating factor graphs.
* Added ExactInf class for brute force exact inference.
* [Giuseppe Pasino] Added "logdomain" property to BP, a boolean that controls
  whether calculations are done in the log-domain or in the linear domain;
  doing calculations in the log-domain may help if the numerical range
  of a double is too small.
* [Claudio Lima] Added Max-Product functionality to BP.
* Improved documentation.

Improved architecture:
* Added Exceptions framework.
* Pervasive change of BipartiteGraph implementation (based on an idea by
  Giuseppe Passino). BipartiteGraph no longer stores the node properties
  (former _V1 and _V2), nor does it store a dense adjacency matrix anymore,
  nor an edge list. Instead, it stores the graph structure as lists of
  neighboring nodes. This yields a significant memory/speed improvement for
  large factor graphs, and is more elegant as well. Iterating over neighbors is
  made easy by using boost::foreach.
* Added conditional compilation of inference methods.
* VarSet is now implemented using a std::vector<Var> instead of a
  std::set<Var>, which yields a significant speed improvement. Furthermore,
  the implementation has been generalized, resulting in the small_set<T> class
  which can be used to represent sets of small cardinality; VarSet is the
  specialization with T = Var.
* Improved ClusterGraph implementation, yielding significant speedups
  for the JunctionTree algorithm on large factorgraphs.

Code cleanup:
* Moved everything into namespace "dai".
* Renamed DEBUG to DAI_DEBUG to avoid conflicts.
* Replaced ENUM2,ENUM3,ENUM4,ENUM5,ENUM6 by single DAI_ENUM macro.
* Removed utils/remove_short_loops and matlab/remove_short_loops.
* Replaced sub_nb class in mr.h by boost::dynamic_bitset.
* Improved index.h:
  - Renamed Index -> IndexFor
  - Added some .reserve()'s to IndexFor methods which yields a
    25% speedup of testregression
  - Replaced multind by Permute
  - Added MultiFor
  - Added State
* New funcstionality of factor.h.
* Moved Properties and MaxDiff frameworks from InfAlg to each individual
  inference algorithm, because the Properties framework was not as
  convenient as I hoped, and not every inference algorithm needs a maxdiff
  variable. Also, replaced some FactorGraph functionality in InfAlg by a
  function that returns the FactorGraph. The result is cleaner (less
  entangled) code.
* Removed x2x.
* Replaced Complex with real numbers (negative potentials are just too rare
  to warrant the additional "complexity" :)).

Miscellaneous improvements:
* Now compiles also with MS Visual C++ (thanks to Jiuxiang Hu) and with
  GCC under cygwin.
* Contributions by Peter Gober:
  - Renamed variable _N in mr.* for compatibility with g++ under cygwin.
* Misc contributions by Giuseppe Passino:
  - removed "using namespace std;" from header files - bad practice;
  - moved header files in include/dai and sources in src;
  - changed #ifndefs to GNU style;
  - added extra warning checks (-W -Wextra) and fixed resulting warnings;
  - dai::TProb:
    o removed copy constructor and assignment operators (redundant);
    o implementation of some methods via STL algorithms;
    o added methods takeExp, takeLog, takeLog0 for transformation in-place;
    o explicit constructor (prevents implicit conversion from size_t to TProb);
    o added operator+,+=,-,-=, with argument T (for calculations in log-scale);
* Misc contributions by Christian Wojek:
  - New FactorGraph constructor that constructs from given ranges of factors
    and variables;
  - Optimization of FactorGraph constructors using tr1::unordered_map.
* FactorGraph constructors no longer check for short loops (huge speed
  increase for large factor graphs), nor for negative entries. Also, the
  normtype is now Prob::NORMPROB by default.
* Improved MaxSpanningTreePrims algorithm (uses boost::graph).

Interface changes:
* VarSet::
  - VarSet::stateSpace() -> nrStates(const VarSet &)
  - VarSet( const std::set<Var> ) -> VarSet( begin, end, sizeHint=0 )
  - VarSet( const std::vector<Var> ) -> VarSet( begin, end, sizeHint=0 )
  - removed bool operator||
  - operator&&(const VarSet&) -> intersects(const VarSet&)
  - operator&&(const Var&) -> contains(const Var&)
* FactorGraph::
  - delta(const Var &) -> delta(size_t)
  - Delta(const Var &) -> Delta(size_t)
  - makeCavity(const Var &) -> makeCavity(size_t)
  - vars() -> vars
  - factors() -> factors
  - removed MakeFactorCavity(size_t)
  - removed ExactMarginal(const VarSet &)
  - removed ExactlogZ()
  - removed updatedFactor(size_t)
  - removed _normtype and NormType()
  - removed hasShortLoops(...) and removeShortLoops(...)
  - WriteToDotFile(const char *filename) -> printDot( std::ostream& os )
  - undoProb(size_t) -> restoreFactor(size_t)
  - saveProb(size_t) -> backupFactor(size_t)
  - undoProbs(const VarSet &) -> restoreFactors(const VarSet &)
  - saveProbs(const VarSet &) -> backupFactors(const VarSet &)
  - ReadFromFile(const char*) returns void (throws on error)
  - WriteToFile(const char*) returns void (throws on error)
  - removed hasNegatives()
* RegionGraph::
  - nr_ORs() -> nrORs()
  - nr_IRs() -> nrIRs()
  - ORs() -> ORs
  - IRs() -> IRs
* *::Regenerate() -> *::construct()
* Renamed Index -> IndexFor
* Diffs:
  - max() -> maxDiff()
  - max_size() -> maxSize()
* Prob::max() -> Prob::maxVal()
* Factor::
  - max() -> maxVal()
  - part_sum() -> partSum()
* toc() in util.h now returns seconds as a double
* VarSet::operator&&
* Properties -> PropertySet


libDAI-0.2.1 (2008-05-26)
-------------------------

Bugfix release.
* added missing cstdio header in util.h
* fixed Properties in MR_CLAMPING_* and MR_EXACT_*
* added description of the factor graph fileformat
* improved Makefile


libDAI-0.2.0 (2006-11-30)
-------------------------

First public release.


0.1.5 (2006-11-30)
------------------

Regressions

- tests/testlcbp and tests/testlcbp are broken.
- EXACT method does not work anymore.
- The Properties framework gives a speed penalty because of the lookup
  costs involved; inner loops should be optimized.

General framework

- DAIAlg is now a template class; typedefs for DAIAlg<FactorGraph> and for
  DAIAlg<RegionGraph> are provided. In this way, we do not have to write "wrapper"
  functions to forward functionality from either FactorGraph or RegionGraph
  to DAIAlg. Functionality like clamping can be implemented in FactorGraph
  and in RegionGraph and no explicit interface is needed in descendants.
- New abstract base class InfAlg added, representing an inference algorithm,
  from which DAIAlg<T> inherits. This solves the incompatibility problems of
  DAIAlg<T> for different T (e.g. DAIAlg<FactorGraph> was incompatible with
  DAIAlg<RegionGraph>). More work is required to reduce code duplication
  (make FactorGraph part of InfAlg).
- Added generic interface (nrVars(), Vars(), nrFactors(), factor(size_t),
  beliefs(), belief(VarSet &), ...) to InfAlg and descendants.
- Added a saveProbs/undoProbs interface to InfAlg and descendants that enables
  one to save a few factors, modify them (e.g. clamp them), and then restore them
  to their old values. Undo should also init the corresponding messages / beliefs.
  This can be used if a given factor graph repeatedly needs to be clamped in
  different ways and an approximation method is run for each clamping; using the
  saveProbs/undoProbs can give a significant speed increase.
- Switched to a general Properties framework that handles the parameters of
  all inference methods in a uniform manner. The Properties class is a map of
  several properties in boost::any objects, indexed by their names (strings).
  It can read from a stream and write to a stream. It is recursive, in the sense
  that a Properties object can hold a variable of type Properties as well.
- Added a generic way of constructing inference algorithms from a factor graph,
  name and properties object. Added the newInfAlg function which constructs
  the requested object. This is used by LCBP, the Matlab interface and the
  command line (test) interface.
- Added a generic enum framework for enum parameters. Although implemented as a
  hack, it is quite useful in that it drastically simplifies and reduces the
  amount of code for handling enum parameters.
- Provided generic functions for calculating marginals in different ways that
  work for all approximate inference methods.

Bugfixes

- Fixed GBP free energy.
- Fixed bug in junctiontree (it didn't init the _vars variable).
- Corrected two bugs in operator&& and operator|| in VarSet (they returned
  the logical NOT of what they should return).
- Fixed bug in RegionGraph::RecomputeOR(s).
- Fixed bug in utils/create_dreg_fg:
  graph structure was not random for given parameters (forgot to call srand()).
- TreeEP bug workaround: use the complete junction tree instead of a subtree.
- Fixed bug in JTree::HUGIN() and JTree:ShaferShenoy() in case of junction tree
  that consists of one outer region only.
- Fixed INIT bug in LCBP2::UpdatePancake().
- Fixed MaxDiffs flow (except for MR).

New functionality

- HAK supports several default cluster choices:
  minimal (only factors)
  delta   (Markov blankets)
  loop    (all loops consisting of loops consisting of <loopdepth> or less variables)
  Only the maximal clusters are used as outer clusters.
- Implemented TreeEP. It generalizes the heuristic method described in the
  Minka & Qi paper for obtaining a tree with the most relevant interactions to
  higher order interactions. Almost all optimizations described in the Minka & Qi
  paper are used, except that evidence is passed over the whole tree instead of
  relevant subsets (the latter is almost implemented but buggy). Also added
  alternative (worst-case) algorithm that uses a maximum spanning tree on the
  weighted graph where the weight between neighbours i and j is given by
  N(psi,i,j), where psi is the product of all the factors involving both i and j
  (which is an upper bound on the effective interaction between i and j).
- Implemented MR (MontanariRizzo) based on Bastian's code, but extended it
  to be able to handle connectivities larger than 3 (in principle, up to 32).
  It supports different initialization methods (the original RESPPROP,
  the CLAMPING method and EXACT which uses JTree) and different update methods
  (FULL and LINEAR).
- Implemented LCBP2, an analogon of LCBP which represents pancakes as little
  networks and uses some approximate inference method on them for calculating
  marginals.
- Now there are several LCBP variants (LCBP, LCBPI, LCBPJ, LCBPK, LCBPL);
  LCBPJ works only for pairwise, LCBPK is LCBP improved for higher order
  interactions and LCBPL is LCBPI improved for higher-order interactions.
- Wrote one single program utils/createfg for creating various types of
  random factor graphs.
- Wrote utility to visualize factor graphs using graphviz.
  (it uses the BOOST Program Options library)
- Added fginfo utility that displays some info about a .fg file.
- Implemented Factor::strength function that calculates the potential strength
  N(psi,i,j) between variables i and j as described in cs.IT:0504030
- Wrote a general MatLab interface matlab/dai (similar to tests/test);
  this unified the matlab functions dai, dai_bp, dai_mf, dai_jt, dai_tep, dai_cvm.
- Added MATLAB routine that returns contraction matrix A for BP convergence analysis.
- Implemented a MATLAB interface ai_potstrength for Factor::strength
- Added Martijn's x2x

Improvements of existing code

- Reimplemented RegionGraph and descendants: a RegionGraph ISA FactorGraph
  and also a BipartiteGraph<FRegion,Region>. It now also keeps a map that
  associates outer region indices to factor indices (no powers yet, this
  is deemed superfluous) and provides functions to recompute (some of) the
  outer regions from the factors.
- InfAlg descendants run() methods now stop immediately and return NAN in case
  they detect NANs. Only BP does not do NAN checking for performance reasons.
- LCBP now works with factors containing zeroes (by defining x/0 = 0).
- HAK, GBP and DoubleLoop now conform to the standards for verbose reporting,
  timing and convergence criteria.
- Implemented logZ() for JTree. It does the calculation during message-passing.
- Marginal2ndO now optionally divides by the single node beliefs (to the power n-2);
  hopefully this will give more accurate approximations.
- Marginal and Marginal2ndO (optionally) use the new saveProbs/undoProbs functionality
  for a faster way of calculating marginals, which does not require a call to init()
  nor cloning the whole object for each clamping. This leads to a significant speedup.
- LCBP (and LCBP2) now have complete flexibility in the specification of the
  inner method, i.e. the method used to generate the initial cavity approximations.
  One can pass two strings, a name and a properties string, and LCBP simply invokes
  newInfAlg to construct the corresponding inference algorithm and uses the generic
  marginal functions to approximate cavity marginals.
- Replaced the global "method" variable by local properties and removed ai.h
- Added some methods to Factor (operators *, *=, /, /= with doubles as
  second argument, operators -, +=, -= with other Factors as second
  arguments, randomize(), RemoveFirstOrderInteractions) and similar
  operations to Prob
- Moving towards boost::program_options for handling command line arguments
  (tests/test is done).
- Renamed some FactorGraph methods:
  nr_vars       -> nrVars
  nr_factors    -> nrFactors
  varind        -> findVar
  factorind     -> findFactor
  makeFacCavity -> makeFactorCavity
- LCBP_SEQMAXRES has been removed because it did strange things.
- Implemented RandomDRegularGraph
- Implemented JTree::calcMarginal for marginals that are not confined
  within one cluster (using cut-set conditioning).
- Added isConnected() method to FactorGraph (some methods do not work with
  disconnected factor graphs).
- Pair beliefs are now calculated in a symmetrical way by calcPairBeliefs
- Removed single node interaction "correction" code from clamping methods
- Removed calcCavityDist and calcCavityDist2ndO
- No longer depends on GSL.
- Increased portability by combining platform dependant utility functions
  in util.{h,cpp}.
- Wrote *.m files providing help

Testing framework

- Made a new and significantly improved testing framework that provides most
  functionality from the command line.
- The basis is provided by tests/test, which uses the newInfAlg functionality
  and enables the user to easily compare from the command line different
  inference methods on a given factorgraph. All parameters can be specified.
  Output consists of CPU time, average and maximum single variable marginal
  errors, relative logZ error and MaxDiff().
- tests/aliases.conf contains aliases for standard combinations of methods
  and their options (which can be used in tests/test).
- tests/large contains several bash/python scripts that create random factor
  graphs, compare several approximate inference algorithms (using tests/test) and
  allow for easy visualization of the results using PyX.
- Added several .fg files for test purposes to /tests (e.g. two ALARM versions
  alarm.fg and alarm_bnt.fg; testfast.fg, a 4x4 periodic Ising grid for
  regression testing).
- Added a regression test to the Makefile which is included in the standard
  target.  It compares all inference methods on tests/testfast.fg with the
  results stored in tests/testfast.out

Miscellaneous

- Expanded all tabs to spaces (":set tabstop 4\n:set expandtab\n:retab" in vim)
- Experimental MATLAB code added for StarEP approximation on cavity
- Renamed project to libDAI and changed directory name accordingly.
- Renamed JunctionTree to JTree.
- Fixed licensing (now it's officially GPL).
- Improved README


revision 252
------------

Functionality
- Added RegionGraph, GBP, CVM and HAK (double-loop).
- Added JunctionTree (with two update algorithms, HUGIN and Shafer-Shenoy), which is a
  RegionGraph.
- NormType is now chosen automatically (in case of negative factors, Prob::NORMLINF is used,
  otherwise the default Prob::NORMPROB is used). Also, in case of negative factors, the
  RegionGraph constructors assign each Factor to a unique outer region instead of dividing
  it over all subsuming outer regions. See README for when negative factors are known to work
  and when not.
- FactorGraph::FactorGraph(const vector<Factor>) only gives a warning in case of short loops,
  it does not automatically merge factors anymore.
- Removed BP_SEQMAXRESNOCLEAR (all cavity initialization methods now are implicitly NOCLEAR)
- Added MATLAB interface functions ai_readfg, ai_removeshortloops and ai_bp
- Added LCBP-III type that should be equivalent to LCBP-II, but can handle zeroes
  in potentials. Note that it is significantly slower than LCBP-II (and has to be reimplemented
  such that it does not store the complete pancakes, but represents them as little factor graphs).

Implementation / code
- Made a seperate type WeightedGraph, which until now only implements Prim's
  maximal spanning tree algorithm and is only used by the junction tree code. It might
  be good to make it a class somewhere in the future and extend it's interface.
- Made a seperate class ClusterGraph, which is only used by the junction tree
  code. It's main purpose is a graph-theoretical variable elimination algorithm.
- Implemented the heuristic "minimum-new-edges-in-clique-graph" for variable elimination.
- Massive code cleanup, moving towards "generic" programming style, using
  multiple inheritance and polymorphism.
  o BP, LCBP, MF, HAK and JunctionTree now inherit from a common DAIAlg class
  o Made generic functions Marginal, Marginal2ndO, calcCavityDist, calcCavityDist2ndO, clamp
    that can be used by FactorGraph-based DAIAlgs.
  o Created TProb<T> class, which stores a probability vector (without the accompanying indexing
    and VarSet) and provides functionality for it (which is used by TFactor<T>).
  o Rewrote the VarSet class. It now caches its statespace(). It now privately inherits from set<Var>.
    I had to overload the insert methods of set<Var> so that they calculate the new statespace.
  o Rewrote the TFactor class. The TFactor class now HAS a TProb and HAS a VarSet.
- Rewrote BP to use the new TProb<T> interface. Performance of BP improved up to a factor 6 by:
  o using Prob's instead of Factor's;
  o splitting the multiplication of the messages into two parts (thanks to Vicenc!);
  o optimizing the calculation of the beliefs (only the message calculations were optimized till now).
  o replacing FactorGraph::_nb1 and _nb2 (which were set<size_t>) by vector<size_t>
- LCBP now seperately stores cavitydists and pancakes. Added InitPancakes() method
  that takes the cavitydists and multiplies them with the relevant factors. This
  resulted in an API change in AI which now accepts and returns initial cavitydists
  instead of initial pancakes.

Minor changes
- Started writing DoxyGen documentation
- Renamed lcptab2fg.m matlab/ai_writefg.m
- Moved all matlab stuff to matlab/
- More detailed reporting (also reports clocks used).
- Marginal and Marginal2ndO now use *differences* in logZ to avoid NaNs.
- Improved testing suite.
- Removed logreal support.
- FactorGraph now also supports input streams and ignores comment lines in .fg files.
- Added tests/create_full_fg.cpp and tests/create_ising_fg.cpp which create
  full and periodic 2D Ising networks according to some command line parameters.
- Now logZ really returns logZ instead of -logZ.
- Added FactorGraph::WriteToDotFile


0.1.4 (2006-04-13)
------------------
- Added file IO routines to read and write factorgraphs.
- Added L-infinity normalization for use with (partially) negative factors.
- Renamed BetheF, MFF to logZ, which now use complex numbers to be able to
handle (partially) negative factors.
- Added test suite.
- All probabilities are now represented using double instead of LogReal<double>.
- Combined Alg and Alg3 into LCBP. Several update schemes possible.
- Combined several variants of BP into doBP. Several update schemes possible.
Now uses precalculated indices for optimization.
- Renamed Node -> Var and Potential -> Factor.
- Extensive code cleanup. More use of OO techniques. Changed API.
- MaxIter now means maximum number of passes (corresponding to number of
_parallel_ updates).
- MaxDiff now means the maximum L-infinity distance between the updated and
original single variable beliefs, for all AI methods.
- Implemented RBP which converges faster than BP for difficult problems.
- Now uses method parameter which is a bitmask combining outmethod and inmethod
(see ai.h).


0.1.3   (2006-03-22)
--------------------
- All AI methods now return maxdiff
- ai.cpp:
    o Now returns maxdiffinner and maxdiffouter
    o New BP2ndO innermethod (estimate only 2nd order cavity interactions)
    o New InitCav outermethod (only create initial cavity distributions)
- bp.cpp:
    o New CavityDist2ndO which estimates 2nd order cavity interactions
- Makefile:
    o Bugfix: removed dependencies on algwim.*


0.1.2   (2006-02-28)
--------------------
- Cleaned up alg.cpp (removed Alg2 and its corresponding data structures).
- Added the possibility to provide initial cavity distributions as an input
argument to ai (not much error checking is done, so be careful).
- Potentials2mx now correctly sets the dimensions of the P field (i.e. for
the output arguments Q, Q0 of ai).
- Removed algwim.* since it does not work.


0.1.1   (2006-02-28)
--------------------
- The constructors of (Log)FactorGraph and LogFactorGraph from a
vector<(Log)Potential> now merge potentials to prevent short loops (of length
4) in the factor graph. These are used in ai to construct the factor graphs
from the psi argument. If compiled with DEBUG defined, the method calc_nb()
of BipGraph checks for the existence of short loops.
- Changed calling syntax of ai (now the actual syntax *does* correspond to its
description in the help).
- ai does not hook cout anymore (which caused weird segfaults).
- Fixed a bug in an assert statement in the matlab interface code in ai.cpp.
- Removed network.* since it is not useful.


0.1.0   (2006-02-28)
--------------------
First version worthy a version number.
Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1RegionGraph.png0000644000263000017630000000142311334764771020262 0ustar jorismkybPNG  IHDRJYOPLTE`{tRNS@fIDAThmn ß}7h/4Js#,` -L7F &Dw|-?AD m݋[)nq@14R2&vBFd'NψP2$eDĚ6Gpp"0 t0 xDh- >QTb7=(DU{~^ 1c8>r6|_+ 8Q0! aC`_go?qXjuLEH܇i>~Y\LiqK^=xf ]ҵH?y x+ȈE/)!o V<1,^­M-8/E>Q^ݝrNXqj67|^e8>r<O{5N! aC0!ئ#&b*gYXj Uym ֱЭkr5uh2;n WbbVj$D䕄"=b/ RWp&]U8[U9 &d7U壚xlrsͥ"*!yP1="q "1 bʖɂ4 U?"YrVEA4k*gAԲX(rw'JA /lKC>Tmz`Eptq q&Gδm!rIENDB`libDAI-0.2.4/doc/html/alldai_8h.html0000644000263000017630000001641311334764771015723 0ustar jorismkyb libDAI: include/dai/alldai.h File Reference

include/dai/alldai.h File Reference

Main libDAI header file. It #includes all other libDAI headers. More...

#include <string>
#include <dai/daialg.h>
#include <dai/properties.h>
#include <dai/exactinf.h>
#include <dai/evidence.h>
#include <dai/emalg.h>
#include <dai/bp.h>
#include <dai/fbp.h>
#include <dai/trwbp.h>
#include <dai/mf.h>
#include <dai/hak.h>
#include <dai/lc.h>
#include <dai/treeep.h>
#include <dai/jtree.h>
#include <dai/mr.h>
#include <dai/cbp.h>

Go to the source code of this file.

Namespaces

namespace  dai

Functions

InfAlg * dai::newInfAlg (const std::string &name, const FactorGraph &fg, const PropertySet &opts)
 Constructs a new inference algorithm.
InfAlg * dai::newInfAlgFromString (const std::string &nameOpts, const FactorGraph &fg)
 Constructs a new inference algorithm.
InfAlg * dai::newInfAlgFromString (const std::string &nameOpts, const FactorGraph &fg, const std::map< std::string, std::string > &aliases)
 Constructs a new inference algorithm.
std::pair< std::string,
PropertySet > 		dai::parseNameProperties (const std::string &s)
 Extracts the name and property set from a string s in the format "name[key1=val1,key2=val2,...]" or "name".
std::pair< std::string,
PropertySet > 		dai::parseNameProperties (const std::string &s, const std::map< std::string, std::string > &aliases)
 Extracts the name and property set from a string s in the format "name[key1=val1,key2=val2,...]" or "name", performing alias substitution.
std::map< std::string,
std::string > 		dai::readAliasesFile (const std::string &filename)
 Reads aliases from file named filename.

Variables

static const char * dai::DAINames []
 Contains the names of all inference algorithms compiled into libDAI.

Detailed Description

Main libDAI header file. It #includes all other libDAI headers.

Todo:
Replace VarSets by SmallSet<size_t> where appropriate, in order to minimize the use of FactorGraph::findVar().
Todo:
Implement routines for UAI probabilistic inference evaluation data
Todo:
Improve SWIG interfaces and merge their build process with the main build process
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1BipartiteGraph.html0000644000263000017630000021234411334764771021150 0ustar jorismkyb libDAI: dai::BipartiteGraph Class Reference

dai::BipartiteGraph Class Reference

Represents the neighborhood structure of nodes in an undirected, bipartite graph. More...

#include <dai/bipgraph.h>

List of all members.

Public Types

typedef std::vector< Neighbor > Neighbors
 Describes the neighbors of some node.
typedef std::pair< size_t, size_t > Edge
 Represents an edge: an Edge(n1,n2) corresponds to the edge between node n1 of type 1 and node n2 of type 2.

Public Member Functions

Constructors and destructors
 BipartiteGraph ()
 Default constructor (creates an empty bipartite graph).
template<typename EdgeInputIterator>
 BipartiteGraph (size_t nrNodes1, size_t nrNodes2, EdgeInputIterator begin, EdgeInputIterator end)
 Constructs BipartiteGraph from a range of edges.
Accessors and mutators
const Neighbor & nb1 (size_t i1, size_t _i2) const
 Returns constant reference to the _i2 'th neighbor of node i1 of type 1.
Neighbor & nb1 (size_t i1, size_t _i2)
 Returns reference to the _i2 'th neighbor of node i1 of type 1.
const Neighbor & nb2 (size_t i2, size_t _i1) const
 Returns constant reference to the _i1 'th neighbor of node i2 of type 2.
Neighbor & nb2 (size_t i2, size_t _i1)
 Returns reference to the _i1 'th neighbor of node i2 of type 2.
const Neighbors & nb1 (size_t i1) const
 Returns constant reference to all neighbors of node i1 of type 1.
Neighbors & nb1 (size_t i1)
 Returns reference to all neighbors of node i1 of type 1.
const Neighbors & nb2 (size_t i2) const
 Returns constant reference to all neighbors of node i2 of type 2.
Neighbors & nb2 (size_t i2)
 Returns reference to all neighbors of node i2 of type 2.
Adding nodes and edges
template<typename EdgeInputIterator>
void construct (size_t nrNodes1, size_t nrNodes2, EdgeInputIterator begin, EdgeInputIterator end)
 (Re)constructs BipartiteGraph from a range of edges.
size_t addNode1 ()
 Adds a node of type 1 without neighbors and returns the index of the added node.
size_t addNode2 ()
 Adds a node of type 2 without neighbors and returns the index of the added node.
size_t add1 ()
 Adds a node of type 1 without neighbors and returns the index of the added node.
size_t add2 ()
 Adds a node of type 2 without neighbors and returns the index of the added node.
template<typename NodeInputIterator>
size_t addNode1 (NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0)
 Adds a node of type 1, with neighbors specified by a range of nodes of type 2.
template<typename NodeInputIterator>
size_t addNode2 (NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0)
 Adds a node of type 2, with neighbors specified by a range of nodes of type 1.
template<typename NodeInputIterator>
size_t add1 (NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0)
 Adds a node of type 1, with neighbors specified by a range of nodes of type 2.
template<typename NodeInputIterator>
size_t add2 (NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0)
 Adds a node of type 2, with neighbors specified by a range of nodes of type 1.
void addEdge (size_t n1, size_t n2, bool check=true)
 Adds an edge between node n1 of type 1 and node n2 of type 2.
Erasing nodes and edges
void eraseNode1 (size_t n1)
 Removes node n1 of type 1 and all incident edges; indices of other nodes are changed accordingly.
void eraseNode2 (size_t n2)
 Removes node n2 of type 2 and all incident edges; indices of other nodes are changed accordingly.
void erase1 (size_t n1)
 Removes node n1 of type 1 and all incident edges; indices of other nodes are changed accordingly.
void erase2 (size_t n2)
 Removes node n2 of type 2 and all incident edges; indices of other nodes are changed accordingly.
void eraseEdge (size_t n1, size_t n2)
 Removes edge between node n1 of type 1 and node n2 of type 2.
Queries
size_t nrNodes1 () const
 Returns number of nodes of type 1.
size_t nrNodes2 () const
 Returns number of nodes of type 2.
size_t nr1 () const
 Returns number of nodes of type 1.
size_t nr2 () const
 Returns number of nodes of type 2.
size_t nrEdges () const
 Calculates the number of edges, time complexity: O(nrNodes1()).
std::vector< size_t > delta1 (size_t n1, bool include=false) const
 Calculates second-order neighbors (i.e., neighbors of neighbors) of node n1 of type 1.
std::vector< size_t > delta2 (size_t n2, bool include=false) const
 Calculates second-order neighbors (i.e., neighbors of neighbors) of node n2 of type 2.
bool isConnected () const
 Returns true if the graph is connected.
bool isTree () const
 Returns true if the graph is a tree, i.e., if it is singly connected and connected.
void checkConsistency () const
 Checks internal consistency.
Input and output
void printDot (std::ostream &os) const
 Writes this BipartiteGraph to an output stream in GraphViz .dot syntax.

Private Attributes

std::vector< Neighbors > _nb1
 Contains for each node of type 1 a vector of its neighbors.
std::vector< Neighbors > _nb2
 Contains for each node of type 2 a vector of its neighbors.

Classes

struct  levelType
 Used internally by isTree(). More...
struct  Neighbor
 Describes the neighbor relationship of two nodes in a BipartiteGraph. More...

Detailed Description

Represents the neighborhood structure of nodes in an undirected, bipartite graph.

A bipartite graph has two types of nodes: type 1 and type 2. Edges can occur only between nodes of different type. Nodes are indexed by an unsigned integer. If there are nrNodes1() nodes of type 1 and nrNodes2() nodes of type 2, the nodes of type 1 are numbered 0,1,2,...,nrNodes1()-1 and the nodes of type 2 are numbered 0,1,2,...,nrNodes2()-1. An edge between node n1 of type 1 and node n2 of type 2 is represented by a BipartiteGraph::Edge(n1,n2).

A BipartiteGraph is implemented as a sparse adjacency list, i.e., it stores for each node a list of its neighboring nodes. More precisely: it stores for each node of type 1 a vector of Neighbor structures (accessible by the nb1() method) describing the neighboring nodes of type 2; similarly, for each node of type 2 it stores a vector of Neighbor structures (accessibly by the nb2() method) describing the neighboring nodes of type 1. Thus, each node has an associated variable of type BipartiteGraph::Neighbors, which is a vector of Neighbor structures, describing its neighboring nodes of the other type.

Idea:
Cache second-order neighborhoods in BipartiteGraph.
Examples:

example_bipgraph.cpp.

Member Typedef Documentation

typedef std::vector<Neighbor> dai::BipartiteGraph::Neighbors

Describes the neighbors of some node.

typedef std::pair<size_t,size_t> dai::BipartiteGraph::Edge

Represents an edge: an Edge(n1,n2) corresponds to the edge between node n1 of type 1 and node n2 of type 2.

Constructor & Destructor Documentation

dai::BipartiteGraph::BipartiteGraph (  )  [inline]

Default constructor (creates an empty bipartite graph).

template<typename EdgeInputIterator>
dai::BipartiteGraph::BipartiteGraph ( size_t  nrNodes1,
size_t  nrNodes2,
EdgeInputIterator  begin,
EdgeInputIterator  end 
) [inline]

Constructs BipartiteGraph from a range of edges.

Template Parameters:
EdgeInputIterator Iterator that iterates over instances of BipartiteGraph::Edge.
Parameters:
nrNodes1 The number of nodes of type 1.
nrNodes2 The number of nodes of type 2.
begin Points to the first edge.
end Points just beyond the last edge.

Member Function Documentation

const Neighbor& dai::BipartiteGraph::nb1 ( size_t  i1,
size_t  _i2 
) const [inline]

Returns constant reference to the _i2 'th neighbor of node i1 of type 1.

Neighbor& dai::BipartiteGraph::nb1 ( size_t  i1,
size_t  _i2 
) [inline]

Returns reference to the _i2 'th neighbor of node i1 of type 1.

const Neighbor& dai::BipartiteGraph::nb2 ( size_t  i2,
size_t  _i1 
) const [inline]

Returns constant reference to the _i1 'th neighbor of node i2 of type 2.

Neighbor& dai::BipartiteGraph::nb2 ( size_t  i2,
size_t  _i1 
) [inline]

Returns reference to the _i1 'th neighbor of node i2 of type 2.

const Neighbors& dai::BipartiteGraph::nb1 ( size_t  i1  )  const [inline]

Returns constant reference to all neighbors of node i1 of type 1.

Neighbors& dai::BipartiteGraph::nb1 ( size_t  i1  )  [inline]

Returns reference to all neighbors of node i1 of type 1.

const Neighbors& dai::BipartiteGraph::nb2 ( size_t  i2  )  const [inline]

Returns constant reference to all neighbors of node i2 of type 2.

Neighbors& dai::BipartiteGraph::nb2 ( size_t  i2  )  [inline]

Returns reference to all neighbors of node i2 of type 2.

template<typename EdgeInputIterator>
void dai::BipartiteGraph::construct ( size_t  nrNodes1,
size_t  nrNodes2,
EdgeInputIterator  begin,
EdgeInputIterator  end 
) [inline]

(Re)constructs BipartiteGraph from a range of edges.

Template Parameters:
EdgeInputIterator Iterator that iterates over instances of BipartiteGraph::Edge.
Parameters:
nrNodes1 The number of nodes of type 1.
nrNodes2 The number of nodes of type 2.
begin Points to the first edge.
end Points just beyond the last edge.

size_t dai::BipartiteGraph::addNode1 (  )  [inline]

Adds a node of type 1 without neighbors and returns the index of the added node.

size_t dai::BipartiteGraph::addNode2 (  )  [inline]

Adds a node of type 2 without neighbors and returns the index of the added node.

size_t dai::BipartiteGraph::add1 (  )  [inline]

Adds a node of type 1 without neighbors and returns the index of the added node.

Deprecated:
Please use dai::BipartiteGraph::addNode1() instead.

size_t dai::BipartiteGraph::add2 (  )  [inline]

Adds a node of type 2 without neighbors and returns the index of the added node.

Deprecated:
Please use dai::BipartiteGraph::addNode2() instead.

template<typename NodeInputIterator>
size_t dai::BipartiteGraph::addNode1 ( NodeInputIterator  begin,
NodeInputIterator  end,
size_t  sizeHint = 0 
) [inline]

Adds a node of type 1, with neighbors specified by a range of nodes of type 2.

Template Parameters:
NodeInputIterator Iterator that iterates over instances of size_t.
Parameters:
begin Points to the first index of the nodes of type 2 that should become neighbors of the added node.
end Points just beyond the last index of the nodes of type 2 that should become neighbors of the added node.
sizeHint For improved efficiency, the size of the range may be specified by sizeHint.
Returns:
Index of the added node.

template<typename NodeInputIterator>
size_t dai::BipartiteGraph::addNode2 ( NodeInputIterator  begin,
NodeInputIterator  end,
size_t  sizeHint = 0 
) [inline]

Adds a node of type 2, with neighbors specified by a range of nodes of type 1.

Template Parameters:
NodeInputIterator Iterator that iterates over instances of size_t.
Parameters:
begin Points to the first index of the nodes of type 1 that should become neighbors of the added node.
end Points just beyond the last index of the nodes of type 1 that should become neighbors of the added node.
sizeHint For improved efficiency, the size of the range may be specified by sizeHint.
Returns:
Index of the added node.

template<typename NodeInputIterator>
size_t dai::BipartiteGraph::add1 ( NodeInputIterator  begin,
NodeInputIterator  end,
size_t  sizeHint = 0 
) [inline]

Adds a node of type 1, with neighbors specified by a range of nodes of type 2.

Deprecated:
Please use dai::BipartiteGraph::addNode1( NodeInputIterator, NodeInputIterator, size_t) instead.

template<typename NodeInputIterator>
size_t dai::BipartiteGraph::add2 ( NodeInputIterator  begin,
NodeInputIterator  end,
size_t  sizeHint = 0 
) [inline]

Adds a node of type 2, with neighbors specified by a range of nodes of type 1.

Deprecated:
Please use dai::BipartiteGraph::addNode2( NodeInputIterator, NodeInputIterator, size_t) instead.

void dai::BipartiteGraph::addEdge ( size_t  n1,
size_t  n2,
bool  check = true 
)

Adds an edge between node n1 of type 1 and node n2 of type 2.

If check == true, only adds the edge if it does not exist already.

void dai::BipartiteGraph::eraseNode1 ( size_t  n1  ) 

Removes node n1 of type 1 and all incident edges; indices of other nodes are changed accordingly.

void dai::BipartiteGraph::eraseNode2 ( size_t  n2  ) 

Removes node n2 of type 2 and all incident edges; indices of other nodes are changed accordingly.

void dai::BipartiteGraph::erase1 ( size_t  n1  )  [inline]

Removes node n1 of type 1 and all incident edges; indices of other nodes are changed accordingly.

Deprecated:
Please use dai::BipartiteGraph::eraseNode1(size_t) instead.

void dai::BipartiteGraph::erase2 ( size_t  n2  )  [inline]

Removes node n2 of type 2 and all incident edges; indices of other nodes are changed accordingly.

Deprecated:
Please use dai::BipartiteGraph::eraseNode2(size_t) instead.

void dai::BipartiteGraph::eraseEdge ( size_t  n1,
size_t  n2 
)

Removes edge between node n1 of type 1 and node n2 of type 2.

size_t dai::BipartiteGraph::nrNodes1 (  )  const [inline]

Returns number of nodes of type 1.

size_t dai::BipartiteGraph::nrNodes2 (  )  const [inline]

Returns number of nodes of type 2.

size_t dai::BipartiteGraph::nr1 (  )  const [inline]

Returns number of nodes of type 1.

Deprecated:
Please use dai::BipartiteGraph::nrNodes1() instead.

size_t dai::BipartiteGraph::nr2 (  )  const [inline]

Returns number of nodes of type 2.

Deprecated:
Please use dai::BipartiteGraph::nrNodes2() instead.

size_t dai::BipartiteGraph::nrEdges (  )  const [inline]

Calculates the number of edges, time complexity: O(nrNodes1()).

std::vector< size_t > dai::BipartiteGraph::delta1 ( size_t  n1,
bool  include = false 
) const

Calculates second-order neighbors (i.e., neighbors of neighbors) of node n1 of type 1.

If include == true, includes n1 itself, otherwise excludes n1.

std::vector< size_t > dai::BipartiteGraph::delta2 ( size_t  n2,
bool  include = false 
) const

Calculates second-order neighbors (i.e., neighbors of neighbors) of node n2 of type 2.

If include == true, includes n2 itself, otherwise excludes n2.

bool dai::BipartiteGraph::isConnected (  )  const

Returns true if the graph is connected.

bool dai::BipartiteGraph::isTree (  )  const

Returns true if the graph is a tree, i.e., if it is singly connected and connected.

void dai::BipartiteGraph::checkConsistency (  )  const

Checks internal consistency.

void dai::BipartiteGraph::printDot ( std::ostream &  os  )  const

Writes this BipartiteGraph to an output stream in GraphViz .dot syntax.

Member Data Documentation

std::vector<Neighbors> dai::BipartiteGraph::_nb1 [private]

Contains for each node of type 1 a vector of its neighbors.

std::vector<Neighbors> dai::BipartiteGraph::_nb2 [private]

Contains for each node of type 2 a vector of its neighbors.

The documentation for this class was generated from the following files:
Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1Region.png0000644000263000017630000000102411334764771017275 0ustar jorismkybPNG  IHDRr1PLTE`{tRNS@fIDATXQn 7pvB{01Њ-ڲH[!|8JV-|nk^$9tH2A0#e'Rwߒ]-+$GZ"w$mɺF̶aq^%a Ir+i,RuF2B dE eW5[H1;{1&w)%("!}K9e7prNKmtI'=adoUpN:lsBGʥ( RSfy\|q`]H_ZxlFE_?Ԍe&ra`$lG"]Vm_0'I^q⤓N:$ZHw%ckkc0임"dT 9~p_LH9@<$#mb2Ι3$ܑ6)B7əc2.+N񮜜\jӈVa'IENDB`libDAI-0.2.4/doc/html/classdai_1_1PropertySet.html0000644000263000017630000007724711334764771020556 0ustar jorismkyb libDAI: dai::PropertySet Class Reference

dai::PropertySet Class Reference

Represents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue). More...

#include <dai/properties.h>

List of all members.

Public Member Functions

Constructors and destructors
 PropertySet ()
 Default constructor.
 PropertySet (const std::string &s)
 Construct from a string.
Setting property keys/values
PropertySet & Set (const PropertyKey &key, const PropertyValue &val)
 Sets a property (a key key with a corresponding value val).
PropertySet & Set (const PropertySet &newProps)
 Set properties according to newProps, overriding properties that already exist with new values.
PropertySet operator() (const PropertyKey &key, const PropertyValue &val) const
 Shorthand for (temporarily) adding properties.
template<typename ValueType>
PropertySet & setAsString (const PropertyKey &key, ValueType &val)
 Sets a property (a key key with a corresponding value val, which is first converted from ValueType to string).
template<typename ValueType>
void ConvertTo (const PropertyKey &key)
 Converts the type of the property value corresponding with key from string to ValueType (if necessary).
Queries
bool hasKey (const PropertyKey &key) const
 Check if a property with the given key is defined.
std::set< PropertyKey > keys () const
 Returns a set containing all keys.
const PropertyValue & Get (const PropertyKey &key) const
 Gets the value corresponding to key.
template<typename ValueType>
ValueType GetAs (const PropertyKey &key) const
 Gets the value corresponding to key, cast to ValueType.
template<typename ValueType>
ValueType getStringAs (const PropertyKey &key) const
 Gets the value corresponding to key, cast to ValueType, converting from a string if necessary.

Friends

Input/output
std::ostream & operator<< (std::ostream &os, const PropertySet &ps)
 Writes a PropertySet object to an output stream.
std::istream & operator>> (std::istream &is, PropertySet &ps)
 Reads a PropertySet object from an input stream.

Detailed Description

Represents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue).

Properties are used for specifying parameters of algorithms in a convenient way, where the values of the parameters can be of different types (e.g., strings, doubles, integers, enums). A PropertySet is an attempt to mimic the functionality of a Python dictionary object in C++, using the boost::any class.

A PropertySet can be converted to and from a string, using the following format:

[key1=val1,key2=val2,...,keyn=valn]

That is,

  • the whole PropertySet is wrapped in square brackets ("[", "]")
  • all properties in the PropertySet are seperated by a comma (",")
  • each Property consists of:
    • the name of the key
    • an equality sign ("=")
    • its value (represented as a string)

Also, a PropertySet provides functionality for converting the representation of individual values from some arbitrary type to and from std::string.

Note:
Not all types are automatically supported; if a type is unknown, an UNKNOWN_PROPERTY_TYPE exception is thrown. Adding support for a new type can be done in the body of the operator<<(std::ostream &, const Property &).
Examples:

example.cpp, example_sprinkler_em.cpp, and example_sprinkler_gibbs.cpp.

Constructor & Destructor Documentation

dai::PropertySet::PropertySet (  )  [inline]

Default constructor.

dai::PropertySet::PropertySet ( const std::string &  s  )  [inline]

Construct from a string.

Parameters:
s string in the format "[key1=val1,key2=val2,...,keyn=valn]"

Member Function Documentation

PropertySet& dai::PropertySet::Set ( const PropertyKey &  key,
const PropertyValue &  val 
) [inline]

Sets a property (a key key with a corresponding value val).

Examples:
example.cpp, example_sprinkler_em.cpp, and example_sprinkler_gibbs.cpp.

PropertySet& dai::PropertySet::Set ( const PropertySet &  newProps  )  [inline]

Set properties according to newProps, overriding properties that already exist with new values.

PropertySet dai::PropertySet::operator() ( const PropertyKey &  key,
const PropertyValue &  val 
) const [inline]

Shorthand for (temporarily) adding properties.

Example:
PropertySet p()("method","BP")("verbose",1)("tol",1e-9)

template<typename ValueType>
PropertySet& dai::PropertySet::setAsString ( const PropertyKey &  key,
ValueType &  val 
) [inline]

Sets a property (a key key with a corresponding value val, which is first converted from ValueType to string).

The implementation makes use of boost::lexical_cast.

Template Parameters:
ValueType Type from which the value should be cast
Exceptions:
IMPOSSIBLE_TYPECAST if the type cast cannot be done

template<typename ValueType>
void dai::PropertySet::ConvertTo ( const PropertyKey &  key  )  [inline]

Converts the type of the property value corresponding with key from string to ValueType (if necessary).

The implementation makes use of boost::lexical_cast

Template Parameters:
ValueType Type to which the value should be cast
Exceptions:
IMPOSSIBLE_TYPECAST if the type cast cannot be done

bool dai::PropertySet::hasKey ( const PropertyKey &  key  )  const [inline]

Check if a property with the given key is defined.

std::set<PropertyKey> dai::PropertySet::keys (  )  const [inline]

Returns a set containing all keys.

const PropertyValue& dai::PropertySet::Get ( const PropertyKey &  key  )  const [inline]

Gets the value corresponding to key.

Exceptions:
OBJECT_NOT_FOUND if the key cannot be found in *this

template<typename ValueType>
ValueType dai::PropertySet::GetAs ( const PropertyKey &  key  )  const [inline]

Gets the value corresponding to key, cast to ValueType.

Template Parameters:
ValueType Type to which the value should be cast
Exceptions:
OBJECT_NOT_FOUND if the key cannot be found in *this
IMPOSSIBLE_TYPECAST if the type cast cannot be done

template<typename ValueType>
ValueType dai::PropertySet::getStringAs ( const PropertyKey &  key  )  const [inline]

Gets the value corresponding to key, cast to ValueType, converting from a string if necessary.

If the type of the value is already equal to ValueType, no conversion is done. Otherwise, the type of the value should be a std::string, in which case boost::lexical_cast is used to convert this to ValueType.

Template Parameters:
ValueType Type to which the value should be cast/converted
Exceptions:
OBJECT_NOT_FOUND if the key cannot be found in *this
IMPOSSIBLE_TYPECAST if the type cast cannot be done

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os,
const PropertySet &  ps 
) [friend]

Writes a PropertySet object to an output stream.

It uses the format "[key1=val1,key2=val2,...,keyn=valn]".

Note:
Only a subset of all possible types is supported (see the implementation of this function). Adding support for more types has to be done by hand.
Exceptions:
UNKNOWN_PROPERTY_TYPE if the type of a property value is not supported.

std::istream& operator>> ( std::istream &  is,
PropertySet &  ps 
) [friend]

Reads a PropertySet object from an input stream.

It expects a string in the format "[key1=val1,key2=val2,...,keyn=valn]". Values are stored as strings.

Exceptions:
MALFORMED_PROPERTY if the string is not in the expected format

The documentation for this class was generated from the following file:
Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_0x74.html0000644000263000017630000001526411334764771016673 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- t -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1BP__dual_1_1__edges__t.html0000644000263000017630000000502111334764771022547 0ustar jorismkyb libDAI: dai::BP_dual::_edges_t< T > Struct Template Reference

dai::BP_dual::_edges_t< T > Struct Template Reference

Convenience label for storing edge properties. More...

#include <dai/bp_dual.h>

Inherits std::vector< T >.

List of all members.

Detailed Description

template<class T>
struct dai::BP_dual::_edges_t< T >

Convenience label for storing edge properties.
The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/clustergraph_8h-source.html0000644000263000017630000012350311334764771020475 0ustar jorismkyb libDAI: include/dai/clustergraph.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/examples.html0000644000263000017630000000342211334764771015710 0ustar jorismkyb libDAI: Examples

Examples

Here is a list of all examples:
Generated on Thu Feb 11 12:26:08 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_5.png0000644000263000017630000000241311334764771015100 0ustar jorismkybPNG  IHDR $K0PLTEppp```PPP@@@000 4tRNS@fIDATXW]lUfv~vO%vTJ0Z4v F~NՠAAh!\P>4P #1>фmф'|lkşܙvggvn_2ν{9n຅4>>~l5TxynhIp0:3+bvbP=*go*>nrd뉦ډFD\pM$:؄դB7Lh!$Q;s.QB+ň뿚'm,5EqrҖ*ɯzqُ'Ղ롇[j5K''G"ߡ:\K."'A=wcn<حeedTECdEe#m.m 1K[Y \.rf\XUB/$$BLݓZHR)Pi>.≠5O Ϧj\癐fllcxMcxTg)))c7C^T1zT[lbm2ݎ{eAbq܁Yn+E(9t'Y_p6a DɊwG۩| Ћ> B1SfBt}u@H:*n&Ϣ7p{pM:w;Ff>N,xe6:=QYR џaj(_83ߌItQB*p`m$ANCwi<'va* kBߘ"j ٕB_ 6N@]eyUA6')7iU]k MQ$yWuҁSmr5y [sLAe.EzMWV ?:|υIENDB`libDAI-0.2.4/doc/html/classdai_1_1ExactInf.html0000644000263000017630000012263411334764771017746 0ustar jorismkyb libDAI: dai::ExactInf Class Reference

dai::ExactInf Class Reference

Exact inference algorithm using brute force enumeration (mainly useful for testing purposes). More...

#include <dai/exactinf.h>

Inheritance diagram for dai::ExactInf:

dai::DAIAlg< GRM > dai::InfAlg

List of all members.

Public Member Functions

Constructors/destructors
 ExactInf ()
 Default constructor.
 ExactInf (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts.
General InfAlg interface
virtual ExactInf * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
virtual std::string identify () const
 Identifies itself for logging purposes.
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable.
virtual Factor belief (const VarSet &vs) const
 Returns the (approximate) marginal probability distribution of a set of variables.
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i.
virtual Factor beliefF (size_t I) const
 Returns the (approximate) marginal probability distribution of the variables on which factor I depends.
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).
virtual void init ()
 Initializes all data structures of the approximate inference algorithm.
virtual void init (const VarSet &)
 Initializes all data structures corresponding to some set of variables.
virtual Real run ()
 Runs the approximate inference algorithm.
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration.
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph).
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm.
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet.
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".
Additional interface specific for JTree
Factor calcMarginal (const VarSet &vs) const
 Calculates marginal probability distribution for variables vs.

Public Attributes

struct dai::ExactInf::Properties props

Static Public Attributes

static const char * Name = "EXACT"
 Name of this inference algorithm.

Private Member Functions

void construct ()
 Helper function for constructors.

Private Attributes

std::vector< Factor > _beliefsV
 All single variable marginals.
std::vector< Factor > _beliefsF
 All factor variable marginals.
Real _logZ
 Logarithm of partition sum.

Classes

struct  Properties
 Parameters for ExactInf. More...

Detailed Description

Exact inference algorithm using brute force enumeration (mainly useful for testing purposes).

Inference is done simply by multiplying all factors together into one large factor, and then calculating marginals and partition sum from the product.

Note:
This inference method can easily exhaust all available memory; in that case, one may try the JTree class instead.

Constructor & Destructor Documentation

dai::ExactInf::ExactInf (  )  [inline]

Default constructor.

dai::ExactInf::ExactInf ( const FactorGraph &  fg,
const PropertySet &  opts 
) [inline]

Construct from FactorGraph fg and PropertySet opts.

Parameters:
opts Parameters
See also:
Properties

Member Function Documentation

virtual ExactInf* dai::ExactInf::clone (  )  const [inline, virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Implements dai::InfAlg.

string dai::ExactInf::identify (  )  const [virtual]

Identifies itself for logging purposes.

Implements dai::InfAlg.

virtual Factor dai::ExactInf::belief ( const Var &  v  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of a variable.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

Factor dai::ExactInf::belief ( const VarSet &  vs  )  const [virtual]

Returns the (approximate) marginal probability distribution of a set of variables.

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported.
BELIEF_NOT_AVAILABLE if the requested belief cannot be calculated with this algorithm.

Implements dai::InfAlg.

virtual Factor dai::ExactInf::beliefV ( size_t  i  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of the variable with index i.

For some approximate inference algorithms, using beliefV() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

virtual Factor dai::ExactInf::beliefF ( size_t  I  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of the variables on which factor I depends.

For some approximate inference algorithms, using beliefF() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

vector< Factor > dai::ExactInf::beliefs (  )  const [virtual]

Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.

Note:
Before this method is called, run() should have been called.

Implements dai::InfAlg.

virtual Real dai::ExactInf::logZ (  )  const [inline, virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

void dai::ExactInf::init (  )  [virtual]

Initializes all data structures of the approximate inference algorithm.

Note:
This method should be called at least once before run() is called.

Implements dai::InfAlg.

virtual void dai::ExactInf::init ( const VarSet &  vs  )  [inline, virtual]

Initializes all data structures corresponding to some set of variables.

This method can be used to do a partial initialization after a part of the factor graph has changed. Instead of initializing all data structures, it only initializes those involving the variables in vs.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

Real dai::ExactInf::run (  )  [virtual]

Runs the approximate inference algorithm.

Note:
Before run() is called the first time, init() should have been called.

Implements dai::InfAlg.

virtual Real dai::ExactInf::maxDiff (  )  const [inline, virtual]

Returns maximum difference between single variable beliefs in the last iteration.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

virtual size_t dai::ExactInf::Iterations (  )  const [inline, virtual]

Returns number of iterations done (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

void dai::ExactInf::setProperties ( const PropertySet &  opts  )  [virtual]

Set parameters of this inference algorithm.

The parameters are set according to the PropertySet opts. The values can be stored either as std::string or as the type of the corresponding MF::props member.

Implements dai::InfAlg.

PropertySet dai::ExactInf::getProperties (  )  const [virtual]

Returns parameters of this inference algorithm converted into a PropertySet.

Implements dai::InfAlg.

string dai::ExactInf::printProperties (  )  const [virtual]

Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Implements dai::InfAlg.

Factor dai::ExactInf::calcMarginal ( const VarSet &  vs  )  const

Calculates marginal probability distribution for variables vs.

Note:
The complexity of this calculation is exponential in the number of variables.

void dai::ExactInf::construct (  )  [private]

Helper function for constructors.

Member Data Documentation

const char * dai::ExactInf::Name = "EXACT" [static]

Name of this inference algorithm.

std::vector<Factor> dai::ExactInf::_beliefsV [private]

All single variable marginals.

std::vector<Factor> dai::ExactInf::_beliefsF [private]

All factor variable marginals.

Real dai::ExactInf::_logZ [private]

Logarithm of partition sum.

The documentation for this class was generated from the following files:
Generated on Thu Feb 11 12:26:04 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/lc_8h-source.html0000644000263000017630000006371211334764771016375 0ustar jorismkyb libDAI: include/dai/lc.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1IndexFor-members.html0000644000263000017630000001025311334764771021404 0ustar jorismkyb libDAI: Member List

dai::IndexFor Member List

This is the complete list of members for dai::IndexFor, including all inherited members.

_indexdai::IndexFor [private]
_rangesdai::IndexFor [private]
_statedai::IndexFor [private]
_sumdai::IndexFor [private]
IndexFor()dai::IndexFor [inline]
IndexFor(const VarSet &indexVars, const VarSet &forVars)dai::IndexFor [inline]
operator size_t() const dai::IndexFor [inline]
operator++()dai::IndexFor [inline]
operator++(int)dai::IndexFor [inline]
reset()dai::IndexFor [inline]
valid() const dai::IndexFor [inline]

Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_12.png0000644000263000017630000000042111334764771015153 0ustar jorismkybPNG  IHDR/0PLTEppp```PPP@@@000 4tRNS@fIDATc` !=S$Ŗᕀ$*Vb%k0@P@u!t@"20uYXtXZZS#Vf>Mekg|X! tf6`x bQ`˄z3]!$Uf߄IENDB`libDAI-0.2.4/doc/html/form_37.png0000644000263000017630000000031711334764771015166 0ustar jorismkybPNG  IHDR <0PLTEppp```PPP@@@000 4tRNS@fMIDATc`@P_!”g`h8100}tf> (`ށ RUIENDB`libDAI-0.2.4/doc/html/classdai_1_1Gibbs-members.html0000644000263000017630000003135011334764771020715 0ustar jorismkyb libDAI: Member List

dai::Gibbs Member List

This is the complete list of members for dai::Gibbs, including all inherited members.

_count_t typedefdai::Gibbs [private]
_factor_countsdai::Gibbs [private]
_sample_countdai::Gibbs [private]
_statedai::Gibbs [private]
_state_t typedefdai::Gibbs [private]
_var_countsdai::Gibbs [private]
backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
belief(const Var &v) const dai::Gibbs [inline, virtual]
belief(const VarSet &vs) const dai::Gibbs [virtual]
beliefF(size_t I) const dai::Gibbs [virtual]
beliefs() const dai::Gibbs [virtual]
beliefV(size_t i) const dai::Gibbs [virtual]
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clone() const dai::Gibbs [inline, virtual]
construct()dai::Gibbs [private]
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
getFactorEntry(size_t I)dai::Gibbs [inline, private]
getFactorEntryDiff(size_t I, size_t i)dai::Gibbs [inline, private]
getGibbsState(const FactorGraph &fg, size_t iters)dai::Gibbs [related]
getProperties() const dai::Gibbs [virtual]
getVarDist(size_t i)dai::Gibbs [private]
Gibbs()dai::Gibbs [inline]
Gibbs(const FactorGraph &fg, const PropertySet &opts)dai::Gibbs [inline]
identify() const dai::Gibbs [inline, virtual]
init()dai::Gibbs [virtual]
init(const VarSet &)dai::Gibbs [inline, virtual]
Iterations() const dai::Gibbs [inline, virtual]
logZ() const dai::Gibbs [inline, virtual]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
maxDiff() const dai::Gibbs [inline, virtual]
Namedai::Gibbs [static]
printProperties() const dai::Gibbs [virtual]
props (defined in dai::Gibbs)dai::Gibbs
randomizeState()dai::Gibbs
resampleVar(size_t i)dai::Gibbs [inline, private]
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
run()dai::Gibbs [virtual]
setProperties(const PropertySet &opts)dai::Gibbs [virtual]
state()dai::Gibbs [inline]
state() const dai::Gibbs [inline]
updateCounts()dai::Gibbs [private]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_0x69.html0000644000263000017630000003177411334764771016703 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- i -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/exactinf_8h-source.html0000644000263000017630000004622311334764771017576 0ustar jorismkyb libDAI: include/dai/exactinf.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/exceptions_8h.html0000644000263000017630000003042211334764771016652 0ustar jorismkyb libDAI: include/dai/exceptions.h File Reference

include/dai/exceptions.h File Reference

Defines the Exception class and macros for throwing exceptions and doing assertions. More...

#include <exception>
#include <stdexcept>
#include <string>
#include <iostream>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::Exception
 Error handling in libDAI is done by throwing an instance of the Exception class. More...

Defines

#define DAI_QUOTE(x)   #x
 Used by DAI_THROW.
#define DAI_TOSTRING(x)   DAI_QUOTE(x)
 Used by DAI_THROW.
#define DAI_THROW(cod)   throw dai::Exception(dai::Exception::cod, std::string(__FILE__ ", line " DAI_TOSTRING(__LINE__)))
 Macro that simplifies throwing an exception with a useful default error message.
#define DAI_THROWE(cod, msg)   throw dai::Exception(dai::Exception::cod, std::string(__FILE__ ", line " DAI_TOSTRING(__LINE__)), msg)
 Macro that simplifies throwing an exception with a user-defined error message.
#define DAI_ASSERT(condition)   ((condition) ? ((void)0) : DAI_THROWE(ASSERTION_FAILED, std::string("Assertion \"" #condition "\" failed")))
 Assertion mechanism, similar to the standard assert() macro. It is always active, even if NDEBUG is defined.
#define DAI_DEBASSERT(x)   do {DAI_ASSERT(x);} while(0)
 Assertion mechanism similar to DAI_ASSERT which is only active if DAI_DEBUG is defined.

Detailed Description

Defines the Exception class and macros for throwing exceptions and doing assertions.

Define Documentation

#define DAI_QUOTE ( x   )     #x

Used by DAI_THROW.

#define DAI_TOSTRING ( x   )     DAI_QUOTE(x)

Used by DAI_THROW.

#define DAI_THROW ( cod   )     throw dai::Exception(dai::Exception::cod, std::string(__FILE__ ", line " DAI_TOSTRING(__LINE__)))

Macro that simplifies throwing an exception with a useful default error message.

The error message consists of a description of the exception, the source code file and line number where the exception has been thrown.

Parameters:
cod Corresponds to one of the enum values of dai::Exception::Code
Example:
  DAI_THROW(NOT_IMPLEMENTED);

#define DAI_THROWE ( cod,
msg   )     throw dai::Exception(dai::Exception::cod, std::string(__FILE__ ", line " DAI_TOSTRING(__LINE__)), msg)

Macro that simplifies throwing an exception with a user-defined error message.

Parameters:
cod Corresponds to one of the enum values of dai::Exception::Code
msg Detailed error message that will be written to std::cerr.
Example:
  DAI_THROWE(NOT_IMPLEMENTED,"Detailed error message");

#define DAI_ASSERT ( condition   )     ((condition) ? ((void)0) : DAI_THROWE(ASSERTION_FAILED, std::string("Assertion \"" #condition "\" failed")))

Assertion mechanism, similar to the standard assert() macro. It is always active, even if NDEBUG is defined.

Examples:
example_bipgraph.cpp, example_permute.cpp, and example_varset.cpp.

#define DAI_DEBASSERT ( x   )     do {DAI_ASSERT(x);} while(0)

Assertion mechanism similar to DAI_ASSERT which is only active if DAI_DEBUG is defined.

Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1fo__plog0p-members.html0000644000263000017630000000360211334764771022131 0ustar jorismkyb libDAI: Member List

dai::fo_plog0p< T > Member List

This is the complete list of members for dai::fo_plog0p< T >, including all inherited members.

operator()(const T &p) const dai::fo_plog0p< T > [inline]

Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1fo__max-members.html0000644000263000017630000000360011334764771021513 0ustar jorismkyb libDAI: Member List

dai::fo_max< T > Member List

This is the complete list of members for dai::fo_max< T >, including all inherited members.

operator()(const T &x, const T &y) const dai::fo_max< T > [inline]

Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_130.png0000644000263000017630000000304211334764771015236 0ustar jorismkybPNG  IHDR[$~0PLTEppp```PPP@@@000 4tRNS@fIDATXmTUu\l#+Z^XTv KR1&BFW j6ŬreM/9.з>)}n4 ĠU 1yܹ{Ｘm林;`ZjYm#cuWn9YjdUïTr?;bPrr&bz(q*R- DPyVnx5gPsPH\HLjW}Jo#w[X? n2Fu;ŕbE<\2J  gq`ը1NVұh<Y̢ÙȸX!7J҈jfel׬~ښ%bDe5`wR}n`wd˶g&8?K`o˚Cwvlr `i Q':6[맱A'aM ^&nz|Flx0&Ob`XX8 m؋oM ykhW=]b7c# CKW& i?:"` p=šʓ£*|7 CF&r9l2$\bM7Nb 0.e[5Jt?-x joa-\4%qrxM5Nz \y̕~ԩ;yFT/M.kC4I×>@k>kUuVxSiU9jކ?+]Z LdLoIENDB`libDAI-0.2.4/doc/html/classdai_1_1FRegion.html0000644000263000017630000002147111334764771017573 0ustar jorismkyb libDAI: dai::FRegion Class Reference

dai::FRegion Class Reference

An FRegion is a factor with a counting number. More...

#include <dai/regiongraph.h>

Inheritance diagram for dai::FRegion:

dai::TFactor< T >

List of all members.

Public Member Functions

 FRegion ()
 Default constructor.
 FRegion (const Factor &x, Real c)
 Constructs from a factor and a counting number.
const Real & c () const
 Returns constant reference to counting number.
Real & c ()
 Returns reference to counting number.

Private Attributes

Real _c
 Counting number.

Detailed Description

An FRegion is a factor with a counting number.

Constructor & Destructor Documentation

dai::FRegion::FRegion (  )  [inline]

Default constructor.

dai::FRegion::FRegion ( const Factor &  x,
Real  c 
) [inline]

Constructs from a factor and a counting number.

Member Function Documentation

const Real& dai::FRegion::c (  )  const [inline]

Returns constant reference to counting number.

Real& dai::FRegion::c (  )  [inline]

Returns reference to counting number.

Member Data Documentation

Real dai::FRegion::_c [private]

Counting number.

The documentation for this class was generated from the following file:
Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/bbp_8h-source.html0000644000263000017630000016127511334764771016545 0ustar jorismkyb libDAI: include/dai/bbp.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1BP-members.html0000644000263000017630000003746111334764771020201 0ustar jorismkyb libDAI: Member List

dai::BP Member List

This is the complete list of members for dai::BP, including all inherited members.

_edge2lutdai::BP [protected]
_edgesdai::BP [protected]
_itersdai::BP [protected]
_lutdai::BP [protected]
_maxdiffdai::BP [protected]
_sentMessagesdai::BP [protected]
backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
belief(const Var &v) const dai::BP [inline, virtual]
belief(const VarSet &vs) const dai::BP [virtual]
beliefF(size_t I) const dai::BP [virtual]
beliefs() const dai::BP [virtual]
beliefV(size_t i) const dai::BP [virtual]
BP()dai::BP [inline]
BP(const FactorGraph &fg, const PropertySet &opts)dai::BP [inline]
BP(const BP &x)dai::BP [inline]
calcBeliefF(size_t I, Prob &p) const dai::BP [inline, protected, virtual]
calcBeliefV(size_t i, Prob &p) const dai::BP [protected, virtual]
calcIncomingMessageProduct(size_t I, bool without_i, size_t i) const dai::BP [protected, virtual]
calcNewMessage(size_t i, size_t _I)dai::BP [protected, virtual]
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clearSentMessages()dai::BP [inline]
clone() const dai::BP [inline, virtual]
construct()dai::BP [protected, virtual]
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
findMaximum() const dai::BP
findMaxResidual(size_t &i, size_t &_I)dai::BP [protected]
getProperties() const dai::BP [virtual]
getSentMessages() const dai::BP [inline]
identify() const dai::BP [virtual]
ind_t typedefdai::BP [protected]
index(size_t i, size_t _I) const dai::BP [inline, protected]
index(size_t i, size_t _I)dai::BP [inline, protected]
init()dai::BP [virtual]
init(const VarSet &ns)dai::BP [virtual]
Iterations() const dai::BP [inline, virtual]
logZ() const dai::BP [virtual]
LutType typedefdai::BP [protected]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
maxDiff() const dai::BP [inline, virtual]
message(size_t i, size_t _I) const dai::BP [inline, protected]
message(size_t i, size_t _I)dai::BP [inline, protected]
Namedai::BP [static]
newMessage(size_t i, size_t _I) const dai::BP [inline, protected]
newMessage(size_t i, size_t _I)dai::BP [inline, protected]
operator=(const BP &x)dai::BP [inline]
printProperties() const dai::BP [virtual]
props (defined in dai::BP)dai::BP
recordSentMessagesdai::BP
residual(size_t i, size_t _I) const dai::BP [inline, protected]
residual(size_t i, size_t _I)dai::BP [inline, protected]
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
run()dai::BP [virtual]
setProperties(const PropertySet &opts)dai::BP [virtual]
updateMessage(size_t i, size_t _I)dai::BP [protected]
updateResidual(size_t i, size_t _I, Real r)dai::BP [protected]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_31.png0000644000263000017630000000034011334764771015154 0ustar jorismkybPNG  IHDRC"[0PLTEppp```PPP@@@000 4tRNS@f^IDATc`@v\8 fiP?ac20<`T c`-pl`$w2,f.8p!9-aMbIENDB`libDAI-0.2.4/doc/html/form_3.png0000644000263000017630000000026011334764771015074 0ustar jorismkybPNG  IHDR FZ0PLTEppp```PPP@@@000 4tRNS@f.IDATc`0sL')y0UQrB}Ln)3zKIENDB`libDAI-0.2.4/doc/html/classdai_1_1BP.png0000644000263000017630000000160011334764771016353 0ustar jorismkybPNG  IHDR PLTE`{tRNS@fIDATxmn0 `; ]`؀$Ӧ3kEmb4(rQ򽼅c: h`]HH@L-DZ#y"{)$,,aDa1R:A',eO B=!Szz: D;8 Lhw e^4?`@6!!-6R `x^{ | L 4@hB  4@hip&"eA]t6%Ddk1AR libDAI: Member List

dai::PropertySet Member List

This is the complete list of members for dai::PropertySet, including all inherited members.

ConvertTo(const PropertyKey &key)dai::PropertySet [inline]
Get(const PropertyKey &key) const dai::PropertySet [inline]
GetAs(const PropertyKey &key) const dai::PropertySet [inline]
getStringAs(const PropertyKey &key) const dai::PropertySet [inline]
hasKey(const PropertyKey &key) const dai::PropertySet [inline]
keys() const dai::PropertySet [inline]
operator()(const PropertyKey &key, const PropertyValue &val) const dai::PropertySet [inline]
operator<<(std::ostream &os, const PropertySet &ps)dai::PropertySet [friend]
operator>>(std::istream &is, PropertySet &ps)dai::PropertySet [friend]
PropertySet()dai::PropertySet [inline]
PropertySet(const std::string &s)dai::PropertySet [inline]
Set(const PropertyKey &key, const PropertyValue &val)dai::PropertySet [inline]
Set(const PropertySet &newProps)dai::PropertySet [inline]
setAsString(const PropertyKey &key, ValueType &val)dai::PropertySet [inline]

Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/namespaces.html0000644000263000017630000000312511334764771016211 0ustar jorismkyb libDAI: Namespace Index

Namespace List

Here is a list of all documented namespaces with brief descriptions:
daiNamespace for libDAI
Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_128.png0000644000263000017630000000061711334764771015252 0ustar jorismkybPNG  IHDR;Xc0PLTEppp```PPP@@@000 4tRNS@f IDAT(c`plv'h@& # 14C5pNP@eғ$c!k T<DyB07!b Z̀ѡ d>5(RG 3( ܓ>2ipO`ة``eR4mC{C&R# :0n`:'eb t+C0X40`QrT&rвb##fF)B2} IENDB`libDAI-0.2.4/doc/html/form_125.png0000644000263000017630000000124411334764771015244 0ustar jorismkybPNG  IHDRr#!C0PLTEppp```PPP@@@000 4tRNS@f"IDAT8TMkAL$9( %NEE@!Ajl xEQ % "xSA.ݘ#bSՓZۈǼü~^Ww/BoZ38*)C[rdmpZ2A>G֐Nn"u,'S}y9*v;AtsÐs/9}td /׈f`$!g\>'NS)$=T+W\.8wt%O3֣-rWiuZJ]Qi.aƭEg^$U]Ҟp+L g)?~tU libDAI: include/dai/exceptions.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/fbp_8h-source.html0000644000263000017630000003426011334764771016542 0ustar jorismkyb libDAI: include/dai/fbp.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_93.png0000644000263000017630000000061311334764771015167 0ustar jorismkybPNG  IHDR` o*0PLTEppp```PPP@@@000 4tRNS@f IDAT(c` 0CL JXPt&@X1ճX@)sp 2%5qlP D305h%10eaXPkf[%h>0#PCCJBC,cihcHx8&0L`hgH`r\%ә=a%@ LOX֏ \r fΜisF  L bp`H@a[(B),,& O.PIENDB`libDAI-0.2.4/doc/html/functions_0x67.html0000644000263000017630000002042111334764771016664 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- g -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1IndexFor.html0000644000263000017630000004114411334764771017757 0ustar jorismkyb libDAI: dai::IndexFor Class Reference

dai::IndexFor Class Reference

Tool for looping over the states of several variables. More...

#include <dai/index.h>

List of all members.

Public Member Functions

 IndexFor ()
 Default constructor.
 IndexFor (const VarSet &indexVars, const VarSet &forVars)
 Construct IndexFor object from indexVars and forVars.
IndexFor & reset ()
 Resets the state.
 operator size_t () const
 Conversion to size_t: returns linear index of the current state of indexVars.
IndexFor & operator++ ()
 Increments the current state of forVars (prefix).
void operator++ (int)
 Increments the current state of forVars (postfix).
bool valid () const
 Returns true if the current state is valid.

Private Attributes

long _index
 The current linear index corresponding to the state of indexVars.
std::vector< long > _sum
 For each variable in forVars, the amount of change in _index.
std::vector< size_t > _state
 For each variable in forVars, the current state.
std::vector< size_t > _ranges
 For each variable in forVars, its number of possible values.

Detailed Description

Tool for looping over the states of several variables.

The class IndexFor is an important tool for indexing Factor entries. Its usage can best be explained by an example. Assume indexVars, forVars are both VarSet 's. Then the following code: 

      IndexFor i( indexVars, forVars );
      size_t iter = 0;
      for( ; i.valid(); i++, iter++ ) {
          cout << "State of forVars: " << calcState( forVars, iter ) << "; ";
          cout << "state of indexVars: " << calcState( indexVars, long(i) ) << endl;
      }
loops over all joint states of the variables in forVars, and (long)i equals the linear index of the corresponding state of indexVars, where the variables in indexVars that are not in forVars assume their zero'th value.
Idea:
Optimize all indices as follows: keep a cache of all (or only relatively small) indices that have been computed (use a hash). Then, instead of computing on the fly, use the precomputed ones. Here the labels of the variables don't matter, but the ranges of the variables do.

Constructor & Destructor Documentation

dai::IndexFor::IndexFor (  )  [inline]

Default constructor.

dai::IndexFor::IndexFor ( const VarSet &  indexVars,
const VarSet &  forVars 
) [inline]

Construct IndexFor object from indexVars and forVars.

Member Function Documentation

IndexFor& dai::IndexFor::reset (  )  [inline]

Resets the state.

dai::IndexFor::operator size_t (  )  const [inline]

Conversion to size_t: returns linear index of the current state of indexVars.

IndexFor& dai::IndexFor::operator++ (  )  [inline]

Increments the current state of forVars (prefix).

void dai::IndexFor::operator++ ( int   )  [inline]

Increments the current state of forVars (postfix).

bool dai::IndexFor::valid (  )  const [inline]

Returns true if the current state is valid.

Member Data Documentation

long dai::IndexFor::_index [private]

The current linear index corresponding to the state of indexVars.

std::vector<long> dai::IndexFor::_sum [private]

For each variable in forVars, the amount of change in _index.

std::vector<size_t> dai::IndexFor::_state [private]

For each variable in forVars, the current state.

std::vector<size_t> dai::IndexFor::_ranges [private]

For each variable in forVars, its number of possible values.

The documentation for this class was generated from the following file:
Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1fo__inv-members.html0000644000263000017630000000356011334764771021527 0ustar jorismkyb libDAI: Member List

dai::fo_inv< T > Member List

This is the complete list of members for dai::fo_inv< T >, including all inherited members.

operator()(const T &x) const dai::fo_inv< T > [inline]

Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_9.png0000644000263000017630000000352611334764771015112 0ustar jorismkybPNG  IHDR&2!0PLTEppp```PPP@@@000 4tRNS@fIDATXYklU>؝ngELQG+HI[6%L& 1` +(ʂ&Ę66D,1<};mĕ}s>Ιfj}(§TB<h*4e•r|p ,8H_U֟rI!eVv Fhee"xRu7gC?fre}i;JUxtctGӴZxRVk%Ǻ2m.I1{8COS;N>!TIaX6M!rY6q-5ki8BܛH`@yŽ:o!s XG{vs7^b;bE#$h 4 e= D`U d^q)8*B J2EHN''(aτ4E/ٳ h%3rXzRn`s  {CvSaeFxF·lo+env=s$yh=MGU1EeC GcU8=;ԙuӕ`lpI+. S2k;<UPB/B6=O5,QUgOX!"5y3"$y;[۔qX8r. ж libDAI: Class Members - Functions
 

- t -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1fo__exp.html0000644000263000017630000000710311334764771020074 0ustar jorismkyb libDAI: dai::fo_exp< T > Struct Template Reference

dai::fo_exp< T > Struct Template Reference

Function object that takes the exponent. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &x) const
 Returns exp(x).

Detailed Description

template<typename T>
struct dai::fo_exp< T >

Function object that takes the exponent.

Member Function Documentation

template<typename T>
T dai::fo_exp< T >::operator() ( const T &  x  )  const [inline]

Returns exp(x).

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1TreeEP_1_1Properties.html0000644000263000017630000002060011334764771022313 0ustar jorismkyb libDAI: dai::TreeEP::Properties Struct Reference

dai::TreeEP::Properties Struct Reference

Parameters for TreeEP. More...

#include <dai/treeep.h>

List of all members.

Public Member Functions

 DAI_ENUM (TypeType, ORG, ALT)
 Enumeration of possible choices for the tree.

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr).
size_t maxiter
 Maximum number of iterations.
Real tol
 Tolerance for convergence test.
TypeType type
 How to choose the tree.

Detailed Description

Parameters for TreeEP.

Member Function Documentation

dai::TreeEP::Properties::DAI_ENUM ( TypeType  ,
ORG  ,
ALT   
)

Enumeration of possible choices for the tree.

The two possibilities are:

  • ORG: take the maximum spanning tree where the weights are crude estimates of the mutual information between the nodes;
  • ALT: take the maximum spanning tree where the weights are upper bounds on the effective interaction strengths between pairs of nodes.

Member Data Documentation

size_t dai::TreeEP::Properties::verbose

Verbosity (amount of output sent to stderr).

size_t dai::TreeEP::Properties::maxiter

Maximum number of iterations.

Real dai::TreeEP::Properties::tol

Tolerance for convergence test.

TypeType dai::TreeEP::Properties::type

How to choose the tree.

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:07 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_134.png0000644000263000017630000000111611334764771015242 0ustar jorismkybPNG  IHDRӰ0PLTEppp```PPP@@@000 4tRNS@fIDAT8KPǿK4m&LDTD]Eh' tj]J+8?vpk*Ewy.~f"lG48Y-P; EʘY|7RA 8 An-`=CUA N+fJ'F7sC܂S?zNC5`bRW=a^y]oƃم;V[h`g0ɂ.y>h}P& *~;%5 Aj&ic4;sYк\&h^q8]Nw} v.jaWGƇV\JrLf7?-mf1CZwɷ:e&p#W8+d0)'8PFڨ3Y~g--gt#ý1NbF+C?Q>B_ER8IENDB`libDAI-0.2.4/doc/html/form_41.png0000644000263000017630000000057411334764771015166 0ustar jorismkybPNG  IHDRV~y0PLTEppp```PPP@@@000 4tRNS@fIDAT(c` 0V(U`rq7 _ļ@l0¦ "< PQN1,@e؊e!j Q;3- ]-PQx>/( Q[b1pb`d0lc`F@l3y~cud0\g` FO baG53*xtdP,CP"#V`@g у?,b);sIENDB`libDAI-0.2.4/doc/html/customdoxygen.css0000644000263000017630000002000711334764771016624 0ustar jorismkybBODY,H1,H2,H3,H4,H5,H6,P,CENTER,TD,TH,UL,DL,DIV { font-family: Geneva, Arial, Helvetica, sans-serif; } EM { color: #602020; } BODY,TD { font-size: 90%; } H1 { text-align: center; font-size: 160%; } H2 { font-size: 120%; } H3 { font-size: 100%; } CAPTION { font-weight: bold } DIV.qindex { width: 100%; background-color: #e8eef2; border: 1px solid #84b0c7; text-align: center; margin: 2px; padding: 2px; line-height: 140%; } DIV.navpath { width: 100%; background-color: #e8eef2; border: 1px solid #84b0c7; text-align: center; margin: 2px; padding: 2px; line-height: 140%; } DIV.navtab { background-color: #e8eef2; border: 1px solid #84b0c7; text-align: center; margin: 2px; margin-right: 15px; padding: 2px; } TD.navtab { font-size: 70%; } A.qindex { text-decoration: none; font-weight: bold; color: #1A419D; } A.qindex:visited { text-decoration: none; font-weight: bold; color: #1A419D } A.qindex:hover { text-decoration: none; background-color: #ddddff; } A.qindexHL { text-decoration: none; font-weight: bold; background-color: #6666cc; color: #ffffff; border: 1px double #9295C2; } A.qindexHL:hover { text-decoration: none; background-color: #6666cc; color: #ffffff; } A.qindexHL:visited { text-decoration: none; background-color: #6666cc; color: #ffffff } A.el { text-decoration: none; font-weight: bold } A.elRef { font-weight: bold } A.code:link { text-decoration: none; font-weight: normal; color: #0000FF } A.code:visited { text-decoration: none; font-weight: normal; color: #0000FF } A.codeRef:link { font-weight: normal; color: #0000FF } A.codeRef:visited { font-weight: normal; color: #0000FF } A:hover { text-decoration: none; background-color: #f2f2ff } DL.el { margin-left: -1cm } .fragment { font-family: monospace, fixed; font-size: 95%; } PRE.fragment { border: 1px solid #CCCCCC; background-color: #f5f5f5; margin-top: 4px; margin-bottom: 4px; margin-left: 2px; margin-right: 8px; padding-left: 6px; padding-right: 6px; padding-top: 4px; padding-bottom: 4px; } DIV.ah { background-color: black; font-weight: bold; color: #ffffff; margin-bottom: 3px; margin-top: 3px } DIV.groupHeader { margin-left: 16px; margin-top: 12px; margin-bottom: 6px; font-weight: bold; } DIV.groupText { margin-left: 16px; font-style: italic; font-size: 90% } BODY { background: white; color: black; margin-right: 20px; margin-left: 20px; } TD.indexkey { background-color: #e8eef2; font-weight: bold; padding-right : 10px; padding-top : 2px; padding-left : 10px; padding-bottom : 2px; margin-left : 0px; margin-right : 0px; margin-top : 2px; margin-bottom : 2px; border: 1px solid #CCCCCC; } TD.indexvalue { background-color: #e8eef2; font-style: italic; padding-right : 10px; padding-top : 2px; padding-left : 10px; padding-bottom : 2px; margin-left : 0px; margin-right : 0px; margin-top : 2px; margin-bottom : 2px; border: 1px solid #CCCCCC; } TR.memlist { background-color: #f0f0f0; } P.formulaDsp { text-align: center; } IMG.formulaDsp { } IMG.formulaInl { vertical-align: middle; } SPAN.keyword { color: #008000 } SPAN.keywordtype { color: #604020 } SPAN.keywordflow { color: #e08000 } SPAN.comment { color: #800000 } SPAN.preprocessor { color: #806020 } SPAN.stringliteral { color: #002080 } SPAN.charliteral { color: #008080 } SPAN.vhdldigit { color: #ff00ff } SPAN.vhdlchar { color: #000000 } SPAN.vhdlkeyword { color: #700070 } SPAN.vhdllogic { color: #ff0000 } .mdescLeft { padding: 0px 8px 4px 8px; font-size: 80%; font-style: italic; background-color: #FAFAFA; border-top: 1px none #E0E0E0; border-right: 1px none #E0E0E0; border-bottom: 1px none #E0E0E0; border-left: 1px none #E0E0E0; margin: 0px; } .mdescRight { padding: 0px 8px 4px 8px; font-size: 80%; font-style: italic; background-color: #FAFAFA; border-top: 1px none #E0E0E0; border-right: 1px none #E0E0E0; border-bottom: 1px none #E0E0E0; border-left: 1px none #E0E0E0; margin: 0px; } .memItemLeft { padding: 1px 0px 0px 8px; margin: 4px; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-top-color: #E0E0E0; border-right-color: #E0E0E0; border-bottom-color: #E0E0E0; border-left-color: #E0E0E0; border-top-style: solid; border-right-style: none; border-bottom-style: none; border-left-style: none; background-color: #FAFAFA; font-size: 80%; } .memItemRight { padding: 1px 8px 0px 8px; margin: 4px; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-top-color: #E0E0E0; border-right-color: #E0E0E0; border-bottom-color: #E0E0E0; border-left-color: #E0E0E0; border-top-style: solid; border-right-style: none; border-bottom-style: none; border-left-style: none; background-color: #FAFAFA; font-size: 80%; } .memTemplItemLeft { padding: 1px 0px 0px 8px; margin: 4px; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-top-color: #E0E0E0; border-right-color: #E0E0E0; border-bottom-color: #E0E0E0; border-left-color: #E0E0E0; border-top-style: none; border-right-style: none; border-bottom-style: none; border-left-style: none; background-color: #FAFAFA; font-size: 80%; } .memTemplItemRight { padding: 1px 8px 0px 8px; margin: 4px; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-top-color: #E0E0E0; border-right-color: #E0E0E0; border-bottom-color: #E0E0E0; border-left-color: #E0E0E0; border-top-style: none; border-right-style: none; border-bottom-style: none; border-left-style: none; background-color: #FAFAFA; font-size: 80%; } .memTemplParams { padding: 1px 0px 0px 8px; margin: 4px; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-top-color: #E0E0E0; border-right-color: #E0E0E0; border-bottom-color: #E0E0E0; border-left-color: #E0E0E0; border-top-style: solid; border-right-style: none; border-bottom-style: none; border-left-style: none; color: #606060; background-color: #FAFAFA; font-size: 80%; } .search { color: #003399; font-weight: bold; } FORM.search { margin-bottom: 0px; margin-top: 0px; } INPUT.search { font-size: 75%; color: #000080; font-weight: normal; background-color: #e8eef2; } TD.tiny { font-size: 75%; } a { color: #1A41A8; } a:visited { color: #2A3798; } .dirtab { padding: 4px; border-collapse: collapse; border: 1px solid #84b0c7; } TH.dirtab { background: #e8eef2; font-weight: bold; } HR { height: 1px; border: none; border-top: 1px solid black; } /* Style for detailed member documentation */ .memtemplate { font-size: 80%; color: #606060; font-weight: normal; margin-left: 3px; } .memnav { background-color: #e8eef2; border: 1px solid #84b0c7; text-align: center; margin: 2px; margin-right: 15px; padding: 2px; } .memitem { padding: 4px; background-color: #eef3f5; border-width: 1px; border-style: solid; border-color: #dedeee; -moz-border-radius: 8px 8px 8px 8px; } .memname { white-space: nowrap; font-weight: bold; } .memdoc{ padding-left: 10px; } .memproto { background-color: #d5e1e8; width: 100%; border-width: 1px; border-style: solid; border-color: #84b0c7; font-weight: bold; -moz-border-radius: 8px 8px 8px 8px; } .paramkey { text-align: right; } .paramtype { white-space: nowrap; } .paramname { color: #602020; font-style: italic; white-space: nowrap; } /* End Styling for detailed member documentation */ /* for the tree view */ .ftvtree { font-family: sans-serif; margin:0.5em; } .directory { font-size: 9pt; font-weight: bold; } .directory h3 { margin: 0px; margin-top: 1em; font-size: 11pt; } .directory > h3 { margin-top: 0; } .directory p { margin: 0px; white-space: nowrap; } .directory div { display: none; margin: 0px; } .directory img { vertical-align: -30%; } libDAI-0.2.4/doc/html/form_91.png0000644000263000017630000000146611334764771015174 0ustar jorismkybPNG  IHDR:vV0PLTEppp```PPP@@@000 4tRNS@fIDAT8MhAߝ$6۪bkM(mcTEJA 5bQ LAzir bxRXڣ ^zIk=3$lDě_|~;b'R9mIRzӉTWN|8Lị Ґ!qFm? TZpl#4H5Q) ZỤ5E/Sk0l5VK#$jąF0'15Iy1zΝiwvw~ps9g;}rafttT!|/D 5=r/5''}٨w.ujbU*w_d٩_SԼ1;*r_\P2UN a:ƆZG59$ِF&Aw48˶;-7\udzyvJ[o?5ЋI?5j"6u;{@Yz6f-h yBO h"n[G|M.7j"Է{@~p(cRQ7LىA ֋s@^\u8Me2{o@Apk&M0c&h`.r@SzQ ހפO86Cχg!ӍOcE@-y}\N5[EwԴْ qjCM96qGJTfJ=6Ύ;R? O$>|ߤn: ΤTFrX;JĚ38Tg)1~} 8YedLC; jz]@˵bz6:F҃TeY*)Y$]ݧqnV跇eΘq f,Hߪ5le1)4mdbFs'e[ɔ3s84~b\7 oi $ -q?%gS+ DXǠx9^iZ=&..IVÔ=D?*G(0O(Q-U ;hē)6,^)g;zILDꉙrȶOԭ%+u^hIENDB`libDAI-0.2.4/doc/html/structdai_1_1fo__absdiff-members.html0000644000263000017630000000363011334764771022327 0ustar jorismkyb libDAI: Member List

dai::fo_absdiff< T > Member List

This is the complete list of members for dai::fo_absdiff< T >, including all inherited members.

operator()(const T &x, const T &y) const dai::fo_absdiff< T > [inline]

Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_89.png0000644000263000017630000000155211334764771015177 0ustar jorismkybPNG  IHDRr0PLTEppp```PPP@@@000 4tRNS@fIDATHOAǿli񠨛H_Pb\/EƘMx)jD8r3Gȕp܄UnEh&Ƌߡy;̛-?}eZ0L/å"SJy\!isha!Xp)Uvȶ(~z@P ul˥ _ZPH.VwZH_WXh4Pް >y[Qڎ E)-TypDfs3qiUZ%D%Pjquǣ($C4n2r`*'I);%L],r&OSu[Y94Ge_DWOt┭ 1e9t8>X9B.0!`B4+:OqօD}bqƻGA"*eDlB}𞥳MK!8;:UEmar@6{0~3*z,#fP/)_KT Z\N 'o!V_]}c\T0Zh? f,Not~ZB1 6Ɛ$)]9衽wAX`ra libDAI: Member List

dai::MR::Properties Member List

This is the complete list of members for dai::MR::Properties, including all inherited members.

DAI_ENUM(UpdateType, FULL, LINEAR)dai::MR::Properties
DAI_ENUM(InitType, RESPPROP, CLAMPING, EXACT)dai::MR::Properties
initsdai::MR::Properties
toldai::MR::Properties
updatesdai::MR::Properties
verbosedai::MR::Properties

Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1fo__pow-members.html0000644000263000017630000000360011334764772021534 0ustar jorismkyb libDAI: Member List

dai::fo_pow< T > Member List

This is the complete list of members for dai::fo_pow< T >, including all inherited members.

operator()(const T &x, const T &y) const dai::fo_pow< T > [inline]

Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_110.png0000644000263000017630000000337011334764772015241 0ustar jorismkybPNG  IHDRB30PLTEppp```PPP@@@000 4tRNS@fvIDAThݙkTO3ΣVE ds%ى D0lHaa 0H.b( 5DĨJDQٕdi '8p!`x3X0䯠 ؁00bBڏUMWZ풅iB_sܧr=OIDWBP.#T”zm0/ٙGK b#X ] I y)Xw+!.KnÄ́D'+z+POx$9NlAsXld^'v)4ę %Áa#MJ}਍;5:,Z ◒%a#ʳ{I>r)tfʋ#+"WOtn?~RGxVY Jq aK%Ϟ'Dnz,G'!3XRvŲw wUxfzJ3Еߑq OIK=fp"y5U%P qGz%qD#J߃FsZ9 `B&΃@)K>wB3xXR1jIfsM7"%iYtWBFm+aѷM@NrYS~H7fUϷZ:.ؗazhD/h͚܁pZC sK*AR!Cge[zE/Fz7DI8^m7o(Hvl<(~Z fV'TH$zzVTyYZb(MɂEzsEɑ1.94fV+0 VuFpWh 0!'3[>e w #kwYk׸>wSW.s*8WZ%U5 `j09 =_i"M#$HLP8' ڳ2^FD`v,f"%F펁e[0~fM?e5L<3{qs libDAI: example_varset.cpp

example_varset.cpp

This example shows how to use the Var, VarSet and State classes. It also explains the concept of "states" for VarSets.

Output

X = {x0,x1}

Var x0 has 2 states (possible values).
Var x1 has 3 states.

VarSet {x0,x1} has 6 states (joint assignments of its variables).

States of VarSets correspond to states of their constituent Vars:
  state of x0:   state of x1:   state of X:
    0              0              0
    1              0              1
    0              1              2
    1              1              3
    0              2              4
    1              2              5

And vice versa:
  state of x0:   state of x1:   state of X:
    0              0              0
    1              0              1
    0              1              2
    1              1              3
    0              2              4
    1              2              5

Source

/*  This file is part of libDAI - http://www.libdai.org/
 *
 *  libDAI is licensed under the terms of the GNU General Public License version
 *  2, or (at your option) any later version. libDAI is distributed without any
 *  warranty. See the file COPYING for more details.
 *
 *  Copyright (C) 2008-2009  Joris Mooij  [joris dot mooij at libdai dot org]
 */


#include <dai/varset.h>
#include <dai/index.h>
#include <iostream>

using namespace std;
using namespace dai;

int main() {
    Var x0(0, 2);   // Define binary variable x0 (with label 0)
    Var x1(1, 3);   // Define ternary variable x1 (with label 1)

    // Define set X = {x0, x1}
    VarSet X; // empty
    X |= x1;  // X = {x1}
    X |= x0;  // X = {x1, x0}
    cout << "X = " << X << endl << endl; // Note that the elements of X are ordered according to their labels

    // Output some information about x0, x1 and X
    cout << "Var " << x0 << " has " << x0.states() << " states (possible values)." << endl;
    cout << "Var " << x1 << " has " << x1.states() << " states." << endl << endl;
    cout << "VarSet " << X << " has " << X.nrStates() << " states (joint assignments of its variables)." << endl << endl;

    cout << "States of VarSets correspond to states of their constituent Vars:" << endl;
    cout << "  state of x0:   state of x1:   (linear) state of X:" << endl;
    for( size_t s1 = 0; s1 < x1.states(); s1++ ) // for all states s1 of x1
        for( size_t s0 = 0; s0 < x0.states(); s0++ ) { // for all states s0 of x0
            // store s0 and s1 in a map "states"
            map<Var,size_t> states;
            states[x0] = s0;
            states[x1] = s1;

            // output states of x0, x1 and corresponding state of X
            cout << "    " << s0 << "              " << s1 << "              " << calcLinearState(X,states) << endl;

            // calcState() is the inverse of calcLinearState()
            DAI_ASSERT( calcState(X, calcLinearState(X, states)) == states );
        }

    cout << endl << "And vice versa:" << endl;
    cout << "  state of x0:   state of x1:   (linear) state of X:" << endl;
    for( size_t S = 0; S < X.nrStates(); S++ ) { // for all (joint) states of X
        // calculate states of x0 and x1 corresponding to state S of X
        map<Var,size_t> states = calcState(X,S);

        // output state of X and corresponding states of x0, x1
        cout << "    " << states[x0] << "              " << states[x1] << "              " << S << endl;

        // calcLinearState() is the inverse of calcState()
        DAI_ASSERT( calcLinearState(X, calcState(X,S)) == S );
    }

    cout << endl << "Iterating over all joint states using the State class:" << endl;
    cout << "  state of x0:   state of x1:   (linear) state of X:   state of X (as a map):" << endl;
    for( State S(X); S.valid(); S++ ) {
        // output state of X and corresponding states of x0, x1
        cout << "    " << S(x0) << "              " << S(x1) << "              " << S << "                      " << S.get() << endl;
    }

    return 0;
}
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/properties_8h-source.html0000644000263000017630000005662411334764772020200 0ustar jorismkyb libDAI: include/dai/properties.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1Evidence.html0000644000263000017630000005056311334764772017771 0ustar jorismkyb libDAI: dai::Evidence Class Reference

dai::Evidence Class Reference

Stores a data set consisting of multiple samples, where each sample is the observed joint state of some variables. More...

#include <dai/evidence.h>

List of all members.

Iterator interface

typedef std::vector
< Observation >::iterator 		iterator
 Iterator over the samples.
typedef std::vector
< Observation >
::const_iterator 		const_iterator
 Constant iterator over the samples.
iterator begin ()
 Returns iterator that points to the first sample.
const_iterator begin () const
 Returns constant iterator that points to the first sample.
iterator end ()
 Returns iterator that points beyond the last sample.
const_iterator end () const
 Returns constant iterator that points beyond the last sample.

Public Types

typedef std::map< Var, size_t > Observation
 Stores joint state of a set of variables.

Public Member Functions

 Evidence ()
 Default constructor.
 Evidence (std::vector< Observation > &samples)
 Construct from samples.
void addEvidenceTabFile (std::istream &is, FactorGraph &fg)
 Read in tabular data from a stream and add the read samples to *this.
size_t nrSamples () const
 Returns number of stored samples.

Private Member Functions

void addEvidenceTabFile (std::istream &is, std::map< std::string, Var > &varMap)
 Read in tabular data from a stream and add the read samples to *this.

Private Attributes

std::vector< Observation > _samples
 Each sample is an observed joint state of some variables.

Detailed Description

Stores a data set consisting of multiple samples, where each sample is the observed joint state of some variables.

Note:
Each sample can describe the joint state of a different set of variables, in order to be able to deal with missing data.
Author:
Charles Vaske
Examples:

example_sprinkler_em.cpp.

Member Typedef Documentation

typedef std::map<Var, size_t> dai::Evidence::Observation

Stores joint state of a set of variables.

typedef std::vector<Observation>::iterator dai::Evidence::iterator

Iterator over the samples.

typedef std::vector<Observation>::const_iterator dai::Evidence::const_iterator

Constant iterator over the samples.

Constructor & Destructor Documentation

dai::Evidence::Evidence (  )  [inline]

Default constructor.

dai::Evidence::Evidence ( std::vector< Observation > &  samples  )  [inline]

Construct from samples.

Member Function Documentation

void dai::Evidence::addEvidenceTabFile ( std::istream &  is,
FactorGraph &  fg 
)

Read in tabular data from a stream and add the read samples to *this.

Parameters:
is Input stream in .tab file format, describing joint observations of variables in fg
fg Factor graph describing the corresponding variables
See also:
Evidence (.tab) file format
Exceptions:
INVALID_EVIDENCE_FILE if the input stream is not valid
Examples:
example_sprinkler_em.cpp.

size_t dai::Evidence::nrSamples (  )  const [inline]

Returns number of stored samples.

Examples:
example_sprinkler_em.cpp.

iterator dai::Evidence::begin (  )  [inline]

Returns iterator that points to the first sample.

const_iterator dai::Evidence::begin (  )  const [inline]

Returns constant iterator that points to the first sample.

iterator dai::Evidence::end (  )  [inline]

Returns iterator that points beyond the last sample.

const_iterator dai::Evidence::end (  )  const [inline]

Returns constant iterator that points beyond the last sample.

void dai::Evidence::addEvidenceTabFile ( std::istream &  is,
std::map< std::string, Var > &  varMap 
) [private]

Read in tabular data from a stream and add the read samples to *this.

Member Data Documentation

std::vector<Observation> dai::Evidence::_samples [private]

Each sample is an observed joint state of some variables.

The documentation for this class was generated from the following files:
Generated on Thu Feb 11 12:26:03 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1DAIAlg-members.html0000644000263000017630000002044511334764772020714 0ustar jorismkyb libDAI: Member List

dai::DAIAlg< GRM > Member List

This is the complete list of members for dai::DAIAlg< GRM >, including all inherited members.

backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
belief(const Var &v) const dai::InfAlg [inline, virtual]
belief(const VarSet &vs) const =0dai::InfAlg [pure virtual]
beliefF(size_t I) const dai::InfAlg [inline, virtual]
beliefs() const =0dai::InfAlg [pure virtual]
beliefV(size_t i) const dai::InfAlg [inline, virtual]
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clone() const =0dai::InfAlg [pure virtual]
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
getProperties() const =0dai::InfAlg [pure virtual]
identify() const =0dai::InfAlg [pure virtual]
init()=0dai::InfAlg [pure virtual]
init(const VarSet &vs)=0dai::InfAlg [pure virtual]
Iterations() const =0dai::InfAlg [pure virtual]
logZ() const =0dai::InfAlg [pure virtual]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
maxDiff() const =0dai::InfAlg [pure virtual]
printProperties() const =0dai::InfAlg [pure virtual]
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
run()=0dai::InfAlg [pure virtual]
setProperties(const PropertySet &opts)=0dai::InfAlg [pure virtual]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Feb 11 12:26:03 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_vars_0x66.html0000644000263000017630000000736611334764772017734 0ustar jorismkyb libDAI: Class Members - Variables
 

- f -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1fo__exp-members.html0000644000263000017630000000356011334764772021530 0ustar jorismkyb libDAI: Member List

dai::fo_exp< T > Member List

This is the complete list of members for dai::fo_exp< T >, including all inherited members.

operator()(const T &x) const dai::fo_exp< T > [inline]

Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1TFactor.html0000644000263000017630000032624211334764772017611 0ustar jorismkyb libDAI: dai::TFactor< T > Class Template Reference

dai::TFactor< T > Class Template Reference

Represents a (probability) factor. More...

#include <dai/factor.h>

Inheritance diagram for dai::TFactor< T >:

dai::FRegion

List of all members.

Public Member Functions

Constructors and destructors
 TFactor (T p=1)
 Constructs factor depending on no variables with value p.
 TFactor (const Var &v)
 Constructs factor depending on the variable v with uniform distribution.
 TFactor (const VarSet &vars)
 Constructs factor depending on variables in vars with uniform distribution.
 TFactor (const VarSet &vars, T p)
 Constructs factor depending on variables in vars with all values set to p.
template<typename S>
 TFactor (const VarSet &vars, const std::vector< S > &x)
 Constructs factor depending on variables in vars, copying the values from a std::vector<>.
 TFactor (const VarSet &vars, const T *p)
 Constructs factor depending on variables in vars, copying the values from an array.
 TFactor (const VarSet &vars, const TProb< T > &p)
 Constructs factor depending on variables in vars, copying the values from p.
 TFactor (const std::vector< Var > &vars, const std::vector< T > &p)
 Constructs factor depending on variables in vars, permuting the values given in p accordingly.
Queries
const TProb< T > & p () const
 Returns constant reference to value vector.
TProb< T > & p ()
 Returns reference to value vector.
T operator[] (size_t i) const
 Returns a copy of the i 'th entry of the value vector.
T & operator[] (size_t i)
 Returns a reference to the i 'th entry of the value vector.
const VarSet & vars () const
 Returns constant reference to variable set (i.e., the variables on which the factor depends).
VarSet & vars ()
 Returns reference to variable set (i.e., the variables on which the factor depends).
size_t states () const
 Returns the number of possible joint states of the variables on which the factor depends, $\prod_{l\in L} S_l$.
T entropy () const
 Returns the Shannon entropy of *this, $-\sum_i p_i \log p_i$.
T max () const
 Returns maximum of all values.
T min () const
 Returns minimum of all values.
T sum () const
 Returns sum of all values.
T maxAbs () const
 Returns maximum absolute value of all values.
bool hasNaNs () const
 Returns true if one or more values are NaN.
bool hasNegatives () const
 Returns true if one or more values are negative.
T strength (const Var &i, const Var &j) const
 Returns strength of this factor (between variables i and j), as defined in eq. (52) of [MoK07b].
Unary transformations
TFactor< T > abs () const
 Returns pointwise absolute value.
TFactor< T > exp () const
 Returns pointwise exponent.
TFactor< T > log (bool zero=false) const
 Returns pointwise logarithm.
TFactor< T > inverse (bool zero=true) const
 Returns pointwise inverse.
TFactor< T > normalized (typename TProb< T >::NormType norm=TProb< T >::NORMPROB) const
 Returns normalized copy of *this, using the specified norm.
Unary operations
TFactor< T > & randomize ()
 Draws all values i.i.d. from a uniform distribution on [0,1).
TFactor< T > & setUniform ()
 Sets all values to $1/n$ where n is the number of states.
T normalize (typename TProb< T >::NormType norm=TProb< T >::NORMPROB)
 Normalizes factor using the specified norm.
Operations with scalars
TFactor< T > & fill (T x)
 Sets all values to x.
TFactor< T > & operator+= (T x)
 Adds scalar x to each value.
TFactor< T > & operator-= (T x)
 Subtracts scalar x from each value.
TFactor< T > & operator*= (T x)
 Multiplies each value with scalar x.
TFactor< T > & operator/= (T x)
 Divides each entry by scalar x.
TFactor< T > & operator^= (T x)
 Raises values to the power x.
Transformations with scalars
TFactor< T > operator+ (T x) const
 Returns sum of *this and scalar x.
TFactor< T > operator- (T x) const
 Returns difference of *this and scalar x.
TFactor< T > operator* (T x) const
 Returns product of *this with scalar x.
TFactor< T > operator/ (T x) const
 Returns quotient of *this with scalar x.
TFactor< T > operator^ (T x) const
 Returns *this raised to the power x.
Operations with other factors
template<typename binOp>
TFactor< T > & binaryOp (const TFactor< T > &g, binOp op)
 Applies binary operation op on two factors, *this and g.
TFactor< T > & operator+= (const TFactor< T > &g)
 Adds g to *this.
TFactor< T > & operator-= (const TFactor< T > &g)
 Subtracts g from *this.
TFactor< T > & operator*= (const TFactor< T > &g)
 Multiplies *this with g.
TFactor< T > & operator/= (const TFactor< T > &g)
 Divides *this by g (where division by zero yields zero).
Transformations with other factors
template<typename binOp>
TFactor< T > binaryTr (const TFactor< T > &g, binOp op) const
 Returns result of applying binary operation op on two factors, *this and g.
TFactor< T > operator+ (const TFactor< T > &g) const
 Returns sum of *this and g.
TFactor< T > operator- (const TFactor< T > &g) const
 Returns *this minus g.
TFactor< T > operator* (const TFactor< T > &g) const
 Returns product of *this with g.
TFactor< T > operator/ (const TFactor< T > &g) const
 Returns quotient of *this by f (where division by zero yields zero).
Miscellaneous operations
TFactor< T > slice (const VarSet &vars, size_t varsState) const
 Returns a slice of *this, where the subset vars is in state varsState.
TFactor< T > embed (const VarSet &vars) const
 Embeds this factor in a larger VarSet.
TFactor< T > marginal (const VarSet &vars, bool normed=true) const
 Returns marginal on vars, obtained by summing out all variables except those in vars, and normalizing the result if normed == true.
TFactor< T > maxMarginal (const VarSet &vars, bool normed=true) const
 Returns max-marginal on vars, obtained by maximizing all variables except those in vars, and normalizing the result if normed == true.

Private Attributes

VarSet _vs
 Stores the variables on which the factor depends.
TProb< T > _p
 Stores the factor values.

Related Functions

(Note that these are not member functions.)

template<typename T>
std::ostream & operator<< (std::ostream &os, const TFactor< T > &f)
 Writes a factor to an output stream.
template<typename T>
T dist (const TFactor< T > &f, const TFactor< T > &g, typename TProb< T >::DistType dt)
 Returns distance between two factors f and g, according to the distance measure dt.
template<typename T>
TFactor< T > max (const TFactor< T > &f, const TFactor< T > &g)
 Returns the pointwise maximum of two factors.
template<typename T>
TFactor< T > min (const TFactor< T > &f, const TFactor< T > &g)
 Returns the pointwise minimum of two factors.
template<typename T>
T MutualInfo (const TFactor< T > &f)
 Calculates the mutual information between the two variables that f depends on, under the distribution given by f.

Detailed Description

template<typename T>
class dai::TFactor< T >

Represents a (probability) factor.

Mathematically, a factor is a function mapping joint states of some variables to the nonnegative real numbers. More formally, denoting a discrete variable with label $l$ by $x_l$ and its state space by $X_l = \{0,1,\dots,S_l-1\}$, a factor depending on the variables $\{x_l\}_{l\in L}$ is a function $f_L : \prod_{l\in L} X_l \to [0,\infty)$.

In libDAI, a factor is represented by a TFactor<T> object, which has two components:

  • a VarSet, corresponding with the set of variables $\{x_l\}_{l\in L}$ that the factor depends on;
  • a TProb, a vector containing the value of the factor for each possible joint state of the variables.
The factor values are stored in the entries of the TProb in a particular ordering, which is defined by the one-to-one correspondence of a joint state in $\prod_{l\in L} X_l$ with a linear index in $\{0,1,\dots,\prod_{l\in L} S_l-1\}$ according to the mapping $\sigma$ induced by dai::calcLinearState().

Template Parameters:
T Should be a scalar that is castable from and to double and should support elementary arithmetic operations.
Todo:
Define a better fileformat for .fg files (maybe using XML)?
Todo:
Add support for sparse factors.
Examples:

example_sprinkler.cpp.

Constructor & Destructor Documentation

template<typename T>
dai::TFactor< T >::TFactor ( T  p = 1  )  [inline]

Constructs factor depending on no variables with value p.

template<typename T>
dai::TFactor< T >::TFactor ( const Var &  v  )  [inline]

Constructs factor depending on the variable v with uniform distribution.

template<typename T>
dai::TFactor< T >::TFactor ( const VarSet &  vars  )  [inline]

Constructs factor depending on variables in vars with uniform distribution.

template<typename T>
dai::TFactor< T >::TFactor ( const VarSet &  vars,
T  p 
) [inline]

Constructs factor depending on variables in vars with all values set to p.

template<typename T>
template<typename S>
dai::TFactor< T >::TFactor ( const VarSet &  vars,
const std::vector< S > &  x 
) [inline]

Constructs factor depending on variables in vars, copying the values from a std::vector<>.

Template Parameters:
S Type of values of x
Parameters:
vars contains the variables that the new factor should depend on.
x Vector with values to be copied.

template<typename T>
dai::TFactor< T >::TFactor ( const VarSet &  vars,
const T *  p 
) [inline]

Constructs factor depending on variables in vars, copying the values from an array.

Parameters:
vars contains the variables that the new factor should depend on.
p Points to array of values to be added.

template<typename T>
dai::TFactor< T >::TFactor ( const VarSet &  vars,
const TProb< T > &  p 
) [inline]

Constructs factor depending on variables in vars, copying the values from p.

template<typename T>
dai::TFactor< T >::TFactor ( const std::vector< Var > &  vars,
const std::vector< T > &  p 
) [inline]

Constructs factor depending on variables in vars, permuting the values given in p accordingly.

Member Function Documentation

template<typename T>
const TProb<T>& dai::TFactor< T >::p (  )  const [inline]

Returns constant reference to value vector.

template<typename T>
TProb<T>& dai::TFactor< T >::p (  )  [inline]

Returns reference to value vector.

template<typename T>
T dai::TFactor< T >::operator[] ( size_t  i  )  const [inline]

Returns a copy of the i 'th entry of the value vector.

template<typename T>
T& dai::TFactor< T >::operator[] ( size_t  i  )  [inline]

Returns a reference to the i 'th entry of the value vector.

template<typename T>
const VarSet& dai::TFactor< T >::vars (  )  const [inline]

Returns constant reference to variable set (i.e., the variables on which the factor depends).

Examples:
example.cpp.

template<typename T>
VarSet& dai::TFactor< T >::vars (  )  [inline]

Returns reference to variable set (i.e., the variables on which the factor depends).

template<typename T>
size_t dai::TFactor< T >::states (  )  const [inline]

Returns the number of possible joint states of the variables on which the factor depends, $\prod_{l\in L} S_l$.

Note:
This is equal to the length of the value vector.

template<typename T>
T dai::TFactor< T >::entropy (  )  const [inline]

Returns the Shannon entropy of *this, $-\sum_i p_i \log p_i$.

template<typename T>
T dai::TFactor< T >::max (  )  const [inline]

Returns maximum of all values.

template<typename T>
T dai::TFactor< T >::min (  )  const [inline]

Returns minimum of all values.

template<typename T>
T dai::TFactor< T >::sum (  )  const [inline]

Returns sum of all values.

template<typename T>
T dai::TFactor< T >::maxAbs (  )  const [inline]

Returns maximum absolute value of all values.

template<typename T>
bool dai::TFactor< T >::hasNaNs (  )  const [inline]

Returns true if one or more values are NaN.

template<typename T>
bool dai::TFactor< T >::hasNegatives (  )  const [inline]

Returns true if one or more values are negative.

template<typename T>
T dai::TFactor< T >::strength ( const Var &  i,
const Var &  j 
) const [inline]

Returns strength of this factor (between variables i and j), as defined in eq. (52) of [MoK07b].

template<typename T>
TFactor<T> dai::TFactor< T >::abs (  )  const [inline]

Returns pointwise absolute value.

template<typename T>
TFactor<T> dai::TFactor< T >::exp (  )  const [inline]

Returns pointwise exponent.

template<typename T>
TFactor<T> dai::TFactor< T >::log ( bool  zero = false  )  const [inline]

Returns pointwise logarithm.

If zero == true, uses log(0)==0; otherwise, log(0)==-Inf.

template<typename T>
TFactor<T> dai::TFactor< T >::inverse ( bool  zero = true  )  const [inline]

Returns pointwise inverse.

If zero == true, uses 1/0==0; otherwise, 1/0==Inf.

template<typename T>
TFactor<T> dai::TFactor< T >::normalized ( typename TProb< T >::NormType  norm = TProb<T>::NORMPROB  )  const [inline]

Returns normalized copy of *this, using the specified norm.

Exceptions:
NOT_NORMALIZABLE if the norm is zero

template<typename T>
TFactor<T>& dai::TFactor< T >::randomize (  )  [inline]

Draws all values i.i.d. from a uniform distribution on [0,1).

template<typename T>
TFactor<T>& dai::TFactor< T >::setUniform (  )  [inline]

Sets all values to $1/n$ where n is the number of states.

template<typename T>
T dai::TFactor< T >::normalize ( typename TProb< T >::NormType  norm = TProb<T>::NORMPROB  )  [inline]

Normalizes factor using the specified norm.

Exceptions:
NOT_NORMALIZABLE if the norm is zero

template<typename T>
TFactor<T>& dai::TFactor< T >::fill ( T  x  )  [inline]

Sets all values to x.

template<typename T>
TFactor<T>& dai::TFactor< T >::operator+= ( T  x  )  [inline]

Adds scalar x to each value.

template<typename T>
TFactor<T>& dai::TFactor< T >::operator-= ( T  x  )  [inline]

Subtracts scalar x from each value.

template<typename T>
TFactor<T>& dai::TFactor< T >::operator*= ( T  x  )  [inline]

Multiplies each value with scalar x.

template<typename T>
TFactor<T>& dai::TFactor< T >::operator/= ( T  x  )  [inline]

Divides each entry by scalar x.

template<typename T>
TFactor<T>& dai::TFactor< T >::operator^= ( T  x  )  [inline]

Raises values to the power x.

template<typename T>
TFactor<T> dai::TFactor< T >::operator+ ( T  x  )  const [inline]

Returns sum of *this and scalar x.

template<typename T>
TFactor<T> dai::TFactor< T >::operator- ( T  x  )  const [inline]

Returns difference of *this and scalar x.

template<typename T>
TFactor<T> dai::TFactor< T >::operator* ( T  x  )  const [inline]

Returns product of *this with scalar x.

template<typename T>
TFactor<T> dai::TFactor< T >::operator/ ( T  x  )  const [inline]

Returns quotient of *this with scalar x.

template<typename T>
TFactor<T> dai::TFactor< T >::operator^ ( T  x  )  const [inline]

Returns *this raised to the power x.

template<typename T>
template<typename binOp>
TFactor<T>& dai::TFactor< T >::binaryOp ( const TFactor< T > &  g,
binOp  op 
) [inline]

Applies binary operation op on two factors, *this and g.

Template Parameters:
binOp Type of function object that accepts two arguments of type T and outputs a type T
Parameters:
g Right operand
op Operation of type binOp

template<typename T>
TFactor<T>& dai::TFactor< T >::operator+= ( const TFactor< T > &  g  )  [inline]

Adds g to *this.

The sum of two factors is defined as follows: if $f : \prod_{l\in L} X_l \to [0,\infty)$ and $g : \prod_{m\in M} X_m \to [0,\infty)$, then

\[f+g : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) + g(x_M).\]

template<typename T>
TFactor<T>& dai::TFactor< T >::operator-= ( const TFactor< T > &  g  )  [inline]

Subtracts g from *this.

The difference of two factors is defined as follows: if $f : \prod_{l\in L} X_l \to [0,\infty)$ and $g : \prod_{m\in M} X_m \to [0,\infty)$, then

\[f-g : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) - g(x_M).\]

template<typename T>
TFactor<T>& dai::TFactor< T >::operator*= ( const TFactor< T > &  g  )  [inline]

Multiplies *this with g.

The product of two factors is defined as follows: if $f : \prod_{l\in L} X_l \to [0,\infty)$ and $g : \prod_{m\in M} X_m \to [0,\infty)$, then

\[fg : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) g(x_M).\]

template<typename T>
TFactor<T>& dai::TFactor< T >::operator/= ( const TFactor< T > &  g  )  [inline]

Divides *this by g (where division by zero yields zero).

The quotient of two factors is defined as follows: if $f : \prod_{l\in L} X_l \to [0,\infty)$ and $g : \prod_{m\in M} X_m \to [0,\infty)$, then

\[\frac{f}{g} : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto \frac{f(x_L)}{g(x_M)}.\]

template<typename T>
template<typename binOp>
TFactor<T> dai::TFactor< T >::binaryTr ( const TFactor< T > &  g,
binOp  op 
) const [inline]

Returns result of applying binary operation op on two factors, *this and g.

Template Parameters:
binOp Type of function object that accepts two arguments of type T and outputs a type T
Parameters:
g Right operand
op Operation of type binOp

template<typename T>
TFactor<T> dai::TFactor< T >::operator+ ( const TFactor< T > &  g  )  const [inline]

Returns sum of *this and g.

The sum of two factors is defined as follows: if $f : \prod_{l\in L} X_l \to [0,\infty)$ and $g : \prod_{m\in M} X_m \to [0,\infty)$, then

\[f+g : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) + g(x_M).\]

template<typename T>
TFactor<T> dai::TFactor< T >::operator- ( const TFactor< T > &  g  )  const [inline]

Returns *this minus g.

The difference of two factors is defined as follows: if $f : \prod_{l\in L} X_l \to [0,\infty)$ and $g : \prod_{m\in M} X_m \to [0,\infty)$, then

\[f-g : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) - g(x_M).\]

template<typename T>
TFactor<T> dai::TFactor< T >::operator* ( const TFactor< T > &  g  )  const [inline]

Returns product of *this with g.

The product of two factors is defined as follows: if $f : \prod_{l\in L} X_l \to [0,\infty)$ and $g : \prod_{m\in M} X_m \to [0,\infty)$, then

\[fg : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) g(x_M).\]

template<typename T>
TFactor<T> dai::TFactor< T >::operator/ ( const TFactor< T > &  g  )  const [inline]

Returns quotient of *this by f (where division by zero yields zero).

The quotient of two factors is defined as follows: if $f : \prod_{l\in L} X_l \to [0,\infty)$ and $g : \prod_{m\in M} X_m \to [0,\infty)$, then

\[\frac{f}{g} : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto \frac{f(x_L)}{g(x_M)}.\]

template<typename T>
TFactor< T > dai::TFactor< T >::slice ( const VarSet &  vars,
size_t  varsState 
) const [inline]

Returns a slice of *this, where the subset vars is in state varsState.

Precondition:
vars sould be a subset of vars()

varsState < vars.states()

The result is a factor that depends on the variables of *this except those in vars, obtained by setting the variables in vars to the joint state specified by the linear index varsState. Formally, if *this corresponds with the factor $f : \prod_{l\in L} X_l \to [0,\infty)$, $M \subset L$ corresponds with vars and varsState corresponds with a mapping $s$ that maps a variable $x_m$ with $m\in M$ to its state $s(x_m) \in X_m$, then the slice returned corresponds with the factor $g : \prod_{l \in L \setminus M} X_l \to [0,\infty)$ defined by $g(\{x_l\}_{l\in L \setminus M}) = f(\{x_l\}_{l\in L \setminus M}, \{s(x_m)\}_{m\in M})$.

template<typename T>
TFactor<T> dai::TFactor< T >::embed ( const VarSet &  vars  )  const [inline]

Embeds this factor in a larger VarSet.

Precondition:
vars() should be a subset of vars
If *this corresponds with $f : \prod_{l\in L} X_l \to [0,\infty)$ and $L \subset M$, then the embedded factor corresponds with $g : \prod_{m\in M} X_m \to [0,\infty) : x \mapsto f(x_L)$.

template<typename T>
TFactor< T > dai::TFactor< T >::marginal ( const VarSet &  vars,
bool  normed = true 
) const [inline]

Returns marginal on vars, obtained by summing out all variables except those in vars, and normalizing the result if normed == true.

Examples:
example_sprinkler.cpp.

template<typename T>
TFactor< T > dai::TFactor< T >::maxMarginal ( const VarSet &  vars,
bool  normed = true 
) const [inline]

Returns max-marginal on vars, obtained by maximizing all variables except those in vars, and normalizing the result if normed == true.

Friends And Related Function Documentation

template<typename T>
std::ostream & operator<< ( std::ostream &  os,
const TFactor< T > &  f 
) [related]

Writes a factor to an output stream.

template<typename T>
T dist ( const TFactor< T > &  f,
const TFactor< T > &  g,
typename TProb< T >::DistType  dt 
) [related]

Returns distance between two factors f and g, according to the distance measure dt.

Precondition:
f.vars() == g.vars()

template<typename T>
TFactor< T > max ( const TFactor< T > &  f,
const TFactor< T > &  g 
) [related]

Returns the pointwise maximum of two factors.

Precondition:
f.vars() == g.vars()

template<typename T>
TFactor< T > min ( const TFactor< T > &  f,
const TFactor< T > &  g 
) [related]

Returns the pointwise minimum of two factors.

Precondition:
f.vars() == g.vars()

template<typename T>
T MutualInfo ( const TFactor< T > &  f  )  [related]

Calculates the mutual information between the two variables that f depends on, under the distribution given by f.

Precondition:
f.vars().size() == 2

Member Data Documentation

template<typename T>
VarSet dai::TFactor< T >::_vs [private]

Stores the variables on which the factor depends.

template<typename T>
TProb<T> dai::TFactor< T >::_p [private]

Stores the factor values.

The documentation for this class was generated from the following file:
Generated on Thu Feb 11 12:26:04 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1HAK-members.html0000644000263000017630000003050311334764772020272 0ustar jorismkyb libDAI: Member List

dai::HAK Member List

This is the complete list of members for dai::HAK, including all inherited members.

_itersdai::HAK [private]
_maxdiffdai::HAK [private]
_muabdai::HAK [private]
_mubadai::HAK [private]
_Qadai::HAK [private]
_Qbdai::HAK [private]
backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
belief(const VarSet &vs) const dai::HAK [virtual]
dai::DAIAlg::belief(const Var &v) const dai::InfAlg [inline, virtual]
beliefF(size_t I) const dai::InfAlg [inline, virtual]
beliefs() const dai::HAK [virtual]
beliefV(size_t i) const dai::InfAlg [inline, virtual]
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clone() const dai::HAK [inline, virtual]
construct()dai::HAK [private]
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
doDoubleLoop()dai::HAK
doGBP()dai::HAK
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
findLoopClusters(const FactorGraph &fg, std::set< VarSet > &allcl, VarSet newcl, const Var &root, size_t length, VarSet vars)dai::HAK [private]
getProperties() const dai::HAK [virtual]
HAK()dai::HAK [inline]
HAK(const FactorGraph &fg, const PropertySet &opts)dai::HAK
HAK(const RegionGraph &rg, const PropertySet &opts)dai::HAK
identify() const dai::HAK [virtual]
init()dai::HAK [virtual]
init(const VarSet &vs)dai::HAK [virtual]
Iterations() const dai::HAK [inline, virtual]
logZ() const dai::HAK [virtual]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
maxDiff() const dai::HAK [inline, virtual]
muab(size_t alpha, size_t _beta)dai::HAK [inline]
muba(size_t alpha, size_t _beta)dai::HAK [inline]
Namedai::HAK [static]
printProperties() const dai::HAK [virtual]
props (defined in dai::HAK)dai::HAK
Qa(size_t alpha) const dai::HAK [inline]
Qb(size_t beta) const dai::HAK [inline]
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
run()dai::HAK [virtual]
setProperties(const PropertySet &opts)dai::HAK [virtual]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_func.html0000644000263000017630000001031311334764772017113 0ustar jorismkyb libDAI: Class Members - Functions
 

- _ -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_67.png0000644000263000017630000000100711334764772015167 0ustar jorismkybPNG  IHDRriD0PLTEppp```PPP@@@000 4tRNS@fIDAT8c`L@LD˔?10YJ~ >Daj80p,2MY`&?ñ(3dv!xȆ|c% H\4C3qdY a@O`V0C3gΜ1iXk  ֿ S6()ap L_@Hbaʙ j0p)LClf-e'0E|`h&CI fpd8@/PCUC arS@ |8 fd `+g70k d3h`Q7{"ƥ .T dwcE`B8IENDB`libDAI-0.2.4/doc/html/form_66.png0000644000263000017630000000050311334764772015166 0ustar jorismkybPNG  IHDR40PLTEppp```PPP@@@000 4tRNS@fIDATc` dtAV)OH G{dqH-pa!\RLJ0*7mYT}a S'|X>3x#lWp Q(1,1AD@DmԁJ ́و̽S ĒQ 0&IENDB`libDAI-0.2.4/doc/html/var_8h-source.html0000644000263000017630000004334411334764772016567 0ustar jorismkyb libDAI: include/dai/var.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1MR-members.html0000644000263000017630000003632011334764772020210 0ustar jorismkyb libDAI: Member List

dai::MR Member List

This is the complete list of members for dai::MR, including all inherited members.

_itersdai::MR [private]
_maxdiffdai::MR [private]
_tJ(size_t i, sub_nb A)dai::MR [private]
appM(size_t i, sub_nb A)dai::MR [private]
backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
belief(const Var &v) const dai::MR [inline, virtual]
belief(const VarSet &) const dai::MR [inline, virtual]
beliefF(size_t I) const dai::InfAlg [inline, virtual]
beliefs() const dai::MR [virtual]
beliefV(size_t i) const dai::MR [virtual]
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clone() const dai::MR [inline, virtual]
condai::MR [private]
corsdai::MR [private]
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
Gamma(size_t i, size_t _j, size_t _l1, size_t _l2)dai::MR [private]
Gamma(size_t i, size_t _l1, size_t _l2)dai::MR [private]
getProperties() const dai::MR [virtual]
identify() const dai::MR [virtual]
init()dai::MR [inline, virtual]
init(const VarSet &)dai::MR [inline, virtual]
init(size_t Nin, Real *_w, Real *_th)dai::MR [private]
init_cor()dai::MR [private]
init_cor_resp()dai::MR [private]
Iterations() const dai::MR [inline, virtual]
kindexdai::MR [private]
kmaxdai::MR [private, static]
logZ() const dai::MR [inline, virtual]
Mdai::MR [private]
Magdai::MR [private]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
makekindex()dai::MR [private]
maxDiff() const dai::MR [inline, virtual]
MR()dai::MR [inline]
MR(const FactorGraph &fg, const PropertySet &opts)dai::MR
Ndai::MR [private]
Namedai::MR [static]
nbdai::MR [private]
Omega(size_t i, size_t _j, size_t _l)dai::MR [private]
printProperties() const dai::MR [virtual]
props (defined in dai::MR)dai::MR
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
run()dai::MR [virtual]
setProperties(const PropertySet &opts)dai::MR [virtual]
sign(Real a)dai::MR [inline, private]
solveM()dai::MR [private]
solvemcav()dai::MR [private]
sub_nb typedefdai::MR [private]
sum_subs(size_t j, sub_nb A, Real *sum_even, Real *sum_odd)dai::MR [private]
supporteddai::MR [private]
T(size_t i, sub_nb A)dai::MR [private]
T(size_t i, size_t _j)dai::MR [private]
thetadai::MR [private]
tJdai::MR [private]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/mf_8h-source.html0000644000263000017630000004413311334764772016376 0ustar jorismkyb libDAI: include/dai/mf.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_78.png0000644000263000017630000000113111334764772015167 0ustar jorismkybPNG  IHDRw0PLTEppp```PPP@@@000 4tRNS@fIDAT8͓=H@I[luhRZ B(u *8 .vQ;A!&B/q:8:8wm&m{+.F&TLy68USUC,Z⳻0YW,hgh7^)uIx'_qsTj9 se.I~xk:ncS57Rx$Şyl%9mIY-r nȘI +rإ}kD{ENO%푊y`T m" i쓛ph]LD9Z2wGGOyNmsC >GZA8MSFxgw|cUm*M=X֏qb{CU/}zb4qe5r#Dw-Č\УIY:/<+/m4^0ڰ3rATMfR̢ X픽ҭT XXpu5,׵$M3I{8D7ldeѯK2(kٕPΆ[6 rTPE}Rvv/*YZ/DIENDB`libDAI-0.2.4/doc/html/form_68.png0000644000263000017630000000025711334764772015176 0ustar jorismkybPNG  IHDR ޹0PLTEppp```PPP@@@000 4tRNS@f-IDATc`@@@ʋa)H4!ZR/IENDB`libDAI-0.2.4/doc/html/structdai_1_1LC_1_1Properties-members.html0000644000263000017630000001027211334764772023122 0ustar jorismkyb libDAI: Member List

dai::LC::Properties Member List

This is the complete list of members for dai::LC::Properties, including all inherited members.

cavainamedai::LC::Properties
cavaioptsdai::LC::Properties
cavitydai::LC::Properties
DAI_ENUM(CavityType, FULL, PAIR, PAIR2, UNIFORM)dai::LC::Properties
DAI_ENUM(UpdateType, SEQFIX, SEQRND)dai::LC::Properties
dampingdai::LC::Properties
maxiterdai::LC::Properties
reinitdai::LC::Properties
toldai::LC::Properties
updatesdai::LC::Properties
verbosedai::LC::Properties

Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_func_0x71.html0000644000263000017630000001031011334764772017667 0ustar jorismkyb libDAI: Class Members - Functions
 

- q -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_120.png0000644000263000017630000000117711334764772015245 0ustar jorismkybPNG  IHDRzf0PLTEppp```PPP@@@000 4tRNS@fIDAT8RkQ6dM6ӛETJBCBm|b$R< ӂ(TEB`x؈x4ݤto曟8Nd hO3_SШuӬu7h^ji).&c|Df2w`gF RdZh;Mb՝DB!7+K&M>V=F-%乀mJuq6uͶ^f/ ҽM=jHlKrL’7K $s\Rd٠%5t!ÆƇ>b.d,r'}=`GjJb V3*F3(kU×EV^L󷿡>Ip q!@Q7vE?18E:IENDB`libDAI-0.2.4/doc/html/form_42.png0000644000263000017630000000067011334764772015165 0ustar jorismkybPNG  IHDR Xb[0PLTEppp```PPP@@@000 4tRNS@f6IDAT(c`0 0`Qe,&¬t&4cg &41B9dY3gΜ tpgtx !L2 r j/`^~]PV4a0C֯ m *k*&26  !e4eH`lpBZ}tf>aI֏ x @÷h(N25q as0 GxDl#,mE(x@UĀe .İ(8J66@ ;? s IENDB`libDAI-0.2.4/doc/html/structdai_1_1MF_1_1Properties-members.html0000644000263000017630000000501411334764772023124 0ustar jorismkyb libDAI: Member List

dai::MF::Properties Member List

This is the complete list of members for dai::MF::Properties, including all inherited members.

dampingdai::MF::Properties
maxiterdai::MF::Properties
toldai::MF::Properties
verbosedai::MF::Properties

Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/jtree_8h-source.html0000644000263000017630000005563111334764772017112 0ustar jorismkyb libDAI: include/dai/jtree.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_0x6d.html0000644000263000017630000002363111334764772016750 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- m -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_85.png0000644000263000017630000000030611334764772015170 0ustar jorismkybPNG  IHDR 'p0PLTEppp```PPP@@@000 4tRNS@fDIDATc`XR L'~ Pf?B- libDAI: Member List

dai::SmallSet< T > Member List

This is the complete list of members for dai::SmallSet< T >, including all inherited members.

_elementsdai::SmallSet< T > [private]
begin()dai::SmallSet< T > [inline]
begin() const dai::SmallSet< T > [inline]
const_iterator typedefdai::SmallSet< T >
const_reverse_iterator typedefdai::SmallSet< T >
contains(const T &t) const dai::SmallSet< T > [inline]
elements()dai::SmallSet< T > [inline]
elements() const dai::SmallSet< T > [inline]
empty() const dai::SmallSet< T > [inline]
end()dai::SmallSet< T > [inline]
end() const dai::SmallSet< T > [inline]
front()dai::SmallSet< T > [inline]
front() const dai::SmallSet< T > [inline]
intersects(const SmallSet &x) const dai::SmallSet< T > [inline]
iterator typedefdai::SmallSet< T >
operator &(const SmallSet &x) const dai::SmallSet< T > [inline]
operator &=(const SmallSet &x)dai::SmallSet< T > [inline]
operator!=(const SmallSet &a, const SmallSet &b)dai::SmallSet< T > [friend]
operator/(const SmallSet &x) const dai::SmallSet< T > [inline]
operator/=(const SmallSet &x)dai::SmallSet< T > [inline]
operator/=(const T &t)dai::SmallSet< T > [inline]
operator<(const SmallSet &a, const SmallSet &b)dai::SmallSet< T > [friend]
operator<<(const SmallSet &x) const dai::SmallSet< T > [inline]
operator==(const SmallSet &a, const SmallSet &b)dai::SmallSet< T > [friend]
operator>>(const SmallSet &x) const dai::SmallSet< T > [inline]
operator|(const SmallSet &x) const dai::SmallSet< T > [inline]
operator|=(const SmallSet &x)dai::SmallSet< T > [inline]
operator|=(const T &t)dai::SmallSet< T > [inline]
rbegin()dai::SmallSet< T > [inline]
rbegin() const dai::SmallSet< T > [inline]
rend()dai::SmallSet< T > [inline]
rend() const dai::SmallSet< T > [inline]
reverse_iterator typedefdai::SmallSet< T >
size() const dai::SmallSet< T > [inline]
SmallSet()dai::SmallSet< T > [inline]
SmallSet(const T &t)dai::SmallSet< T > [inline]
SmallSet(const T &t1, const T &t2)dai::SmallSet< T > [inline]
SmallSet(TIterator begin, TIterator end, size_t sizeHint=0)dai::SmallSet< T > [inline]

Generated on Thu Feb 11 12:26:07 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1BP__dual_1_1__edges__t-members.html0000644000263000017630000000321211334764772024200 0ustar jorismkyb libDAI: Member List

dai::BP_dual::_edges_t< T > Member List

This is the complete list of members for dai::BP_dual::_edges_t< T >, including all inherited members.

Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_124.png0000644000263000017630000000026011334764772015241 0ustar jorismkybPNG  IHDR ޹0PLTEppp```PPP@@@000 4tRNS@f.IDATc`@LA@J{JgRA$+A*>cRG,F³IENDB`libDAI-0.2.4/doc/html/daialg_8h-source.html0000644000263000017630000006234011334764772017215 0ustar jorismkyb libDAI: include/dai/daialg.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_45.png0000644000263000017630000000031611334764772015165 0ustar jorismkybPNG  IHDR <0PLTEppp```PPP@@@000 4tRNS@fLIDATc`@P_!”g`h08000}tf>`(a  `'"Y s#IENDB`libDAI-0.2.4/doc/html/form_70.png0000644000263000017630000000035611334764772015167 0ustar jorismkybPNG  IHDR,0PLTEppp```PPP@@@000 4tRNS@flIDATc`09 aoX1[W~@`fR a~011 Lg+ ?MEuC/PΙa 00 1&dIENDB`libDAI-0.2.4/doc/html/functions_func_0x75.html0000644000263000017630000001152411334764772017703 0ustar jorismkyb libDAI: Class Members - Functions
 

- u -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_16.png0000644000263000017630000000134311334764772015164 0ustar jorismkybPNG  IHDR$vz0PLTEppp```PPP@@@000 4tRNS@faIDATHݕkQǿ#dQCzJ t`/n!1 !XDE(!xq/V6C x "Sq5]8yof?7o[_RTqBuzC, hw:j1Pzq}RaZ Ԯo%p{{q+?7"<پWKO8;āwTX9qk: !ڌgqؤ7b5?%7;NߩziT*i:C 6Ye +-9Џ+r0b s<,b!TÚʝWmm\:KMEoiE1<h-gjywq=-d:-B*l^FHy,l^p3❾p Zy{⠦H9pܽ+G(A-(ssu5s#3R >3d$i"ZZqgFR8 ڮ/B{x倈B}}; 'f pL7bcĄ"%39kͷ!eS 6Ķ&?{Z!=aOCpJc?1ԓIENDB`libDAI-0.2.4/doc/html/enum_8h-source.html0000644000263000017630000002231011334764772016731 0ustar jorismkyb libDAI: include/dai/enum.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/authors.html0000644000263000017630000000337611334764772015570 0ustar jorismkyb libDAI: Authors

Authors

People who contributed to libDAI

The following people have contributed to libDAI (in decreasing order of importance):

Joris Mooij
Martijn Leisink
Frederik Eaton
Charles Vaske
Giuseppe Passino
Bastian Wemmenhove
Patrick Pletscher
Christian Wojek
Claudio Lima
Jiuxiang Hu
Peter Gober
Sebastian Nowozin
Alexander Schwing
Alejandro Lage

This work is part of the Interactive Collaborative Information Systems (ICIS) 
project, supported by the Dutch Ministry of Economic Affairs, grant BSIK03024.
Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_54.png0000644000263000017630000000070011334764772015162 0ustar jorismkybPNG  IHDR0PLTEppp```PPP@@@000 4tRNS@f>IDAT(c`|@=[26QL1\ ,xcQʱ(o,.l揘  cJ}Q6 _䞙@`3$f H5pUB 0g`@wPrt0p(lDs40Lc`` iP0lS0=`e=H{O*S#VpQ̟ `Q AmzˇU H:3ekEu``a`bQ`$ BV)r{@`5"*>KhIENDB`libDAI-0.2.4/doc/html/structdai_1_1fo__Hellinger-members.html0000644000263000017630000000364411334764772022650 0ustar jorismkyb libDAI: Member List

dai::fo_Hellinger< T > Member List

This is the complete list of members for dai::fo_Hellinger< T >, including all inherited members.

operator()(const T &p, const T &q) const dai::fo_Hellinger< T > [inline]

Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_vars_0x67.html0000644000263000017630000000770711334764772017734 0ustar jorismkyb libDAI: Class Members - Variables
 

- g -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1BBP.html0000644000263000017630000036514211334764772016654 0ustar jorismkyb libDAI: dai::BBP Class Reference

dai::BBP Class Reference

Implements BBP (Back-Belief-Propagation) [EaG09]. More...

#include <dai/bbp.h>

List of all members.

Index cache management (for performance)

std::vector< std::vector
< _ind_t > > 		_indices
 Cached indices (indexed [i][_I]).
typedef std::vector< size_t > _ind_t
 Index type.
void RegenerateInds ()
 Prepares index cache _indices.
const _ind_t & _index (size_t i, size_t _I) const
 Returns an index from the cache.

Public Member Functions

Constructors/destructors
 BBP (const InfAlg *ia, const PropertySet &opts)
 Construct BBP object from a InfAlg ia and a PropertySet opts.
Initialization
void init (const std::vector< Prob > &adj_b_V, const std::vector< Prob > &adj_b_F, const std::vector< Prob > &adj_psi_V, const std::vector< Prob > &adj_psi_F)
 Initializes from given belief adjoints adj_b_V, adj_b_F and initial factor adjoints adj_psi_V, adj_psi_F.
void init (const std::vector< Prob > &adj_b_V, const std::vector< Prob > &adj_b_F)
 Initializes from given belief adjoints adj_b_V and adj_b_F (setting initial factor adjoints to zero).
void init_V (const std::vector< Prob > &adj_b_V)
 Initializes variable belief adjoints adj_b_V (and sets factor belief adjoints and initial factor adjoints to zero).
void init_F (const std::vector< Prob > &adj_b_F)
 Initializes factor belief adjoints adj_b_F (and sets variable belief adjoints and initial factor adjoints to zero).
void initCostFnAdj (const BBPCostFunction &cfn, const std::vector< size_t > *stateP)
 Initializes with adjoints calculated from cost function cfn, and state stateP.
BBP Algorithm
void run ()
 Perform iterative updates until change is less than given tolerance.
Query results
Prob & adj_psi_V (size_t i)
 Returns reference to variable factor adjoint.
const Prob & adj_psi_V (size_t i) const
 Returns constant reference to variable factor adjoint.
Prob & adj_psi_F (size_t I)
 Returns reference to factor adjoint.
const Prob & adj_psi_F (size_t I) const
 Returns constant reference to factor adjoint.
Prob & adj_b_V (size_t i)
 Returns reference to variable belief adjoint.
const Prob & adj_b_V (size_t i) const
 Returns constant reference to variable belief adjoint.
Prob & adj_b_F (size_t I)
 Returns reference to factor belief adjoint.
const Prob & adj_b_F (size_t I) const
 Returns constant reference to factor belief adjoint.
size_t Iterations ()
 Return number of iterations done so far.

Public Attributes

struct dai::BBP::Properties props

Private Member Functions

Prob unnormAdjoint (const Prob &w, Real Z_w, const Prob &adj_w)
 Computes the adjoint of the unnormed probability vector from the normalizer and the adjoint of the normalized probability vector.
Real getUnMsgMag ()
 Calculates averaged L1 norm of unnormalized message adjoints.
void getMsgMags (Real &s, Real &new_s)
 Calculates averaged L1 norms of current and new normalized message adjoints.
void getArgmaxMsgM (size_t &i, size_t &_I, Real &mag)
 Returns indices and magnitude of the largest normalized factor->variable message adjoint.
Real getMaxMsgM ()
 Returns magnitude of the largest (in L1-norm) normalized factor->variable message adjoint.
Real getTotalMsgM ()
 Calculates sum of L1 norms of all normalized factor->variable message adjoints.
Real getTotalNewMsgM ()
 Calculates sum of L1 norms of all updated normalized factor->variable message adjoints.
Real getTotalMsgN ()
 Calculates sum of L1 norms of all normalized variable->factor message adjoints.
std::vector< Prob > getZeroAdjF (const FactorGraph &fg)
 Returns a vector of Probs (filled with zeroes) with state spaces corresponding to the factors in the factor graph fg.
std::vector< Prob > getZeroAdjV (const FactorGraph &fg)
 Returns a vector of Probs (filled with zeroes) with state spaces corresponding to the variables in the factor graph fg.
Initialization helper functions
void RegenerateT ()
 Calculate T values; see eqn. (41) in [EaG09].
void RegenerateU ()
 Calculate U values; see eqn. (42) in [EaG09].
void RegenerateS ()
 Calculate S values; see eqn. (43) in [EaG09].
void RegenerateR ()
 Calculate R values; see eqn. (44) in [EaG09].
void RegenerateInputs ()
 Calculate _adj_b_V_unnorm and _adj_b_F_unnorm from _adj_b_V and _adj_b_F.
void RegeneratePsiAdjoints ()
 Initialise members for factor adjoints.
void RegenerateParMessageAdjoints ()
 Initialise members for message adjoints for parallel algorithm.
void RegenerateSeqMessageAdjoints ()
 Initialise members for message adjoints for sequential algorithm.
void Regenerate ()
 Called by init, recalculates intermediate values.
Accessors/mutators
Prob & T (size_t i, size_t _I)
 Returns reference to T value; see eqn. (41) in [EaG09].
const Prob & T (size_t i, size_t _I) const
 Returns constant reference to T value; see eqn. (41) in [EaG09].
Prob & U (size_t I, size_t _i)
 Returns reference to U value; see eqn. (42) in [EaG09].
const Prob & U (size_t I, size_t _i) const
 Returns constant reference to U value; see eqn. (42) in [EaG09].
Prob & S (size_t i, size_t _I, size_t _j)
 Returns reference to S value; see eqn. (43) in [EaG09].
const Prob & S (size_t i, size_t _I, size_t _j) const
 Returns constant reference to S value; see eqn. (43) in [EaG09].
Prob & R (size_t I, size_t _i, size_t _J)
 Returns reference to R value; see eqn. (44) in [EaG09].
const Prob & R (size_t I, size_t _i, size_t _J) const
 Returns constant reference to R value; see eqn. (44) in [EaG09].
Prob & adj_n (size_t i, size_t _I)
 Returns reference to variable->factor message adjoint.
const Prob & adj_n (size_t i, size_t _I) const
 Returns constant reference to variable->factor message adjoint.
Prob & adj_m (size_t i, size_t _I)
 Returns reference to factor->variable message adjoint.
const Prob & adj_m (size_t i, size_t _I) const
 Returns constant reference to factor->variable message adjoint.
Parallel algorithm
void calcNewN (size_t i, size_t _I)
 Calculates new variable->factor message adjoint.
void calcNewM (size_t i, size_t _I)
 Calculates new factor->variable message adjoint.
void calcUnnormMsgN (size_t i, size_t _I)
 Calculates unnormalized variable->factor message adjoint from the normalized one.
void calcUnnormMsgM (size_t i, size_t _I)
 Calculates unnormalized factor->variable message adjoint from the normalized one.
void upMsgN (size_t i, size_t _I)
 Updates (un)normalized variable->factor message adjoints.
void upMsgM (size_t i, size_t _I)
 Updates (un)normalized factor->variable message adjoints.
void doParUpdate ()
 Do one parallel update of all message adjoints.
Sequential algorithm
void incrSeqMsgM (size_t i, size_t _I, const Prob &p)
 Helper function for sendSeqMsgM(): increases factor->variable message adjoint by p and calculates the corresponding unnormalized adjoint.
void setSeqMsgM (size_t i, size_t _I, const Prob &p)
 Sets normalized factor->variable message adjoint and calculates the corresponding unnormalized adjoint.
void sendSeqMsgN (size_t i, size_t _I, const Prob &f)
 Implements routine Send-n in Figure 5 in [EaG09].
void sendSeqMsgM (size_t i, size_t _I)
 Implements routine Send-m in Figure 5 in [EaG09].

Private Attributes

Input variables
BP_dual _bp_dual
 Stores a BP_dual helper object.
const FactorGraph * _fg
 Pointer to the factor graph.
const InfAlg * _ia
 Pointer to the approximate inference algorithm (currently, only BP objects are supported).
Output variables
std::vector< Prob > _adj_psi_V
 Variable factor adjoints.
std::vector< Prob > _adj_psi_F
 Factor adjoints.
std::vector< std::vector< Prob > > _adj_n
 Variable->factor message adjoints (indexed [i][_I]).
std::vector< std::vector< Prob > > _adj_m
 Factor->variable message adjoints (indexed [i][_I]).
std::vector< Prob > _adj_b_V
 Normalized variable belief adjoints.
std::vector< Prob > _adj_b_F
 Normalized factor belief adjoints.
Internal state variables
std::vector< Prob > _init_adj_psi_V
 Initial variable factor adjoints.
std::vector< Prob > _init_adj_psi_F
 Initial factor adjoints.
std::vector< std::vector< Prob > > _adj_n_unnorm
 Unnormalized variable->factor message adjoint (indexed [i][_I]).
std::vector< std::vector< Prob > > _adj_m_unnorm
 Unnormalized factor->variable message adjoint (indexed [i][_I]).
std::vector< std::vector< Prob > > _new_adj_n
 Updated normalized variable->factor message adjoint (indexed [i][_I]).
std::vector< std::vector< Prob > > _new_adj_m
 Updated normalized factor->variable message adjoint (indexed [i][_I]).
std::vector< Prob > _adj_b_V_unnorm
 Unnormalized variable belief adjoints.
std::vector< Prob > _adj_b_F_unnorm
 Unnormalized factor belief adjoints.
std::vector< std::vector< Prob > > _Tmsg
 _Tmsg[i][_I] (see eqn. (41) in [EaG09])
std::vector< std::vector< Prob > > _Umsg
 _Umsg[I][_i] (see eqn. (42) in [EaG09])
std::vector< std::vector
< std::vector< Prob > > > 		_Smsg
 _Smsg[i][_I][_j] (see eqn. (43) in [EaG09])
std::vector< std::vector
< std::vector< Prob > > > 		_Rmsg
 _Rmsg[I][_i][_J] (see eqn. (44) in [EaG09])
size_t _iters
 Number of iterations done.

Related Functions

(Note that these are not member functions.)

Real numericBBPTest (const InfAlg &bp, const std::vector< size_t > *state, const PropertySet &bbp_props, const BBPCostFunction &cfn, Real h)
 Function to verify the validity of adjoints computed by BBP using numerical differentiation.

Classes

struct  Properties
 Parameters for BBP. More...

Detailed Description

Implements BBP (Back-Belief-Propagation) [EaG09].

Author:
Frederik Eaton

Member Typedef Documentation

typedef std::vector<size_t> dai::BBP::_ind_t [private]

Index type.

Constructor & Destructor Documentation

dai::BBP::BBP ( const InfAlg *  ia,
const PropertySet &  opts 
) [inline]

Construct BBP object from a InfAlg ia and a PropertySet opts.

Parameters:
ia should be a BP object or something compatible
opts Parameters
See also:
Properties

Member Function Documentation

void dai::BBP::RegenerateInds (  )  [private]

Prepares index cache _indices.

See also:
bp.cpp

const _ind_t& dai::BBP::_index ( size_t  i,
size_t  _I 
) const [inline, private]

Returns an index from the cache.

void dai::BBP::RegenerateT (  )  [private]

Calculate T values; see eqn. (41) in [EaG09].

void dai::BBP::RegenerateU (  )  [private]

Calculate U values; see eqn. (42) in [EaG09].

void dai::BBP::RegenerateS (  )  [private]

Calculate S values; see eqn. (43) in [EaG09].

void dai::BBP::RegenerateR (  )  [private]

Calculate R values; see eqn. (44) in [EaG09].

void dai::BBP::RegenerateInputs (  )  [private]

Calculate _adj_b_V_unnorm and _adj_b_F_unnorm from _adj_b_V and _adj_b_F.

void dai::BBP::RegeneratePsiAdjoints (  )  [private]

Initialise members for factor adjoints.

Precondition:
RegenerateInputs() should be called first

void dai::BBP::RegenerateParMessageAdjoints (  )  [private]

Initialise members for message adjoints for parallel algorithm.

Precondition:
RegenerateInputs() should be called first

void dai::BBP::RegenerateSeqMessageAdjoints (  )  [private]

Initialise members for message adjoints for sequential algorithm.

Same as RegenerateMessageAdjoints, but calls sendSeqMsgN rather than updating _adj_n (and friends) which are unused in the sequential algorithm.

Precondition:
RegenerateInputs() should be called first

void dai::BBP::Regenerate (  )  [private]

Called by init, recalculates intermediate values.

Prob& dai::BBP::T ( size_t  i,
size_t  _I 
) [inline, private]

Returns reference to T value; see eqn. (41) in [EaG09].

const Prob& dai::BBP::T ( size_t  i,
size_t  _I 
) const [inline, private]

Returns constant reference to T value; see eqn. (41) in [EaG09].

Prob& dai::BBP::U ( size_t  I,
size_t  _i 
) [inline, private]

Returns reference to U value; see eqn. (42) in [EaG09].

const Prob& dai::BBP::U ( size_t  I,
size_t  _i 
) const [inline, private]

Returns constant reference to U value; see eqn. (42) in [EaG09].

Prob& dai::BBP::S ( size_t  i,
size_t  _I,
size_t  _j 
) [inline, private]

Returns reference to S value; see eqn. (43) in [EaG09].

const Prob& dai::BBP::S ( size_t  i,
size_t  _I,
size_t  _j 
) const [inline, private]

Returns constant reference to S value; see eqn. (43) in [EaG09].

Prob& dai::BBP::R ( size_t  I,
size_t  _i,
size_t  _J 
) [inline, private]

Returns reference to R value; see eqn. (44) in [EaG09].

const Prob& dai::BBP::R ( size_t  I,
size_t  _i,
size_t  _J 
) const [inline, private]

Returns constant reference to R value; see eqn. (44) in [EaG09].

Prob& dai::BBP::adj_n ( size_t  i,
size_t  _I 
) [inline, private]

Returns reference to variable->factor message adjoint.

const Prob& dai::BBP::adj_n ( size_t  i,
size_t  _I 
) const [inline, private]

Returns constant reference to variable->factor message adjoint.

Prob& dai::BBP::adj_m ( size_t  i,
size_t  _I 
) [inline, private]

Returns reference to factor->variable message adjoint.

const Prob& dai::BBP::adj_m ( size_t  i,
size_t  _I 
) const [inline, private]

Returns constant reference to factor->variable message adjoint.

void dai::BBP::calcNewN ( size_t  i,
size_t  _I 
) [private]

Calculates new variable->factor message adjoint.

Increases variable factor adjoint according to eqn. (27) in [EaG09] and calculates the new variable->factor message adjoint according to eqn. (29) in [EaG09].

void dai::BBP::calcNewM ( size_t  i,
size_t  _I 
) [private]

Calculates new factor->variable message adjoint.

Increases factor adjoint according to eqn. (28) in [EaG09] and calculates the new factor->variable message adjoint according to the r.h.s. of eqn. (30) in [EaG09].

void dai::BBP::calcUnnormMsgN ( size_t  i,
size_t  _I 
) [private]

Calculates unnormalized variable->factor message adjoint from the normalized one.

void dai::BBP::calcUnnormMsgM ( size_t  i,
size_t  _I 
) [private]

Calculates unnormalized factor->variable message adjoint from the normalized one.

void dai::BBP::upMsgN ( size_t  i,
size_t  _I 
) [private]

Updates (un)normalized variable->factor message adjoints.

void dai::BBP::upMsgM ( size_t  i,
size_t  _I 
) [private]

Updates (un)normalized factor->variable message adjoints.

void dai::BBP::doParUpdate (  )  [private]

Do one parallel update of all message adjoints.

void dai::BBP::incrSeqMsgM ( size_t  i,
size_t  _I,
const Prob &  p 
) [private]

Helper function for sendSeqMsgM(): increases factor->variable message adjoint by p and calculates the corresponding unnormalized adjoint.

void dai::BBP::setSeqMsgM ( size_t  i,
size_t  _I,
const Prob &  p 
) [private]

Sets normalized factor->variable message adjoint and calculates the corresponding unnormalized adjoint.

void dai::BBP::sendSeqMsgN ( size_t  i,
size_t  _I,
const Prob &  f 
) [private]

Implements routine Send-n in Figure 5 in [EaG09].

void dai::BBP::sendSeqMsgM ( size_t  i,
size_t  _I 
) [private]

Implements routine Send-m in Figure 5 in [EaG09].

Prob dai::BBP::unnormAdjoint ( const Prob &  w,
Real  Z_w,
const Prob &  adj_w 
) [private]

Computes the adjoint of the unnormed probability vector from the normalizer and the adjoint of the normalized probability vector.

See also:
eqn. (13) in [EaG09]

Real dai::BBP::getUnMsgMag (  )  [private]

Calculates averaged L1 norm of unnormalized message adjoints.

void dai::BBP::getMsgMags ( Real &  s,
Real &  new_s 
) [private]

Calculates averaged L1 norms of current and new normalized message adjoints.

void dai::BBP::getArgmaxMsgM ( size_t &  i,
size_t &  _I,
Real &  mag 
) [private]

Returns indices and magnitude of the largest normalized factor->variable message adjoint.

Real dai::BBP::getMaxMsgM (  )  [private]

Returns magnitude of the largest (in L1-norm) normalized factor->variable message adjoint.

Real dai::BBP::getTotalMsgM (  )  [private]

Calculates sum of L1 norms of all normalized factor->variable message adjoints.

Real dai::BBP::getTotalNewMsgM (  )  [private]

Calculates sum of L1 norms of all updated normalized factor->variable message adjoints.

Real dai::BBP::getTotalMsgN (  )  [private]

Calculates sum of L1 norms of all normalized variable->factor message adjoints.

std::vector< Prob > dai::BBP::getZeroAdjF ( const FactorGraph &  fg  )  [private]

Returns a vector of Probs (filled with zeroes) with state spaces corresponding to the factors in the factor graph fg.

std::vector< Prob > dai::BBP::getZeroAdjV ( const FactorGraph &  fg  )  [private]

Returns a vector of Probs (filled with zeroes) with state spaces corresponding to the variables in the factor graph fg.

void dai::BBP::init ( const std::vector< Prob > &  adj_b_V,
const std::vector< Prob > &  adj_b_F,
const std::vector< Prob > &  adj_psi_V,
const std::vector< Prob > &  adj_psi_F 
) [inline]

Initializes from given belief adjoints adj_b_V, adj_b_F and initial factor adjoints adj_psi_V, adj_psi_F.

void dai::BBP::init ( const std::vector< Prob > &  adj_b_V,
const std::vector< Prob > &  adj_b_F 
) [inline]

Initializes from given belief adjoints adj_b_V and adj_b_F (setting initial factor adjoints to zero).

void dai::BBP::init_V ( const std::vector< Prob > &  adj_b_V  )  [inline]

Initializes variable belief adjoints adj_b_V (and sets factor belief adjoints and initial factor adjoints to zero).

void dai::BBP::init_F ( const std::vector< Prob > &  adj_b_F  )  [inline]

Initializes factor belief adjoints adj_b_F (and sets variable belief adjoints and initial factor adjoints to zero).

void dai::BBP::initCostFnAdj ( const BBPCostFunction &  cfn,
const std::vector< size_t > *  stateP 
)

Initializes with adjoints calculated from cost function cfn, and state stateP.

Uses the internal pointer to an inference algorithm in combination with the cost function and state for initialization.

Parameters:
cfn Cost function used for initialization;
stateP is a Gibbs state and can be NULL; it will be initialised using a Gibbs run.

void dai::BBP::run (  ) 

Perform iterative updates until change is less than given tolerance.

Prob& dai::BBP::adj_psi_V ( size_t  i  )  [inline]

Returns reference to variable factor adjoint.

const Prob& dai::BBP::adj_psi_V ( size_t  i  )  const [inline]

Returns constant reference to variable factor adjoint.

Prob& dai::BBP::adj_psi_F ( size_t  I  )  [inline]

Returns reference to factor adjoint.

const Prob& dai::BBP::adj_psi_F ( size_t  I  )  const [inline]

Returns constant reference to factor adjoint.

Prob& dai::BBP::adj_b_V ( size_t  i  )  [inline]

Returns reference to variable belief adjoint.

const Prob& dai::BBP::adj_b_V ( size_t  i  )  const [inline]

Returns constant reference to variable belief adjoint.

Prob& dai::BBP::adj_b_F ( size_t  I  )  [inline]

Returns reference to factor belief adjoint.

const Prob& dai::BBP::adj_b_F ( size_t  I  )  const [inline]

Returns constant reference to factor belief adjoint.

size_t dai::BBP::Iterations (  )  [inline]

Return number of iterations done so far.

Friends And Related Function Documentation

Real numericBBPTest ( const InfAlg &  bp,
const std::vector< size_t > *  state,
const PropertySet &  bbp_props,
const BBPCostFunction &  cfn,
Real  h 
) [related]

Function to verify the validity of adjoints computed by BBP using numerical differentiation.

Factors containing a variable are multiplied by small adjustments to verify accuracy of calculated variable factor adjoints.

Parameters:
bp BP object;
state Global state of all variables;
bbp_props BBP parameters;
cfn Cost function to be used;
h Size of perturbation.

Member Data Documentation

BP_dual dai::BBP::_bp_dual [private]

Stores a BP_dual helper object.

const FactorGraph* dai::BBP::_fg [private]

Pointer to the factor graph.

const InfAlg* dai::BBP::_ia [private]

Pointer to the approximate inference algorithm (currently, only BP objects are supported).

std::vector<Prob> dai::BBP::_adj_psi_V [private]

Variable factor adjoints.

std::vector<Prob> dai::BBP::_adj_psi_F [private]

Factor adjoints.

std::vector<std::vector<Prob> > dai::BBP::_adj_n [private]

Variable->factor message adjoints (indexed [i][_I]).

std::vector<std::vector<Prob> > dai::BBP::_adj_m [private]

Factor->variable message adjoints (indexed [i][_I]).

std::vector<Prob> dai::BBP::_adj_b_V [private]

Normalized variable belief adjoints.

std::vector<Prob> dai::BBP::_adj_b_F [private]

Normalized factor belief adjoints.

std::vector<Prob> dai::BBP::_init_adj_psi_V [private]

Initial variable factor adjoints.

std::vector<Prob> dai::BBP::_init_adj_psi_F [private]

Initial factor adjoints.

std::vector<std::vector<Prob> > dai::BBP::_adj_n_unnorm [private]

Unnormalized variable->factor message adjoint (indexed [i][_I]).

std::vector<std::vector<Prob> > dai::BBP::_adj_m_unnorm [private]

Unnormalized factor->variable message adjoint (indexed [i][_I]).

std::vector<std::vector<Prob> > dai::BBP::_new_adj_n [private]

Updated normalized variable->factor message adjoint (indexed [i][_I]).

std::vector<std::vector<Prob> > dai::BBP::_new_adj_m [private]

Updated normalized factor->variable message adjoint (indexed [i][_I]).

std::vector<Prob> dai::BBP::_adj_b_V_unnorm [private]

Unnormalized variable belief adjoints.

std::vector<Prob> dai::BBP::_adj_b_F_unnorm [private]

Unnormalized factor belief adjoints.

std::vector<std::vector<Prob > > dai::BBP::_Tmsg [private]

_Tmsg[i][_I] (see eqn. (41) in [EaG09])

std::vector<std::vector<Prob > > dai::BBP::_Umsg [private]

_Umsg[I][_i] (see eqn. (42) in [EaG09])

std::vector<std::vector<std::vector<Prob > > > dai::BBP::_Smsg [private]

_Smsg[i][_I][_j] (see eqn. (43) in [EaG09])

std::vector<std::vector<std::vector<Prob > > > dai::BBP::_Rmsg [private]

_Rmsg[I][_i][_J] (see eqn. (44) in [EaG09])

size_t dai::BBP::_iters [private]

Number of iterations done.

std::vector<std::vector<_ind_t> > dai::BBP::_indices [private]

Cached indices (indexed [i][_I]).

The documentation for this class was generated from the following files:
  • include/dai/bbp.h
  • src/bbp.cpp
Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_64.png0000644000263000017630000000047511334764772015174 0ustar jorismkybPNG  IHDR00PLTEppp```PPP@@@000 4tRNS@fIDATc` 85(s#<%t&`J$09d00 libDAI: include/dai/weightedgraph.h File Reference

include/dai/weightedgraph.h File Reference

Defines some utility functions for (weighted) undirected graphs, trees and rooted trees. More...

#include <vector>
#include <map>
#include <iostream>
#include <set>
#include <limits>
#include <climits>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/prim_minimum_spanning_tree.hpp>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::DEdge
 Represents a directed edge. More...
class  dai::UEdge
 Represents an undirected edge. More...
class  dai::GraphEL
 Represents an undirected graph, implemented as a std::set of undirected edges. More...
class  dai::WeightedGraph< T >
 Represents an undirected weighted graph, with weights of type T, implemented as a std::map mapping undirected edges to weights. More...
class  dai::RootedTree
 Represents a rooted tree, implemented as a vector of directed edges. More...

Typedefs

typedef GraphEL dai::Graph

Functions

template<typename T>
RootedTree dai::MinSpanningTreePrims (const WeightedGraph< T > &G)
 Uses Prim's algorithm to construct a minimal spanning tree from the (positively) weighted graph G.
template<typename T>
RootedTree dai::MaxSpanningTreePrims (const WeightedGraph< T > &G)
 Use Prim's algorithm to construct a maximal spanning tree from the (positively) weighted graph G.
GraphEL dai::RandomDRegularGraph (size_t N, size_t d)
 Constructs a random undirected graph of N nodes, where each node has connectivity d.

Detailed Description

Defines some utility functions for (weighted) undirected graphs, trees and rooted trees.

Todo:
Improve general support for graphs and trees.
Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_132.png0000644000263000017630000000231711334764772015245 0ustar jorismkybPNG  IHDR$r0PLTEppp```PPP@@@000 4tRNS@fMIDATXkEǿwm$jdm6W 5B[k_lz.6 xߜh*[4"D_yDMgvw{{CEؙ>yfYOL_X=DWi*n4 WЍ,jR>QiAJ#*&7 P$'f|Z):JF0w v&r.TМ$2CYVuV骙A4ubDY]7>M7|m #@MCq4ՁC'QNmcdȆ2cKƽw,0uxDF KkSWҖ6S$oqǧ>J[LOrrBv@mW.ٟ i(3Zi}&E1ʡ`~Uj1q$ƀč|Rl#BR圕"<RuHxpka̤D@7Qp8rc缁#9Fq֞sCZD2Ϳ^ć˫$#NԒ9߳#Y K6F"?7h)ضg(Ni̕&!fX4QNa'F,$EΉmeS&Vᘣ7I%{]]i *к"q;< ֞w䣵VWnd}P gŅ둃du%mhi^9煉6 yc\q,gx_1F8lcȖ8ڱxh mςsѤQb$53>SXFo;4bjU;Źht4doJ9V(7c8䴓-1X8 | 1!=,Vc4/%uuB9D)E*9sgO)P ~9$6{Eu/՚S?lGM:h"#!Ɯt>IENDB`libDAI-0.2.4/doc/html/discussion.html0000644000263000017630000001144211334764772016257 0ustar jorismkyb libDAI: Ideas not worth exploring

Ideas not worth exploring

Extended factorgraphs/regiongraphs

A FactorGraph and a RegionGraph are often equipped with additional properties for nodes and edges. The code to initialize those is often quite similar. Maybe one could abstract this, e.g.: 
  template <typename Node1Properties, typename Node2Properties, typename EdgeProperties>
  class ExtFactorGraph : public FactorGraph {
      public:
          std::vector<Node1Properties>              node1Props;
          std::vector<Node2Properties>              node2Props;
          std::vector<std::vector<EdgeProperties> > edgeProps;
         // ...
  }

Advantages:

  • Less code duplication.
  • Easier maintainability.
  • Easier to write new inference algorithms.

Disadvantages:

  • Cachability may be worse.
  • A problem is the case where there are no properties for either type of nodes or for edges. Maybe this can be solved using specializations, or using variadac template arguments? Another possible solution would be to define a "class Empty {}", and add some code that checks for the typeid, comparing it with Empty, and doing something special in that case (e.g., not allocating memory).
  • The main disadvantage of this approach seems to be that it leads to even more entanglement. Therefore this is probably a bad idea.

Polymorphism by template parameterization

Instead of polymorphism by inheritance, use polymorphism by template parameterization. For example, the real reason for introducing the complicated inheritance scheme of dai::InfAlg was for functions like dai::calcMarginal. Instead, one could use a template function: 
  template<typename InfAlg>
  Factor calcMarginal( const InfAlg &obj, const VarSet &ns, bool reInit );
This would assume that the type InfAlg supports certain methods. Ideally, one would use concepts to define different classes of inference algorithms with different capabilities, for example the ability to calculate logZ, the ability to calculate marginals, the ability to calculate bounds, the ability to calculate MAP states, etc. Then, one would use traits classes in order to be able to query the capabilities of the model. For example, one would be able to query whether the inference algorithm supports calculation of logZ. Unfortunately, this is compile-time polymorphism, whereas tests/testdai needs runtime polymorphism. Therefore this is probably a bad idea.
Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1GraphAL_1_1Neighbor.html0000644000263000017630000003463011334764772022057 0ustar jorismkyb libDAI: dai::GraphAL::Neighbor Struct Reference

dai::GraphAL::Neighbor Struct Reference

Describes the neighbor relationship of two nodes in a GraphAL. More...

#include <dai/graph.h>

List of all members.

Public Member Functions

 Neighbor ()
 Default constructor.
 Neighbor (size_t iter, size_t node, size_t dual)
 Constructor that sets the Neighbor members according to the parameters.
 operator size_t () const
 Cast to size_t returns node member.

Public Attributes

size_t iter
 Corresponds to the index of this Neighbor entry in the vector of neighbors.
size_t node
 Contains the number of the neighboring node.
size_t dual
 Contains the "dual" iter.

Detailed Description

Describes the neighbor relationship of two nodes in a GraphAL.

Sometimes we want to do an action, such as sending a message, for all edges in a graph. However, most graphs will be sparse, so we need some way of storing a set of the neighbors of a node, which is both fast and memory-efficient. We also need to be able to go between viewing node a as a neighbor of node b, and node b as a neighbor of node a. The Neighbor struct solves both of these problems. Each node has a list of neighbors, stored as a std::vector<Neighbor>, and extra information is included in the Neighbor struct which allows us to access a node as a neighbor of its neighbor (the dual member).

By convention, variable identifiers naming indices into a vector of neighbors are prefixed with an underscore ("_"). The neighbor list which they point into is then understood from context. For example:

  Real MR::T( size_t i, size_t _j );

Here, i is the "absolute" index of node i, but _j is understood as a "relative" index, giving node j 's entry in nb(i). The corresponding Neighbor structure can be accessed as nb(i,_j) or nb(i)[_j]. The absolute index of _j, which would be called j, can be recovered from the node member: nb(i,_j).node. The iter member gives the relative index _j, and the dual member gives the "dual" relative index, i.e., the index of i in j 's neighbor list.

  Neighbor n = nb(i,_j);
  n.node == j &&
  n.iter == _j &&
  nb(n.node,n.dual).node == i

There is no easy way to transform a pair of absolute node indices i and j into a Neighbor structure relative to one of the nodes. Such a feature has never yet been found to be necessary. Iteration over edges can always be accomplished using the Neighbor lists, and by writing functions that accept relative indices: 

  for( size_t i = 0; i < nrNodes(); ++i )
      foreach( const Neighbor &j, nb(i) )
          T( i, j.iter );

Constructor & Destructor Documentation

dai::GraphAL::Neighbor::Neighbor (  )  [inline]

Default constructor.

dai::GraphAL::Neighbor::Neighbor ( size_t  iter,
size_t  node,
size_t  dual 
) [inline]

Constructor that sets the Neighbor members according to the parameters.

Member Function Documentation

dai::GraphAL::Neighbor::operator size_t (  )  const [inline]

Cast to size_t returns node member.

Member Data Documentation

size_t dai::GraphAL::Neighbor::iter

Corresponds to the index of this Neighbor entry in the vector of neighbors.

size_t dai::GraphAL::Neighbor::node

Contains the number of the neighboring node.

size_t dai::GraphAL::Neighbor::dual

Contains the "dual" iter.

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_44.png0000644000263000017630000000027211334764772015165 0ustar jorismkybPNG  IHDR Q0PLTEppp```PPP@@@000 4tRNS@f8IDATc`! `C Yj0H31>(ҋ,A*E : & .DjIENDB`libDAI-0.2.4/doc/html/form_61.png0000644000263000017630000000065211334764772015166 0ustar jorismkybPNG  IHDRK)0PLTEppp```PPP@@@000 4tRNS@f(IDAT(c` @(F  ̘  AL!1#w3 P̙& n2l``>``oЀj]*`ZyH$%@,f3_H$e)x3W03 ɲ!"A,v2SXQ HpuG2V0W eⶹ/@jX-*{R. (md  %+e# lؕ803 libDAI: include/dai/daialg.h File Reference

include/dai/daialg.h File Reference

Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG). More...

#include <string>
#include <iostream>
#include <vector>
#include <dai/factorgraph.h>
#include <dai/regiongraph.h>
#include <dai/properties.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::InfAlg
 InfAlg is an abstract base class, defining the common interface of all inference algorithms in libDAI. More...
class  dai::DAIAlg< GRM >
 Combines the abstract base class InfAlg with a graphical model (e.g., a FactorGraph or RegionGraph). More...

Typedefs

typedef DAIAlg< FactorGraph > dai::DAIAlgFG
 Base class for inference algorithms that operate on a FactorGraph.
typedef DAIAlg< RegionGraph > dai::DAIAlgRG
 Base class for inference algorithms that operate on a RegionGraph.

Functions

Factor dai::calcMarginal (const InfAlg &obj, const VarSet &vs, bool reInit)
 Calculates the marginal probability distribution for vs using inference algorithm obj.
vector< Factor > dai::calcPairBeliefs (const InfAlg &obj, const VarSet &vs, bool reInit, bool accurate=false)
 Calculates beliefs for all pairs of variables in vs using inference algorithm obj.

Detailed Description

Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG).

Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_11.png0000644000263000017630000000031711334764772015157 0ustar jorismkybPNG  IHDR]R0PLTEppp```PPP@@@000 4tRNS@fMIDATc`8YӠ@-+ABH, ôAttf i(CHęـU e20S s5IENDB`libDAI-0.2.4/doc/html/form_55.png0000644000263000017630000000066111334764772015171 0ustar jorismkybPNG  IHDR0PLTEppp```PPP@@@000 4tRNS@f/IDAT(c`|y6QdlXg|"ȲWh}6`37cVa b4QX/C$k03 `DUl Q  pQ .2Xh.`20< @`.D3pE!Lg!20pOiPe` xp. 6tQ0C,Pd libDAI: include/dai/graph.h File Reference

include/dai/graph.h File Reference

Defines the GraphAL class, which represents an undirected graph as an adjacency list. More...

#include <ostream>
#include <vector>
#include <algorithm>
#include <dai/util.h>
#include <dai/exceptions.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::GraphAL
 Represents the neighborhood structure of nodes in an undirected graph. More...
struct  dai::GraphAL::Neighbor
 Describes the neighbor relationship of two nodes in a GraphAL. More...

Functions

GraphAL dai::createGraphFull (size_t N)
 Creates a fully-connected graph with N nodes.
GraphAL dai::createGraphGrid (size_t n1, size_t n2, bool periodic)
 Creates a two-dimensional rectangular grid of n1 by n2 nodes, which can be periodic.
GraphAL dai::createGraphGrid3D (size_t n1, size_t n2, size_t n3, bool periodic)
 Creates a three-dimensional rectangular grid of n1 by n2 by n3 nodes, which can be periodic.
GraphAL dai::createGraphLoop (size_t N)
 Creates a graph consisting of a single loop of N nodes.
GraphAL dai::createGraphTree (size_t N)
 Creates a random tree-structured graph of N nodes.
GraphAL dai::createGraphRegular (size_t N, size_t d)
 Creates a random regular graph of N nodes with uniform connectivity d.

Detailed Description

Defines the GraphAL class, which represents an undirected graph as an adjacency list.

Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/hak_8h.html0000644000263000017630000000710011334764772015232 0ustar jorismkyb libDAI: include/dai/hak.h File Reference

include/dai/hak.h File Reference

Defines class HAK, which implements a variant of Generalized Belief Propagation. More...

#include <string>
#include <dai/daialg.h>
#include <dai/regiongraph.h>
#include <dai/enum.h>
#include <dai/properties.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::HAK
 Approximate inference algorithm: implementation of single-loop ("Generalized Belief Propagation") and double-loop algorithms by Heskes, Albers and Kappen [HAK03]. More...
struct  dai::HAK::Properties
 Parameters for HAK. More...

Detailed Description

Defines class HAK, which implements a variant of Generalized Belief Propagation.

Idea:
Implement more general region graphs and corresponding Generalized Belief Propagation updates as described in [YFW05].
Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_119.png0000644000263000017630000000032511334764772015247 0ustar jorismkybPNG  IHDR!0PLTEppp```PPP@@@000 4tRNS@fSIDATc`@ pzy bi3yfp^i`bf10P22X8>08,s`R`?aRľa; ׮eX$IENDB`libDAI-0.2.4/doc/html/form_97.png0000644000263000017630000000110111334764772015165 0ustar jorismkybPNG  IHDRPP0PLTEppp```PPP@@@000 4tRNS@fIDAT8c`-`&UV6f06@DQ +kd ~RX>@Mbh(3PF(&%3N`'( P] hr{dґ&xMj>PXʷg`Ld9c CQḃ9 , LexF<V1~``y,y9P+STgU@apèh' F]8j|= c~l| mdFq$0p el l`FAj*ALdc#Q\K822=ewb4o00}tO3#G[Z2(FN IJ!C!U^d,?$ S SbPe #J@lS`, I  bK4_PT`IENDB`libDAI-0.2.4/doc/html/structdai_1_1TreeEP_1_1Properties-members.html0000644000263000017630000000552011334764772023750 0ustar jorismkyb libDAI: Member List

dai::TreeEP::Properties Member List

This is the complete list of members for dai::TreeEP::Properties, including all inherited members.

DAI_ENUM(TypeType, ORG, ALT)dai::TreeEP::Properties
maxiterdai::TreeEP::Properties
toldai::TreeEP::Properties
typedai::TreeEP::Properties
verbosedai::TreeEP::Properties

Generated on Thu Feb 11 12:26:07 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1HAK.png0000644000263000017630000000106311334764772016461 0ustar jorismkybPNG  IHDR<)PLTE`{tRNS@fIDAThQn gLۅa`qVҀL5M%K> Uk},ap`( wD#!\B[> )]Hs*hT-AP! =9 (U8n@6h libDAI: Class Members - Functions
 

- d -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1BipartiteGraph_1_1levelType.html0000644000263000017630000001123211334764772023713 0ustar jorismkyb libDAI: dai::BipartiteGraph::levelType Struct Reference

dai::BipartiteGraph::levelType Struct Reference

Used internally by isTree(). More...

List of all members.

Public Attributes

std::vector< size_t > ind1
 Indices of nodes of type 1.
std::vector< size_t > ind2
 Indices of nodes of type 2.

Detailed Description

Used internally by isTree().

Member Data Documentation

std::vector<size_t> dai::BipartiteGraph::levelType::ind1

Indices of nodes of type 1.

std::vector<size_t> dai::BipartiteGraph::levelType::ind2

Indices of nodes of type 2.

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1MF_1_1Properties.html0000644000263000017630000001504211334764772021476 0ustar jorismkyb libDAI: dai::MF::Properties Struct Reference

dai::MF::Properties Struct Reference

Parameters for MF. More...

#include <dai/mf.h>

List of all members.

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr).
size_t maxiter
 Maximum number of iterations.
Real tol
 Tolerance for convergence test.
Real damping
 Damping constant (0.0 means no damping, 1.0 is maximum damping).

Detailed Description

Parameters for MF.

Member Data Documentation

size_t dai::MF::Properties::verbose

Verbosity (amount of output sent to stderr).

size_t dai::MF::Properties::maxiter

Maximum number of iterations.

Real dai::MF::Properties::tol

Tolerance for convergence test.

Real dai::MF::Properties::damping

Damping constant (0.0 means no damping, 1.0 is maximum damping).

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_vars_0x72.html0000644000263000017630000001073111334764772017717 0ustar jorismkyb libDAI: Class Members - Variables
 

- r -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1BP__dual_1_1beliefs.html0000644000263000017630000002044411334764772022120 0ustar jorismkyb libDAI: dai::BP_dual::beliefs Struct Reference

dai::BP_dual::beliefs Struct Reference

Groups together the data structures for storing the two types of beliefs and their normalizers. More...

#include <dai/bp_dual.h>

List of all members.

Public Attributes

std::vector< Prob > b1
 Unnormalized variable beliefs.
std::vector< Real > Zb1
 Normalizers of variable beliefs.
std::vector< Prob > b2
 Unnormalized factor beliefs.
std::vector< Real > Zb2
 Normalizers of factor beliefs.

Detailed Description

Groups together the data structures for storing the two types of beliefs and their normalizers.

Member Data Documentation

std::vector<Prob> dai::BP_dual::beliefs::b1

Unnormalized variable beliefs.

std::vector<Real> dai::BP_dual::beliefs::Zb1

Normalizers of variable beliefs.

std::vector<Prob> dai::BP_dual::beliefs::b2

Unnormalized factor beliefs.

std::vector<Real> dai::BP_dual::beliefs::Zb2

Normalizers of factor beliefs.

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/tab_l.gif0000644000263000017630000000130211334764772014750 0ustar jorismkybGIF89a ,薴ŝɯͻ, ,@P`H$!%CqVe2XJ(Ġ+3 2$ kv-u*"}|}|~q(" $f 'l(&&$r & !){rƲεҽͼиP?Bm A%V܈!k/Đ;^$Ɩ#Mf)f͇(WLK҄ I)L:eD Cx*4 Uh %A^NKbeXkx!2t !5t]$%X.i[]YfEkg`:zҞ;}jaaM׸c瞽vۺ8ȋ'?9積G_>yu_ߞ]zw߭Ǿm浏G~თ/>٫|W}v;libDAI-0.2.4/doc/html/index_8h-source.html0000644000263000017630000015070311334764772017104 0ustar jorismkyb libDAI: include/dai/index.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_10.png0000644000263000017630000000027511334764772015161 0ustar jorismkybPNG  IHDR Rio0PLTEppp```PPP@@@000 4tRNS@f;IDATc`,)`0#̲Q`f1yDJ)@#M)LBe0IENDB`libDAI-0.2.4/doc/html/form_98.png0000644000263000017630000000035011334764772015173 0ustar jorismkybPNG  IHDR0PLTEppp```PPP@@@000 4tRNS@ffIDATc`@^QB()yq lQXa@bB%6b Wjօ 2\ $c@unBpBINfXIENDB`libDAI-0.2.4/doc/html/classdai_1_1TProb.html0000644000263000017630000037054211334764772017277 0ustar jorismkyb libDAI: dai::TProb< T > Class Template Reference

dai::TProb< T > Class Template Reference

Represents a vector with entries of type T. More...

#include <dai/prob.h>

List of all members.

Public Types

enum  NormType { NORMPROB, NORMLINF }
 Enumerates different ways of normalizing a probability measure. More...
enum  DistType {
  DISTL1, DISTLINF, DISTTV, DISTKL,
  DISTHEL
}
 Enumerates different distance measures between probability measures. More...
typedef std::vector< T >
::const_iterator 		const_iterator
 Constant iterator over the elements.
typedef std::vector< T >::iterator iterator
 Iterator over the elements.
typedef std::vector< T >
::const_reverse_iterator 		const_reverse_iterator
 Constant reverse iterator over the elements.
typedef std::vector< T >
::reverse_iterator 		reverse_iterator
 Reverse iterator over the elements.

Public Member Functions

template<typename binOp1, typename binOp2>
T innerProduct (const TProb< T > &q, T init, binOp1 binaryOp1, binOp2 binaryOp2) const
 Performs a generalized inner product, similar to std::inner_product.
Constructors and destructors
 TProb ()
 Default constructor (constructs empty vector).
 TProb (size_t n)
 Construct uniform probability distribution over n outcomes (i.e., a vector of length n with each entry set to $1/n$).
 TProb (size_t n, T p)
 Construct vector of length n with each entry set to p.
template<typename TIterator>
 TProb (TIterator begin, TIterator end, size_t sizeHint=0)
 Construct vector from a range.
template<typename S>
 TProb (const std::vector< S > &v)
 Construct vector from another vector.
Iterator interface
iterator begin ()
 Returns iterator that points to the first element.
const_iterator begin () const
 Returns constant iterator that points to the first element.
iterator end ()
 Returns iterator that points beyond the last element.
const_iterator end () const
 Returns constant iterator that points beyond the last element.
reverse_iterator rbegin ()
 Returns reverse iterator that points to the last element.
const_reverse_iterator rbegin () const
 Returns constant reverse iterator that points to the last element.
reverse_iterator rend ()
 Returns reverse iterator that points beyond the first element.
const_reverse_iterator rend () const
 Returns constant reverse iterator that points beyond the first element.
Queries
const std::vector< T > & p () const
 Returns a const reference to the wrapped vector.
std::vector< T > & p ()
 Returns a reference to the wrapped vector.
T operator[] (size_t i) const
 Returns a copy of the i 'th entry.
T & operator[] (size_t i)
 Returns reference to the i 'th entry.
size_t size () const
 Returns length of the vector (i.e., the number of entries).
template<typename binOp, typename unOp>
T accumulate (T init, binOp op1, unOp op2) const
 Accumulate over all values, similar to std::accumulate.
T entropy () const
 Returns the Shannon entropy of *this, $-\sum_i p_i \log p_i$.
T max () const
 Returns maximum value of all entries.
T min () const
 Returns minimum value of all entries.
T sum () const
 Returns sum of all entries.
T sumAbs () const
 Return sum of absolute value of all entries.
T maxAbs () const
 Returns maximum absolute value of all entries.
bool hasNaNs () const
 Returns true if one or more entries are NaN.
bool hasNegatives () const
 Returns true if one or more entries are negative.
std::pair< size_t, T > argmax () const
 Returns a pair consisting of the index of the maximum value and the maximum value itself.
size_t draw ()
 Returns a random index, according to the (normalized) distribution described by *this.
bool operator<= (const TProb< T > &q) const
 Lexicographical comparison.
Unary transformations
template<typename unaryOp>
TProb< T > pwUnaryTr (unaryOp op) const
 Returns the result of applying operation op pointwise on *this.
TProb< T > operator- () const
 Returns negative of *this.
TProb< T > abs () const
 Returns pointwise absolute value.
TProb< T > exp () const
 Returns pointwise exponent.
TProb< T > log (bool zero=false) const
 Returns pointwise logarithm.
TProb< T > inverse (bool zero=true) const
 Returns pointwise inverse.
TProb< T > normalized (NormType norm=NORMPROB) const
 Returns normalized copy of *this, using the specified norm.
Unary operations
template<typename unaryOp>
TProb< T > & pwUnaryOp (unaryOp op)
 Applies unary operation op pointwise.
TProb< T > & randomize ()
 Draws all entries i.i.d. from a uniform distribution on [0,1).
TProb< T > & setUniform ()
 Sets all entries to $1/n$ where n is the length of the vector.
const TProb< T > & takeAbs ()
 Applies absolute value pointwise.
const TProb< T > & takeExp ()
 Applies exponent pointwise.
const TProb< T > & takeLog (bool zero=false)
 Applies logarithm pointwise.
T normalize (NormType norm=NORMPROB)
 Normalizes vector using the specified norm.
Operations with scalars
TProb< T > & fill (T x)
 Sets all entries to x.
TProb< T > & operator+= (T x)
 Adds scalar x to each entry.
TProb< T > & operator-= (T x)
 Subtracts scalar x from each entry.
TProb< T > & operator*= (T x)
 Multiplies each entry with scalar x.
TProb< T > & operator/= (T x)
 Divides each entry by scalar x.
TProb< T > & operator^= (T x)
 Raises entries to the power x.
Transformations with scalars
TProb< T > operator+ (T x) const
 Returns sum of *this and scalar x.
TProb< T > operator- (T x) const
 Returns difference of *this and scalar x.
TProb< T > operator* (T x) const
 Returns product of *this with scalar x.
TProb< T > operator/ (T x) const
 Returns quotient of *this and scalar x, where division by 0 yields 0.
TProb< T > operator^ (T x) const
 Returns *this raised to the power x.
Operations with other equally-sized vectors
template<typename binaryOp>
TProb< T > & pwBinaryOp (const TProb< T > &q, binaryOp op)
 Applies binary operation pointwise on two vectors.
TProb< T > & operator+= (const TProb< T > &q)
 Pointwise addition with q.
TProb< T > & operator-= (const TProb< T > &q)
 Pointwise subtraction of q.
TProb< T > & operator*= (const TProb< T > &q)
 Pointwise multiplication with q.
TProb< T > & operator/= (const TProb< T > &q)
 Pointwise division by q, where division by 0 yields 0.
TProb< T > & divide (const TProb< T > &q)
 Pointwise division by q, where division by 0 yields +Inf.
TProb< T > & operator^= (const TProb< T > &q)
 Pointwise power.
Transformations with other equally-sized vectors
template<typename binaryOp>
TProb< T > pwBinaryTr (const TProb< T > &q, binaryOp op) const
 Returns the result of applying binary operation op pointwise on *this and q.
TProb< T > operator+ (const TProb< T > &q) const
 Returns sum of *this and q.
TProb< T > operator- (const TProb< T > &q) const
 Return *this minus q.
TProb< T > operator* (const TProb< T > &q) const
 Return product of *this with q.
TProb< T > operator/ (const TProb< T > &q) const
 Returns quotient of *this with q, where division by 0 yields 0.
TProb< T > divided_by (const TProb< T > &q) const
 Pointwise division by q, where division by 0 yields +Inf.
TProb< T > operator^ (const TProb< T > &q) const
 Returns *this to the power q.

Private Attributes

std::vector< T > _p
 The vector.

Related Functions

(Note that these are not member functions.)

template<typename T>
T dist (const TProb< T > &p, const TProb< T > &q, typename TProb< T >::DistType dt)
 Returns distance between p and q, measured using distance measure dt.
template<typename T>
std::ostream & operator<< (std::ostream &os, const TProb< T > &p)
 Writes a TProb<T> to an output stream.
template<typename T>
TProb< T > min (const TProb< T > &a, const TProb< T > &b)
 Returns the pointwise minimum of a and b.
template<typename T>
TProb< T > max (const TProb< T > &a, const TProb< T > &b)
 Returns the pointwise maximum of a and b.

Detailed Description

template<typename T>
class dai::TProb< T >

Represents a vector with entries of type T.

It is simply a std::vector<T> with an interface designed for dealing with probability mass functions.

It is mainly used for representing measures on a finite outcome space, for example, the probability distribution of a discrete random variable. However, entries are not necessarily non-negative; it is also used to represent logarithms of probability mass functions.

Template Parameters:
T Should be a scalar that is castable from and to dai::Real and should support elementary arithmetic operations.

Member Typedef Documentation

template<typename T>
typedef std::vector<T>::const_iterator dai::TProb< T >::const_iterator

Constant iterator over the elements.

template<typename T>
typedef std::vector<T>::iterator dai::TProb< T >::iterator

Iterator over the elements.

template<typename T>
typedef std::vector<T>::const_reverse_iterator dai::TProb< T >::const_reverse_iterator

Constant reverse iterator over the elements.

template<typename T>
typedef std::vector<T>::reverse_iterator dai::TProb< T >::reverse_iterator

Reverse iterator over the elements.

Member Enumeration Documentation

template<typename T>
enum dai::TProb::NormType

Enumerates different ways of normalizing a probability measure.

  • NORMPROB means that the sum of all entries should be 1;
  • NORMLINF means that the maximum absolute value of all entries should be 1.

template<typename T>
enum dai::TProb::DistType

Enumerates different distance measures between probability measures.

  • DISTL1 is the $\ell_1$ distance (sum of absolute values of pointwise difference);
  • DISTLINF is the $\ell_\infty$ distance (maximum absolute value of pointwise difference);
  • DISTTV is the total variation distance (half of the $\ell_1$ distance);
  • DISTKL is the Kullback-Leibler distance ($\sum_i p_i (\log p_i - \log q_i)$).
  • DISTHEL is the Hellinger distance ($\frac{1}{2}\sum_i (\sqrt{p_i}-\sqrt{q_i})^2$).

Constructor & Destructor Documentation

template<typename T>
dai::TProb< T >::TProb (  )  [inline]

Default constructor (constructs empty vector).

template<typename T>
dai::TProb< T >::TProb ( size_t  n  )  [inline, explicit]

Construct uniform probability distribution over n outcomes (i.e., a vector of length n with each entry set to $1/n$).

template<typename T>
dai::TProb< T >::TProb ( size_t  n,
T  p 
) [inline, explicit]

Construct vector of length n with each entry set to p.

template<typename T>
template<typename TIterator>
dai::TProb< T >::TProb ( TIterator  begin,
TIterator  end,
size_t  sizeHint = 0 
) [inline]

Construct vector from a range.

Template Parameters:
TIterator Iterates over instances that can be cast to T
Parameters:
begin Points to first instance to be added.
end Points just beyond last instance to be added.
sizeHint For efficiency, the number of entries can be speficied by sizeHint.

template<typename T>
template<typename S>
dai::TProb< T >::TProb ( const std::vector< S > &  v  )  [inline]

Construct vector from another vector.

Template Parameters:
S type of elements in v (should be castable to type T)
Parameters:
v vector used for initialization

Member Function Documentation

template<typename T>
iterator dai::TProb< T >::begin (  )  [inline]

Returns iterator that points to the first element.

template<typename T>
const_iterator dai::TProb< T >::begin (  )  const [inline]

Returns constant iterator that points to the first element.

template<typename T>
iterator dai::TProb< T >::end (  )  [inline]

Returns iterator that points beyond the last element.

template<typename T>
const_iterator dai::TProb< T >::end (  )  const [inline]

Returns constant iterator that points beyond the last element.

template<typename T>
reverse_iterator dai::TProb< T >::rbegin (  )  [inline]

Returns reverse iterator that points to the last element.

template<typename T>
const_reverse_iterator dai::TProb< T >::rbegin (  )  const [inline]

Returns constant reverse iterator that points to the last element.

template<typename T>
reverse_iterator dai::TProb< T >::rend (  )  [inline]

Returns reverse iterator that points beyond the first element.

template<typename T>
const_reverse_iterator dai::TProb< T >::rend (  )  const [inline]

Returns constant reverse iterator that points beyond the first element.

template<typename T>
const std::vector<T>& dai::TProb< T >::p (  )  const [inline]

Returns a const reference to the wrapped vector.

template<typename T>
std::vector<T>& dai::TProb< T >::p (  )  [inline]

Returns a reference to the wrapped vector.

template<typename T>
T dai::TProb< T >::operator[] ( size_t  i  )  const [inline]

Returns a copy of the i 'th entry.

template<typename T>
T& dai::TProb< T >::operator[] ( size_t  i  )  [inline]

Returns reference to the i 'th entry.

template<typename T>
size_t dai::TProb< T >::size (  )  const [inline]

Returns length of the vector (i.e., the number of entries).

template<typename T>
template<typename binOp, typename unOp>
T dai::TProb< T >::accumulate ( T  init,
binOp  op1,
unOp  op2 
) const [inline]

Accumulate over all values, similar to std::accumulate.

template<typename T>
T dai::TProb< T >::entropy (  )  const [inline]

Returns the Shannon entropy of *this, $-\sum_i p_i \log p_i$.

template<typename T>
T dai::TProb< T >::max (  )  const [inline]

Returns maximum value of all entries.

template<typename T>
T dai::TProb< T >::min (  )  const [inline]

Returns minimum value of all entries.

template<typename T>
T dai::TProb< T >::sum (  )  const [inline]

Returns sum of all entries.

template<typename T>
T dai::TProb< T >::sumAbs (  )  const [inline]

Return sum of absolute value of all entries.

template<typename T>
T dai::TProb< T >::maxAbs (  )  const [inline]

Returns maximum absolute value of all entries.

template<typename T>
bool dai::TProb< T >::hasNaNs (  )  const [inline]

Returns true if one or more entries are NaN.

template<typename T>
bool dai::TProb< T >::hasNegatives (  )  const [inline]

Returns true if one or more entries are negative.

template<typename T>
std::pair<size_t,T> dai::TProb< T >::argmax (  )  const [inline]

Returns a pair consisting of the index of the maximum value and the maximum value itself.

template<typename T>
size_t dai::TProb< T >::draw (  )  [inline]

Returns a random index, according to the (normalized) distribution described by *this.

template<typename T>
bool dai::TProb< T >::operator<= ( const TProb< T > &  q  )  const [inline]

Lexicographical comparison.

Precondition:
this->size() == q.size()

template<typename T>
template<typename unaryOp>
TProb<T> dai::TProb< T >::pwUnaryTr ( unaryOp  op  )  const [inline]

Returns the result of applying operation op pointwise on *this.

template<typename T>
TProb<T> dai::TProb< T >::operator- (  )  const [inline]

Returns negative of *this.

template<typename T>
TProb<T> dai::TProb< T >::abs (  )  const [inline]

Returns pointwise absolute value.

template<typename T>
TProb<T> dai::TProb< T >::exp (  )  const [inline]

Returns pointwise exponent.

template<typename T>
TProb<T> dai::TProb< T >::log ( bool  zero = false  )  const [inline]

Returns pointwise logarithm.

If zero == true, uses log(0)==0; otherwise, log(0)==-Inf.

template<typename T>
TProb<T> dai::TProb< T >::inverse ( bool  zero = true  )  const [inline]

Returns pointwise inverse.

If zero == true, uses 1/0==0; otherwise, 1/0==Inf.

template<typename T>
TProb<T> dai::TProb< T >::normalized ( NormType  norm = NORMPROB  )  const [inline]

Returns normalized copy of *this, using the specified norm.

Exceptions:
NOT_NORMALIZABLE if the norm is zero

template<typename T>
template<typename unaryOp>
TProb<T>& dai::TProb< T >::pwUnaryOp ( unaryOp  op  )  [inline]

Applies unary operation op pointwise.

template<typename T>
TProb<T>& dai::TProb< T >::randomize (  )  [inline]

Draws all entries i.i.d. from a uniform distribution on [0,1).

template<typename T>
TProb<T>& dai::TProb< T >::setUniform (  )  [inline]

Sets all entries to $1/n$ where n is the length of the vector.

template<typename T>
const TProb<T>& dai::TProb< T >::takeAbs (  )  [inline]

Applies absolute value pointwise.

template<typename T>
const TProb<T>& dai::TProb< T >::takeExp (  )  [inline]

Applies exponent pointwise.

template<typename T>
const TProb<T>& dai::TProb< T >::takeLog ( bool  zero = false  )  [inline]

Applies logarithm pointwise.

If zero == true, uses log(0)==0; otherwise, log(0)==-Inf.

template<typename T>
T dai::TProb< T >::normalize ( NormType  norm = NORMPROB  )  [inline]

Normalizes vector using the specified norm.

Exceptions:
NOT_NORMALIZABLE if the norm is zero

template<typename T>
TProb<T>& dai::TProb< T >::fill ( T  x  )  [inline]

Sets all entries to x.

template<typename T>
TProb<T>& dai::TProb< T >::operator+= ( T  x  )  [inline]

Adds scalar x to each entry.

template<typename T>
TProb<T>& dai::TProb< T >::operator-= ( T  x  )  [inline]

Subtracts scalar x from each entry.

template<typename T>
TProb<T>& dai::TProb< T >::operator*= ( T  x  )  [inline]

Multiplies each entry with scalar x.

template<typename T>
TProb<T>& dai::TProb< T >::operator/= ( T  x  )  [inline]

Divides each entry by scalar x.

template<typename T>
TProb<T>& dai::TProb< T >::operator^= ( T  x  )  [inline]

Raises entries to the power x.

template<typename T>
TProb<T> dai::TProb< T >::operator+ ( T  x  )  const [inline]

Returns sum of *this and scalar x.

template<typename T>
TProb<T> dai::TProb< T >::operator- ( T  x  )  const [inline]

Returns difference of *this and scalar x.

template<typename T>
TProb<T> dai::TProb< T >::operator* ( T  x  )  const [inline]

Returns product of *this with scalar x.

template<typename T>
TProb<T> dai::TProb< T >::operator/ ( T  x  )  const [inline]

Returns quotient of *this and scalar x, where division by 0 yields 0.

template<typename T>
TProb<T> dai::TProb< T >::operator^ ( T  x  )  const [inline]

Returns *this raised to the power x.

template<typename T>
template<typename binaryOp>
TProb<T>& dai::TProb< T >::pwBinaryOp ( const TProb< T > &  q,
binaryOp  op 
) [inline]

Applies binary operation pointwise on two vectors.

Template Parameters:
binaryOp Type of function object that accepts two arguments of type T and outputs a type T
Parameters:
q Right operand
op Operation of type binaryOp

template<typename T>
TProb<T>& dai::TProb< T >::operator+= ( const TProb< T > &  q  )  [inline]

Pointwise addition with q.

Precondition:
this->size() == q.size()

template<typename T>
TProb<T>& dai::TProb< T >::operator-= ( const TProb< T > &  q  )  [inline]

Pointwise subtraction of q.

Precondition:
this->size() == q.size()

template<typename T>
TProb<T>& dai::TProb< T >::operator*= ( const TProb< T > &  q  )  [inline]

Pointwise multiplication with q.

Precondition:
this->size() == q.size()

template<typename T>
TProb<T>& dai::TProb< T >::operator/= ( const TProb< T > &  q  )  [inline]

Pointwise division by q, where division by 0 yields 0.

Precondition:
this->size() == q.size()
See also:
divide(const TProb<T> &)

template<typename T>
TProb<T>& dai::TProb< T >::divide ( const TProb< T > &  q  )  [inline]

Pointwise division by q, where division by 0 yields +Inf.

Precondition:
this->size() == q.size()
See also:
operator/=(const TProb<T> &)

template<typename T>
TProb<T>& dai::TProb< T >::operator^= ( const TProb< T > &  q  )  [inline]

Pointwise power.

Precondition:
this->size() == q.size()

template<typename T>
template<typename binaryOp>
TProb<T> dai::TProb< T >::pwBinaryTr ( const TProb< T > &  q,
binaryOp  op 
) const [inline]

Returns the result of applying binary operation op pointwise on *this and q.

Template Parameters:
binaryOp Type of function object that accepts two arguments of type T and outputs a type T
Parameters:
q Right operand
op Operation of type binaryOp

template<typename T>
TProb<T> dai::TProb< T >::operator+ ( const TProb< T > &  q  )  const [inline]

Returns sum of *this and q.

Precondition:
this->size() == q.size()

template<typename T>
TProb<T> dai::TProb< T >::operator- ( const TProb< T > &  q  )  const [inline]

Return *this minus q.

Precondition:
this->size() == q.size()

template<typename T>
TProb<T> dai::TProb< T >::operator* ( const TProb< T > &  q  )  const [inline]

Return product of *this with q.

Precondition:
this->size() == q.size()

template<typename T>
TProb<T> dai::TProb< T >::operator/ ( const TProb< T > &  q  )  const [inline]

Returns quotient of *this with q, where division by 0 yields 0.

Precondition:
this->size() == q.size()
See also:
divided_by(const TProb<T> &)

template<typename T>
TProb<T> dai::TProb< T >::divided_by ( const TProb< T > &  q  )  const [inline]

Pointwise division by q, where division by 0 yields +Inf.

Precondition:
this->size() == q.size()
See also:
operator/(const TProb<T> &)

template<typename T>
TProb<T> dai::TProb< T >::operator^ ( const TProb< T > &  q  )  const [inline]

Returns *this to the power q.

Precondition:
this->size() == q.size()

template<typename T>
template<typename binOp1, typename binOp2>
T dai::TProb< T >::innerProduct ( const TProb< T > &  q,
T  init,
binOp1  binaryOp1,
binOp2  binaryOp2 
) const [inline]

Performs a generalized inner product, similar to std::inner_product.

Precondition:
this->size() == q.size()

Friends And Related Function Documentation

template<typename T>
T dist ( const TProb< T > &  p,
const TProb< T > &  q,
typename TProb< T >::DistType  dt 
) [related]

Returns distance between p and q, measured using distance measure dt.

Precondition:
this->size() == q.size()

template<typename T>
std::ostream & operator<< ( std::ostream &  os,
const TProb< T > &  p 
) [related]

Writes a TProb<T> to an output stream.

template<typename T>
TProb< T > min ( const TProb< T > &  a,
const TProb< T > &  b 
) [related]

Returns the pointwise minimum of a and b.

Precondition:
this->size() == q.size()

template<typename T>
TProb< T > max ( const TProb< T > &  a,
const TProb< T > &  b 
) [related]

Returns the pointwise maximum of a and b.

Precondition:
this->size() == q.size()

Member Data Documentation

template<typename T>
std::vector<T> dai::TProb< T >::_p [private]

The vector.

The documentation for this class was generated from the following file:
Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1CondProbEstimation-members.html0000644000263000017630000001312111334764772023427 0ustar jorismkyb libDAI: Member List

dai::CondProbEstimation Member List

This is the complete list of members for dai::CondProbEstimation, including all inherited members.

_initial_statsdai::CondProbEstimation [private]
_statsdai::CondProbEstimation [private]
_target_dimdai::CondProbEstimation [private]
addSufficientStatistics(const Prob &p)dai::CondProbEstimation [virtual]
clone() const dai::CondProbEstimation [inline, virtual]
CondProbEstimation(size_t target_dimension, const Prob &pseudocounts)dai::CondProbEstimation
construct(const std::string &method, const PropertySet &p)dai::ParameterEstimation [private, static]
estimate()dai::CondProbEstimation [virtual]
factory(const PropertySet &p)dai::CondProbEstimation [static]
ParamEstFactory typedefdai::ParameterEstimation [private]
probSize() const dai::CondProbEstimation [inline, virtual]
registerMethod(const std::string &method, const ParamEstFactory &f)dai::ParameterEstimation [inline, private, static]
~CondProbEstimation()dai::CondProbEstimation [inline, virtual]
~ParameterEstimation()dai::ParameterEstimation [inline, private, virtual]

Generated on Thu Feb 11 12:26:03 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/example__bipgraph_8cpp-example.html0000644000263000017630000001615111334764772022127 0ustar jorismkyb libDAI: example_bipgraph.cpp

example_bipgraph.cpp

This example deals with the following bipartite graph:
inline_dotgraph_1.dot
It has three nodes of type 1 (drawn as circles) and two nodes of type 2 (drawn as rectangles). Node 0 of type 1 has only one neighbor (node 0 of type 2), but node 0 of type 2 has three neighbors (nodes 0,1,2 of type 1). The example code shows how to construct a BipartiteGraph object representing this bipartite graph and how to iterate over nodes and their neighbors.

Output

G has 3 nodes of type 1, 2 nodes of type 2 and 5 edges.

Node 0 of type 1 has 1 neighbors:
  the 0'th neighbor is node 0 of type 2

Node 1 of type 1 has 2 neighbors:
  the 0'th neighbor is node 0 of type 2
  the 1'th neighbor is node 1 of type 2

Node 2 of type 1 has 2 neighbors:
  the 0'th neighbor is node 0 of type 2
  the 1'th neighbor is node 1 of type 2

Source

/*  This file is part of libDAI - http://www.libdai.org/
 *
 *  libDAI is licensed under the terms of the GNU General Public License version
 *  2, or (at your option) any later version. libDAI is distributed without any
 *  warranty. See the file COPYING for more details.
 *
 *  Copyright (C) 2008-2009  Joris Mooij  [joris dot mooij at libdai dot org]
 */


#include <dai/bipgraph.h>

using namespace std;
using namespace dai;

int main() {
    // Create a list of edges
    vector<BipartiteGraph::Edge> edges;
    edges.reserve( 5 );
    edges.push_back( BipartiteGraph::Edge(0, 0) );
    edges.push_back( BipartiteGraph::Edge(1, 0) );
    edges.push_back( BipartiteGraph::Edge(2, 0) );
    edges.push_back( BipartiteGraph::Edge(1, 1) );
    edges.push_back( BipartiteGraph::Edge(2, 1) );

    // Create a bipartite graph with 3 nodes of type 1,
    // 2 nodes of type 2 and edge list edges.
    BipartiteGraph G( 3, 2, edges.begin(), edges.end() );

    // Display some information about G
    cout << "G has " << G.nrNodes1() << " nodes of type 1, " << G.nrNodes2() << " nodes of type 2 and " << G.nrEdges() << " edges." << endl << endl;

    // Iterate over all nodes n1 of type 1
    for( size_t n1 = 0; n1 < G.nrNodes1(); n1++ ) {
        cout << "Node " << n1 << " of type 1 has " << G.nb1(n1).size() << " neighbors:" << endl;
        // Iterate over all neighbors n2 of n1
        foreach( const BipartiteGraph::Neighbor &n2, G.nb1(n1) ) {
            // The n2.iter'th neighbor of n1 is n2:
            DAI_ASSERT( G.nb1(n1)[n2.iter] == n2 );

            // The n2.dual'th neighbor of n2 is n1:
            DAI_ASSERT( G.nb2(n2)[n2.dual] == n1 );

            // n2 can be used as an abbreviation of n2.node:
            DAI_ASSERT( static_cast<size_t>(n2) == n2.node );

            cout << "  the " << n2.iter << "'th neighbor is node " << n2 << " of type 2" << endl;
        }
        cout << endl;
    }
}
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1Var-members.html0000644000263000017630000001200611334764772020415 0ustar jorismkyb libDAI: Member List

dai::Var Member List

This is the complete list of members for dai::Var, including all inherited members.

_labeldai::Var [private]
_statesdai::Var [private]
label() const dai::Var [inline]
label()dai::Var [inline]
operator!=(const Var &n) const dai::Var [inline]
operator<(const Var &n) const dai::Var [inline]
operator<<(std::ostream &os, const Var &n)dai::Var [friend]
operator<=(const Var &n) const dai::Var [inline]
operator==(const Var &n) const dai::Var [inline]
operator>(const Var &n) const dai::Var [inline]
operator>=(const Var &n) const dai::Var [inline]
states() const dai::Var [inline]
states()dai::Var [inline]
Var()dai::Var [inline]
Var(size_t label, size_t states)dai::Var [inline]

Generated on Thu Feb 11 12:26:08 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1State.html0000644000263000017630000007070111334764772017323 0ustar jorismkyb libDAI: dai::State Class Reference

dai::State Class Reference

Makes it easy to iterate over all possible joint states of variables within a VarSet. More...

#include <dai/index.h>

List of all members.

Public Types

typedef states_type::const_iterator const_iterator
 Constant iterator over the values.

Public Member Functions

 State ()
 Default constructor.
 State (const VarSet &vs, size_t linearState=0)
 Construct from VarSet vs and corresponding linear state linearState.
 State (const std::map< Var, size_t > &s)
 Construct from a std::map<Var, size_t>.
const_iterator begin () const
 Returns constant iterator that points to the first item.
const_iterator end () const
 Returns constant iterator that points beyond the last item.
 operator size_t () const
 Return current linear state.
template<typename InputIterator>
void insert (InputIterator b, InputIterator e)
 Inserts a range of variable-state pairs, changing the current state.
const std::map< Var, size_t > & get () const
 Return current state represented as a map.
 operator const std::map< Var, size_t > & () const
 Cast into std::map<Var, size_t>.
size_t operator() (const Var &v) const
 Return current state of variable v, or 0 if v is not in *this.
size_t operator() (const VarSet &vs) const
 Return linear state of variables in vs, assuming that variables that are not in *this are in state 0.
void operator++ ()
 Increments the current state (prefix).
void operator++ (int)
 Increments the current state (postfix).
bool valid () const
 Returns true if the current state is valid.
void reset ()
 Resets the current state (to the joint state represented by linear state 0).

Private Types

typedef std::map< Var, size_t > states_type
 Type for representing a joint state of some variables as a map, which maps each variable to its state.

Private Attributes

long state
 Current state (represented linearly).
states_type states
 Current state (represented as a map).

Detailed Description

Makes it easy to iterate over all possible joint states of variables within a VarSet.

A joint state of several variables can be represented in two different ways, by a map that maps each variable to its own state, or by an integer that gives the index of the joint state in the canonical enumeration.

Both representations are useful, and the main functionality provided by the State class is to simplify iterating over the various joint states of a VarSet and to provide access to the current state in both representations.

As an example, consider the following code snippet which iterates over all joint states of variables x0 and x1: 

  VarSet vars( x0, x1 );
  for( State S(vars); S.valid(); S++ ) {
      cout << "Linear state: " << S.get() << ", x0 = " << S(x0) << ", x1 = " << S(x1) << endl;
  }

Note:
The same functionality could be achieved by simply iterating over the linear state and using dai::calcState(), but the State class offers a more efficient implementation.

A State is very similar to a multifor, but tailored for Var 's and VarSet 's.

See also:
dai::calcLinearState(), dai::calcState()
Idea:
Make the State class a more prominent part of libDAI (and document it clearly, explaining the concept of state); add more optimized variants of the State class like IndexFor (e.g. for TFactor<>::slice()).
Examples:

example_permute.cpp, and example_varset.cpp.

Member Typedef Documentation

typedef std::map<Var, size_t> dai::State::states_type [private]

Type for representing a joint state of some variables as a map, which maps each variable to its state.

typedef states_type::const_iterator dai::State::const_iterator

Constant iterator over the values.

Constructor & Destructor Documentation

dai::State::State (  )  [inline]

Default constructor.

dai::State::State ( const VarSet &  vs,
size_t  linearState = 0 
) [inline]

Construct from VarSet vs and corresponding linear state linearState.

dai::State::State ( const std::map< Var, size_t > &  s  )  [inline]

Construct from a std::map<Var, size_t>.

Member Function Documentation

const_iterator dai::State::begin (  )  const [inline]

Returns constant iterator that points to the first item.

const_iterator dai::State::end (  )  const [inline]

Returns constant iterator that points beyond the last item.

dai::State::operator size_t (  )  const [inline]

Return current linear state.

template<typename InputIterator>
void dai::State::insert ( InputIterator  b,
InputIterator  e 
) [inline]

Inserts a range of variable-state pairs, changing the current state.

const std::map<Var,size_t>& dai::State::get (  )  const [inline]

Return current state represented as a map.

dai::State::operator const std::map< Var, size_t > & (  )  const [inline]

Cast into std::map<Var, size_t>.

size_t dai::State::operator() ( const Var &  v  )  const [inline]

Return current state of variable v, or 0 if v is not in *this.

size_t dai::State::operator() ( const VarSet &  vs  )  const [inline]

Return linear state of variables in vs, assuming that variables that are not in *this are in state 0.

void dai::State::operator++ (  )  [inline]

Increments the current state (prefix).

void dai::State::operator++ ( int   )  [inline]

Increments the current state (postfix).

bool dai::State::valid (  )  const [inline]

Returns true if the current state is valid.

void dai::State::reset (  )  [inline]

Resets the current state (to the joint state represented by linear state 0).

Member Data Documentation

long dai::State::state [private]

Current state (represented linearly).

states_type dai::State::states [private]

Current state (represented as a map).

The documentation for this class was generated from the following file:
Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1MF.png0000644000263000017630000000104111334764772016354 0ustar jorismkybPNG  IHDR<)PLTE`{tRNS@fIDAThAr0 P :텺G%a#66J !L>mx]yE @@Zx[: Ox:/N v hhE9*@$)W'P=ƫ71knG~> ܦ8/xn @eR* W- KLyO^MtQ ERZjS0#Ø#f'A$@PR23 @`%,򎌌CE(ra1w0Obl`%&Hz4zf)\&,Qmd=SfXl6bpPxns8@_סPV<` <1l T9tZz+Ȓ6N|@3`BNu0],@j)?zֿe 1HIENDB`libDAI-0.2.4/doc/html/graph_8h-source.html0000644000263000017630000007250511334764772017101 0ustar jorismkyb libDAI: include/dai/graph.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1DEdge.html0000644000263000017630000002706011334764772017213 0ustar jorismkyb libDAI: dai::DEdge Class Reference

dai::DEdge Class Reference

Represents a directed edge. More...

#include <dai/weightedgraph.h>

List of all members.

Public Member Functions

 DEdge ()
 Default constructor.
 DEdge (size_t m1, size_t m2)
 Constructs a directed edge pointing from m1 to m2.
bool operator== (const DEdge &x) const
 Tests for equality.
bool operator!= (const DEdge &x) const
 Tests for inequality.
bool operator< (const DEdge &x) const
 Smaller-than operator (performs lexicographical comparison).

Public Attributes

size_t n1
 First node index (source of edge).
size_t n2
 Second node index (sink of edge).

Friends

std::ostream & operator<< (std::ostream &os, const DEdge &e)
 Writes a directed edge to an output stream.

Detailed Description

Represents a directed edge.

Constructor & Destructor Documentation

dai::DEdge::DEdge (  )  [inline]

Default constructor.

dai::DEdge::DEdge ( size_t  m1,
size_t  m2 
) [inline]

Constructs a directed edge pointing from m1 to m2.

Member Function Documentation

bool dai::DEdge::operator== ( const DEdge &  x  )  const [inline]

Tests for equality.

bool dai::DEdge::operator!= ( const DEdge &  x  )  const [inline]

Tests for inequality.

bool dai::DEdge::operator< ( const DEdge &  x  )  const [inline]

Smaller-than operator (performs lexicographical comparison).

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os,
const DEdge &  e 
) [friend]

Writes a directed edge to an output stream.

Member Data Documentation

size_t dai::DEdge::n1

First node index (source of edge).

size_t dai::DEdge::n2

Second node index (sink of edge).

The documentation for this class was generated from the following file:
Generated on Thu Feb 11 12:26:08 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_48.png0000644000263000017630000000423011334764772015167 0ustar jorismkybPNG  IHDRZMѵ0PLTEppp```PPP@@@000 4tRNS@fIDATh{lUϼՖ(Q"_EE, &ڄ0Ȫ(H1*jle}G5JDhLLT|&j`1[yιwfv[1[ғt3w;s~sν%Cl!S7E1PDY6'OJ.ѫyǔߧ*cEs P6jqr%M jZIRuʲ݀֐Hiјhw{?`9@ey@;F8dŹj؀袿rΙ!˂6@z#sܔObDZm ^9,!5ULp '' Z96 Nೃ`)@a .M G7]g MˑH:N(0T|-|uS9-=Bc< oEּOQi#sO!UHqt ~&'\1/A}TA b 7MF>;P_@\7B 9kqӒHKRBm\ %[)PL@ZgҗD|BHά&yefZD.&AbP@pr54z0Ӽ%_'x1Ηb;'҃eұ@oȍK'iǐ矋V'1@kw9Zт4Uf=G̫&{,8D *IDi1`jai"<0Q"L!)H*4?j߾4-Vl&?k!遜T12#@闓0drme3OOXѣ\ۦ e99+`:kBM-zLFͼZht ,A !lpzڵY=d{zyӃ}Twzi" `tɍ EI݌}qbWr; aqÈ' GHv;_h!O~h$[ 6-Axdk@O5 X(t~Dz0k[393%ԃ#feL}sc"?hkZ}: \1f}>H`!@7Ƃ1 x y>l{3 ..: 1^6bumCGe2[qlʎ1:f`@+pmL:<҅P``@AR_, @Ơ:z.@بra5}F%BH̺.8j6J/nF^L70c|W5Pn0p'\ БIe!OoL+ԃi> :O/=(Piz㊗0O'҃==^ڞ"\[/4nL ԃ+q4S]^FW.p hAp \U|p ԃ/Ws3P@ڭ?l ҃Oz!ԁ֕LFYө`v.ʩs3F׼nJ5C^"`&`Tz81B1ڽ"klpz'!$Qő,OaЮޤw(<=}+ANT"h<%\9b8m@z|e-zމJAq+`TqA`a&҃)=ʟ{^z\_tC郗.h<#LO=G IKBlHLՅ<҈ * &I^IENDB`libDAI-0.2.4/doc/html/functions_vars_0x6c.html0000644000263000017630000001015111334764772017773 0ustar jorismkyb libDAI: Class Members - Variables
 

- l -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/jtree_8h.html0000644000263000017630000000705311334764772015607 0ustar jorismkyb libDAI: include/dai/jtree.h File Reference

include/dai/jtree.h File Reference

Defines class JTree, which implements the junction tree algorithm. More...

#include <vector>
#include <string>
#include <dai/daialg.h>
#include <dai/varset.h>
#include <dai/regiongraph.h>
#include <dai/factorgraph.h>
#include <dai/clustergraph.h>
#include <dai/weightedgraph.h>
#include <dai/enum.h>
#include <dai/properties.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::JTree
 Exact inference algorithm using junction tree. More...
struct  dai::JTree::Properties
 Parameters for JTree. More...

Detailed Description

Defines class JTree, which implements the junction tree algorithm.

Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_86.png0000644000263000017630000000045511334764772015176 0ustar jorismkybPNG  IHDR. 90PLTEppp```PPP@@@000 4tRNS@fIDATc` d$00H4a}d`@`93Hb` im5 F" -pC'c<SDEk|b~+8?/a`  .s*+ΰa*+:f-fc5GHd!R IENDB`libDAI-0.2.4/doc/html/classdai_1_1InfAlg.png0000644000263000017630000000656611334764772017233 0ustar jorismkybPNG  IHDR`H4EPLTE`{tRNS@f IDATx]vHD<;s̜̆_H, ?!"njp!r-K%__!7=w.8X `A,HS˲7|WK|nn._4mawy vnX]R1,X_J!{¾6>.i,%ɴ1m}Kv̲}1(yv`>Jbmۮ`!.-8`A,q l4۫[@ _l1,_E[@ [@ [@ [@ [@ 1:x}7 qa0Ĺy Ck7 qa0Ĺy Ck7 qa0Ĺy Ck7 qa0ĹyzD_t <Ü8<~0CeRyRWXIzux4q|u˟4_\n`ӍTꅲ[wV?Hֵ{?.n{/.{`ǁ:ڸLO9Xi 6~~q)n|0Lޥ^4YZ sWW>+yT>]=>m~H?Ke\ ׁx82Le\ט3z= V;L~A7}m wV-ll뱧]ϼӜ\q7Wp̛_b{uTW˲ aRMrƞ//EJ`u](VoQg 6,oIUsYߤysιu +-ly6cϗZ.?-,mƜ41OJ`6I؇me!x1n_a5{@SRލh]\%s3 vu,NJNRr0ǿNs}6߾qG W+ăݚh{$-+`] >`ί<ݓ?V||C8Xp `!,TH5LWl#q !E[@ [@ [@ [@ [@ [@ [@ [@ [@ [@ [@ [@ [@ SkW <֛^Sk9X `A,HsTV֓ ?5n {~ k`%p^ {o=v3SkEa&p``^㏃`1f3-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-Z/ q 8XLERWOlOn֊5`?k5[g{lbăpފg ֊úQnb=^9Ep 8X L+` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` %A,q quʊ;{:љlLz.u~Jt9ly:]~!5y)+}Xռ4``)+|U>k歸b$ Oռ떝s6SV(Ycr``,q i6 j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-jੵ ~f `A,i|cyQ{:/UlGsV|h+*vl"s,S}4`+`?1ui{᩵"1^>+]XQ89X `A,q ~ʹ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` xj-._8X `AyQ6>An t꼃R0f 6 V.,]i3-,w\)v/XJd,y+L(eԲw`&Q2/;)X&`8X `A,f3-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-Z/ lq 8X%ER˟l"7;/[X= X4M,8iiS͏ VC+:XJ]{ټT\inKG#yz,u?+||`/18X ~?|i6 j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-jੵ ~~ `A,i]Qyg`+r{tlsW%歘eoa_}Xd+R¿s0`A,q OVPl5Pl5Pl5Pl5Pl5Pl5Pl5Pl5Pl5Pl5Pl5Pl5Pl5Pl5Pl5POK68X `A,Hs@/`%㳃5%䇏BqGƹV֓?8XJN?Sla/NP O܇u$)(ي89X `A,q ~ʹ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` xj-._8X `A|7ah|+ v0o` VLiJz.x)[CaCX mzf&q*8)8LY?Nv{HHROC9_v6"٬ mU? libDAI: example_sprinkler_gibbs.cpp

example_sprinkler_gibbs.cpp

This example shows how to use the Gibbs class.

/*  This file is part of libDAI - http://www.libdai.org/
 *
 *  libDAI is licensed under the terms of the GNU General Public License version
 *  2, or (at your option) any later version. libDAI is distributed without any
 *  warranty. See the file COPYING for more details.
 *
 *  Copyright (C) 2010  Joris Mooij  [joris dot mooij at libdai dot org]
 */


#include <dai/factorgraph.h>
#include <dai/gibbs.h>
#include <dai/properties.h>
#include <iostream>
#include <fstream>

using namespace std;
using namespace dai;

int main() {
    // This example program illustrates how to use Gibbs sampling
    // to sample from a joint probability distribution described
    // by a factor graph, using the sprinkler network example discussed at
    // http://www.cs.ubc.ca/~murphyk/Bayes/bnintro.html
    //
    // The file sprinkler.fg has to be generated by first running
    // example_sprinkler

    // Read the factorgraph from the file
    FactorGraph SprinklerNetwork;
    SprinklerNetwork.ReadFromFile( "sprinkler.fg" );
    cout << "Sprinkler network read from sprinkler.fg" << endl;

    // Output some information about the factorgraph
    cout << SprinklerNetwork.nrVars() << " variables" << endl;
    cout << SprinklerNetwork.nrFactors() << " factors" << endl;

    // Prepare a Gibbs sampler
    PropertySet gibbsProps;
    gibbsProps.Set("iters", size_t(100));   // number of Gibbs sampler iterations
    gibbsProps.Set("burnin", size_t(0));
    gibbsProps.Set("verbose", size_t(0));
    Gibbs gibbsSampler( SprinklerNetwork, gibbsProps );

    // Open a .tab file for writing
    ofstream outfile;
    outfile.open( "sprinkler.tab" );
    if( !outfile.is_open() )
        throw "Cannot write to file!";

    // Write header (consisting of variable labels)
    for( size_t i = 0; i < SprinklerNetwork.nrVars(); i++ )
        outfile << (i == 0 ? "" : "\t") << SprinklerNetwork.var(i).label();
    outfile << endl << endl;

    // Draw samples from joint distribution using Gibbs sampling
    // and write them to the .tab file
    size_t nrSamples = 1000;
    std::vector<size_t> state;
    for( size_t t = 0; t < nrSamples; t++ ) {
        gibbsSampler.run();
        state = gibbsSampler.state();
        for( size_t i = 0; i < state.size(); i++ )
            outfile << (i == 0 ? "" : "\t") << state[i];
        outfile << endl;
    }
    cout << nrSamples << " samples written to sprinkler.tab" << endl;

    // Close the .tab file
    outfile.close();

    return 0;
}
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/regiongraph_8h-source.html0000644000263000017630000010145111334764772020276 0ustar jorismkyb libDAI: include/dai/regiongraph.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_95.png0000644000263000017630000000331411334764772015173 0ustar jorismkybPNG  IHDR+#s0PLTEppp```PPP@@@000 4tRNS@fJIDAThYmleskum^c)D"k1,bO"sb1bXdc"@C!FEaQF?1ƄO |=׻QvE~=/{{瞗,t^EZl4E k]Wa|Z< JЫ0-vOiӂ;rrZ"Gݼ3nɉ_&3$Q0 aĂrx(&?YC KݺUxG9jD=g-V~VrJA޵L ZjpXY_qwꎙji8n)hn" 2.n:߃;/Q 9ZE98Q- ߳rs+8 9[I{w[Nbf .@U Izku6j<[AUO$)'wM-ޕ? GPF k 9t[T]+PG|~||̿P E'a'vb(`X,K{:w5=LHMͺ_FiI27eu>ÌCZ9#(8UۢNQ6:7`b:EGQ<"tbŻ_(9j߈H7Lf `Drܠr*^ lrʀ$M`+eƎ8Aar%ⷒ,S︜%,!hC΂ :3zvJDȓ' t=ge:Nrv ;Y]ND h4AehZ)U9EŵS CGC4`ڊ`VDK%75B QNP ?5 {No{Wz vsi?i~4(ĉer|#d_uS[qءXh\[⃍ u.G6Ґ hdE%(&B&:04U#GM&LNƠ؏ {YlQCV/hHD,hx0л fָ?oXIh58!QW}`io Lˑ07lM Gfiް#Ca1u׬Q,%t5C9,Fb|U$D8v2Y̷i5&%2rc֔CqND|.J'aJ08~xqޏֻc @= YCv;iߠl!DӸp)x4?9`!Ħ 4-,C~HjVN[,M E`dH_Z6zq.fY"OA2MY<0٪3ANk?Y,98CJ&5 -Ң(K[fa۴d'YЬjPj?~)53zg<IENDB`libDAI-0.2.4/doc/html/bp_8h-source.html0000644000263000017630000012613011334764772016373 0ustar jorismkyb libDAI: include/dai/bp.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1CondProbEstimation.png0000644000263000017630000000111011334764772021612 0ustar jorismkybPNG  IHDRP*{PLTE`{tRNS@fIDATX[n! E`j7G UqL>WZe7%/D:W?Q-3%Ģ,h;UD$5&$ N.>K:iv2U',{Jt!dx(y|Gֺ͋mE:/J#q@7p@W,JEo8u1Gj=Xv\U${{yHT߀Zc7fY+Ӟ\>z<[Z-`by&w X-`by&w X-`by&w X~ Y q Wמ S+ 0JYR xt+ i ɫ"fԭ*~4X,b TD=ǶX]cIUl x ZlKdե-Wx̪{ libDAI: example_sprinkler_em.cpp

example_sprinkler_em.cpp

This example shows how to use the EMAlg class.

/*  This file is part of libDAI - http://www.libdai.org/
 *
 *  libDAI is licensed under the terms of the GNU General Public License version
 *  2, or (at your option) any later version. libDAI is distributed without any
 *  warranty. See the file COPYING for more details.
 *
 *  Copyright (C) 2010  Joris Mooij  [joris dot mooij at libdai dot org]
 */

#include <dai/alldai.h>
#include <iostream>
#include <fstream>
#include <string>

using namespace std;
using namespace dai;

int main() {
    // This example program illustrates how to learn the
    // parameters of a Bayesian network from a sample of
    // the sprinkler network discussed at
    // http://www.cs.ubc.ca/~murphyk/Bayes/bnintro.html
    //
    // The factor graph file (sprinkler.fg) has to be generated first
    // by running example_sprinkler, and the data sample file 
    // (sprinkler.tab) by running example_sprinkler_gibbs

    // Read the factorgraph from the file
    FactorGraph SprinklerNetwork;
    SprinklerNetwork.ReadFromFile( "sprinkler.fg" );

    // Prepare junction-tree object for doing exact inference for E-step
    PropertySet infprops;
    infprops.Set( "verbose", (size_t)1 );
    infprops.Set( "updates", string("HUGIN") );
    InfAlg* inf = newInfAlg( "JTREE", SprinklerNetwork, infprops );
    inf->init();

    // Read sample from file
    Evidence e;
    ifstream estream( "sprinkler.tab" );
    e.addEvidenceTabFile( estream, SprinklerNetwork );
    cout << "Number of samples: " << e.nrSamples() << endl;

    // Read EM specification
    ifstream emstream( "sprinkler.em" );
    EMAlg em(e, *inf, emstream);

    // Iterate EM until convergence
    while( !em.hasSatisfiedTermConditions() ) {
        Real l = em.iterate();
        cout << "Iteration " << em.Iterations() << " likelihood: " << l <<endl;
    }

    // Output true factor graph
    cout << endl << "True factor graph:" << endl << "##################" << endl;
    cout.precision(12);
    cout << SprinklerNetwork;

    // Output learned factor graph
    cout << endl << "Learned factor graph:" << endl << "#####################" << endl;
    cout.precision(12);
    cout << inf->fg();

    // Clean up
    delete inf;

    return 0;
}
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_0x6b.html0000644000263000017630000001041411334764772016741 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- k -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1Exception-members.html0000644000263000017630000002132011334764772021622 0ustar jorismkyb libDAI: Member List

dai::Exception Member List

This is the complete list of members for dai::Exception, including all inherited members.

ASSERTION_FAILED enum value (defined in dai::Exception)dai::Exception
BELIEF_NOT_AVAILABLE enum value (defined in dai::Exception)dai::Exception
CANNOT_READ_FILE enum value (defined in dai::Exception)dai::Exception
CANNOT_WRITE_FILE enum value (defined in dai::Exception)dai::Exception
Code enum namedai::Exception
code() const dai::Exception [inline]
errorcodedai::Exception [private]
ErrorStringsdai::Exception [private, static]
Exception(Code _code, const std::string &msg="", const std::string &detailedMsg="")dai::Exception [inline]
FACTORGRAPH_NOT_CONNECTED enum value (defined in dai::Exception)dai::Exception
IMPOSSIBLE_TYPECAST enum value (defined in dai::Exception)dai::Exception
INTERNAL_ERROR enum value (defined in dai::Exception)dai::Exception
INVALID_ALIAS enum value (defined in dai::Exception)dai::Exception
INVALID_EMALG_FILE enum value (defined in dai::Exception)dai::Exception
INVALID_EVIDENCE_FILE enum value (defined in dai::Exception)dai::Exception
INVALID_FACTORGRAPH_FILE enum value (defined in dai::Exception)dai::Exception
MALFORMED_PROPERTY enum value (defined in dai::Exception)dai::Exception
message(const Code c) const dai::Exception [inline]
MULTIPLE_UNDO enum value (defined in dai::Exception)dai::Exception
NOT_ALL_PROPERTIES_SPECIFIED enum value (defined in dai::Exception)dai::Exception
NOT_IMPLEMENTED enum value (defined in dai::Exception)dai::Exception
NOT_NORMALIZABLE enum value (defined in dai::Exception)dai::Exception
NUM_ERRORS enum value (defined in dai::Exception)dai::Exception
OBJECT_NOT_FOUND enum value (defined in dai::Exception)dai::Exception
RUNTIME_ERROR enum value (defined in dai::Exception)dai::Exception
UNKNOWN_DAI_ALGORITHM enum value (defined in dai::Exception)dai::Exception
UNKNOWN_ENUM_VALUE enum value (defined in dai::Exception)dai::Exception
UNKNOWN_PARAMETER_ESTIMATION_METHOD enum value (defined in dai::Exception)dai::Exception
UNKNOWN_PROPERTY enum value (defined in dai::Exception)dai::Exception
UNKNOWN_PROPERTY_TYPE enum value (defined in dai::Exception)dai::Exception

Generated on Thu Feb 11 12:26:04 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_122.png0000644000263000017630000000026311334764772015242 0ustar jorismkybPNG  IHDR r0PLTEppp```PPP@@@000 4tRNS@f1IDATc`@ + H0o @#?Hw/iIENDB`libDAI-0.2.4/doc/html/form_142.png0000644000263000017630000000043011334764772015240 0ustar jorismkybPNG  IHDRֹ0PLTEppp```PPP@@@000 4tRNS@fIDATc`&0J7Bi(CR@&_8H@ X3o`H p7R.@-??07@3,aV`̣r`f~^q`ЀB6p@ libDAI: Member List

dai::UEdge Member List

This is the complete list of members for dai::UEdge, including all inherited members.

first (defined in dai::UEdge)dai::UEdge
n1 (defined in dai::UEdge)dai::UEdge
n2 (defined in dai::UEdge)dai::UEdge
operator<(const UEdge &x) const dai::UEdge [inline]
operator<<(std::ostream &os, const UEdge &e)dai::UEdge [friend]
operator==(const UEdge &x)dai::UEdge [inline]
second (defined in dai::UEdge)dai::UEdge
UEdge()dai::UEdge [inline]
UEdge(size_t m1, size_t m2)dai::UEdge [inline]
UEdge(const DEdge &e)dai::UEdge [inline]

Generated on Thu Feb 11 12:26:08 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1EMAlg.html0000644000263000017630000011745611334764772017201 0ustar jorismkyb libDAI: dai::EMAlg Class Reference

dai::EMAlg Class Reference

EMAlg performs Expectation Maximization to learn factor parameters. More...

#include <dai/emalg.h>

List of all members.

Iterator interface

typedef std::vector
< MaximizationStep >::iterator 		s_iterator
 Iterator over the maximization steps.
typedef std::vector
< MaximizationStep >
::const_iterator 		const_s_iterator
 Constant iterator over the maximization steps.
s_iterator s_begin ()
 Returns iterator that points to the first maximization step.
const_s_iterator s_begin () const
 Returns constant iterator that points to the first maximization step.
s_iterator s_end ()
 Returns iterator that points beyond the last maximization step.
const_s_iterator s_end () const
 Returns constant iterator that points beyond the last maximization step.

Public Member Functions

 EMAlg (const Evidence &evidence, InfAlg &estep, std::vector< MaximizationStep > &msteps, const PropertySet &termconditions)
 Construct an EMAlg from several objects.
 EMAlg (const Evidence &evidence, InfAlg &estep, std::istream &mstep_file)
 Construct an EMAlg from Evidence evidence, an InfAlg estep, and an input stream mstep_file.
void setTermConditions (const PropertySet &p)
 Change the conditions for termination.
bool hasSatisfiedTermConditions () const
 Determine if the termination conditions have been met.
Real logZ () const
 Return the last calculated log likelihood.
size_t Iterations () const
 Returns number of iterations done so far.
const InfAlg & eStep () const
 Get the E-step method used.
Real iterate ()
 Iterate once over all maximization steps.
Real iterate (MaximizationStep &mstep)
 Iterate over a single MaximizationStep.
void run ()
 Iterate until termination conditions are satisfied.

Static Public Attributes

static const std::string MAX_ITERS_KEY
 Key for setting maximum iterations.
static const size_t MAX_ITERS_DEFAULT = 30
 Default maximum iterations.
static const std::string LOG_Z_TOL_KEY
 Key for setting likelihood termination condition.
static const Real LOG_Z_TOL_DEFAULT = 0.01
 Default likelihood tolerance.

Private Attributes

const Evidence & _evidence
 All the data samples used during learning.
InfAlg & _estep
 How to do the expectation step.
std::vector< MaximizationStep > _msteps
 The maximization steps to take.
size_t _iters
 Number of iterations done.
std::vector< Real > _lastLogZ
 History of likelihoods.
size_t _max_iters
 Maximum number of iterations.
Real _log_z_tol
 Convergence tolerance.

Detailed Description

EMAlg performs Expectation Maximization to learn factor parameters.

This requires specifying:

  • Evidence (instances of observations from the graphical model),
  • InfAlg for performing the E-step (which includes the factor graph),
  • a vector of MaximizationStep 's steps to be performed.

This implementation can perform incremental EM by using multiple MaximizationSteps. An expectation step is performed between execution of each MaximizationStep. A call to iterate() will cycle through all MaximizationStep 's. A call to run() will call iterate() until the termination criteria have been met.

Having multiple and separate maximization steps allows for maximizing some parameters, performing another E-step, and then maximizing separate parameters, which may result in faster convergence in some cases.

Author:
Charles Vaske
Examples:

example_sprinkler_em.cpp.

Member Typedef Documentation

typedef std::vector<MaximizationStep>::iterator dai::EMAlg::s_iterator

Iterator over the maximization steps.

typedef std::vector<MaximizationStep>::const_iterator dai::EMAlg::const_s_iterator

Constant iterator over the maximization steps.

Constructor & Destructor Documentation

dai::EMAlg::EMAlg ( const Evidence &  evidence,
InfAlg &  estep,
std::vector< MaximizationStep > &  msteps,
const PropertySet &  termconditions 
) [inline]

Construct an EMAlg from several objects.

Parameters:
evidence Specifies the observed evidence
estep Inference algorithm to be used for the E-step
msteps Vector of maximization steps, each of which is a group of parameter estimation tasks
termconditions Termination conditions
See also:
setTermConditions()

dai::EMAlg::EMAlg ( const Evidence &  evidence,
InfAlg &  estep,
std::istream &  mstep_file 
)

Construct an EMAlg from Evidence evidence, an InfAlg estep, and an input stream mstep_file.

See also:
Expectation Maximization (.em) file format

Member Function Documentation

void dai::EMAlg::setTermConditions ( const PropertySet &  p  ) 

Change the conditions for termination.

There are two possible parameters in the PropertySet p:

  • max_iters maximum number of iterations
  • log_z_tol critical proportion of increase in logZ

See also:
hasSatisifiedTermConditions()

bool dai::EMAlg::hasSatisfiedTermConditions (  )  const

Determine if the termination conditions have been met.

There are two sufficient termination conditions:

  1. the maximum number of iterations has been performed
  2. the ratio of logZ increase over previous logZ is less than the tolerance, i.e., $ \frac{\log(Z_t) - \log(Z_{t-1})}{| \log(Z_{t-1}) | } < \mathrm{tol} $.
Examples:
example_sprinkler_em.cpp.

Real dai::EMAlg::logZ (  )  const [inline]

Return the last calculated log likelihood.

size_t dai::EMAlg::Iterations (  )  const [inline]

Returns number of iterations done so far.

Examples:
example_sprinkler_em.cpp.

const InfAlg& dai::EMAlg::eStep (  )  const [inline]

Get the E-step method used.

Real dai::EMAlg::iterate (  ) 

Iterate once over all maximization steps.

Returns:
Log-likelihood after iteration
Examples:
example_sprinkler_em.cpp.

Real dai::EMAlg::iterate ( MaximizationStep &  mstep  ) 

Iterate over a single MaximizationStep.

void dai::EMAlg::run (  ) 

Iterate until termination conditions are satisfied.

s_iterator dai::EMAlg::s_begin (  )  [inline]

Returns iterator that points to the first maximization step.

const_s_iterator dai::EMAlg::s_begin (  )  const [inline]

Returns constant iterator that points to the first maximization step.

s_iterator dai::EMAlg::s_end (  )  [inline]

Returns iterator that points beyond the last maximization step.

const_s_iterator dai::EMAlg::s_end (  )  const [inline]

Returns constant iterator that points beyond the last maximization step.

Member Data Documentation

const Evidence& dai::EMAlg::_evidence [private]

All the data samples used during learning.

InfAlg& dai::EMAlg::_estep [private]

How to do the expectation step.

std::vector<MaximizationStep> dai::EMAlg::_msteps [private]

The maximization steps to take.

size_t dai::EMAlg::_iters [private]

Number of iterations done.

std::vector<Real> dai::EMAlg::_lastLogZ [private]

History of likelihoods.

size_t dai::EMAlg::_max_iters [private]

Maximum number of iterations.

Real dai::EMAlg::_log_z_tol [private]

Convergence tolerance.

const std::string dai::EMAlg::MAX_ITERS_KEY [static]

Key for setting maximum iterations.

const size_t dai::EMAlg::MAX_ITERS_DEFAULT = 30 [static]

Default maximum iterations.

const std::string dai::EMAlg::LOG_Z_TOL_KEY [static]

Key for setting likelihood termination condition.

const Real dai::EMAlg::LOG_Z_TOL_DEFAULT = 0.01 [static]

Default likelihood tolerance.

The documentation for this class was generated from the following files:
Generated on Thu Feb 11 12:26:03 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_vars_0x74.html0000644000263000017630000001156411334764772017726 0ustar jorismkyb libDAI: Class Members - Variables
 

- t -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1RegionGraph-members.html0000644000263000017630000005513611334764772022105 0ustar jorismkyb libDAI: Member List

dai::RegionGraph Member List

This is the complete list of members for dai::RegionGraph, including all inherited members.

backupFactor(size_t I)dai::FactorGraph
backupFactors(const std::set< size_t > &facs)dai::FactorGraph [virtual]
backupFactors(const VarSet &ns)dai::FactorGraph
begin()dai::FactorGraph [inline]
begin() const dai::FactorGraph [inline]
calcCountingNumbers()dai::RegionGraph
checkCountingNumbers() const dai::RegionGraph
clamp(size_t i, size_t x, bool backup=false)dai::FactorGraph [virtual]
clamped(size_t i, size_t x) const dai::FactorGraph
clampFactor(size_t I, const std::vector< size_t > &xIs, bool backup=false)dai::FactorGraph
clampVar(size_t i, const std::vector< size_t > &xis, bool backup=false)dai::FactorGraph
Cliques() const dai::FactorGraph
clone() const dai::RegionGraph [inline, virtual]
const_iterator typedefdai::FactorGraph
construct(const FactorGraph &fg, const std::vector< VarSet > &ors, const std::vector< Region > &irs, const std::vector< std::pair< size_t, size_t > > &edges)dai::RegionGraph [protected]
constructCVM(const FactorGraph &fg, const std::vector< VarSet > &cl)dai::RegionGraph [protected]
Delta(size_t i) const dai::FactorGraph
Delta(const VarSet &vs) const dai::FactorGraph
delta(size_t i) const dai::FactorGraph
delta(const VarSet &vs) const dai::FactorGraph [inline]
Edge typedefdai::FactorGraph
end()dai::FactorGraph [inline]
end() const dai::FactorGraph [inline]
fac2ORdai::RegionGraph
factor(size_t I)dai::FactorGraph [inline]
factor(size_t I) const dai::FactorGraph [inline]
FactorGraph()dai::FactorGraph [inline]
FactorGraph(const std::vector< Factor > &P)dai::FactorGraph
FactorGraph(FactorInputIterator fact_begin, FactorInputIterator fact_end, VarInputIterator var_begin, VarInputIterator var_end, size_t nr_fact_hint=0, size_t nr_var_hint=0)dai::FactorGraph [inline]
factors() const dai::FactorGraph [inline]
findFactor(const VarSet &ns) const dai::FactorGraph [inline]
findVar(const Var &n) const dai::FactorGraph [inline]
findVars(VarSet &ns) const dai::FactorGraph [inline]
Gdai::RegionGraph
IR(size_t beta) const dai::RegionGraph [inline]
IR(size_t beta)dai::RegionGraph [inline]
IRsdai::RegionGraph
isBinary() const dai::FactorGraph
isConnected() const dai::FactorGraph [inline]
isPairwise() const dai::FactorGraph
isTree() const dai::FactorGraph [inline]
iterator typedefdai::FactorGraph
makeCavity(size_t i, bool backup=false)dai::FactorGraph [virtual]
maximalFactors() const dai::FactorGraph
nbF(size_t I) const dai::FactorGraph [inline]
nbF(size_t I, size_t _i) const dai::FactorGraph [inline]
nbIR(size_t beta) const dai::RegionGraph [inline]
nbOR(size_t alpha) const dai::RegionGraph [inline]
nbV(size_t i) const dai::FactorGraph [inline]
nbV(size_t i, size_t _I) const dai::FactorGraph [inline]
Neighbor typedefdai::FactorGraph
Neighbors typedefdai::FactorGraph
nrEdges() const dai::FactorGraph [inline]
nrFactors() const dai::FactorGraph [inline]
nrIRs() const dai::RegionGraph [inline]
nrORs() const dai::RegionGraph [inline]
nrVars() const dai::FactorGraph [inline]
operator<<(std::ostream &os, const RegionGraph &rg)dai::RegionGraph [friend]
dai::FactorGraph::operator<<(std::ostream &os, const FactorGraph &fg)dai::FactorGraph [friend]
operator>>(std::istream &is, FactorGraph &fg)dai::FactorGraph [friend]
OR(size_t alpha) const dai::RegionGraph [inline]
OR(size_t alpha)dai::RegionGraph [inline]
ORsdai::RegionGraph
printDot(std::ostream &os) const dai::FactorGraph
ReadFromFile(const char *filename)dai::FactorGraph
RecomputeOR(size_t I)dai::RegionGraph
RecomputeORs()dai::RegionGraph
RecomputeORs(const VarSet &vs)dai::RegionGraph
RegionGraph()dai::RegionGraph [inline]
RegionGraph(const FactorGraph &fg)dai::RegionGraph [inline]
RegionGraph(const FactorGraph &fg, const std::vector< VarSet > &ors, const std::vector< Region > &irs, const std::vector< std::pair< size_t, size_t > > &edges)dai::RegionGraph [inline]
RegionGraph(const FactorGraph &fg, const std::vector< Region > &ors, const std::vector< Region > &irs, const std::vector< std::pair< size_t, size_t > > &edges)dai::RegionGraph
RegionGraph(const FactorGraph &fg, const std::vector< VarSet > &cl)dai::RegionGraph [inline]
restoreFactor(size_t I)dai::FactorGraph
restoreFactors()dai::FactorGraph [virtual]
restoreFactors(const VarSet &ns)dai::FactorGraph
setFactor(size_t I, const Factor &newFactor, bool backup=false)dai::RegionGraph [inline, virtual]
setFactors(const std::map< size_t, Factor > &facs, bool backup=false)dai::RegionGraph [inline, virtual]
var(size_t i) const dai::FactorGraph [inline]
vars() const dai::FactorGraph [inline]
WriteToFile(const char *filename, size_t precision=15) const dai::FactorGraph
~FactorGraph()dai::FactorGraph [inline, virtual]

Generated on Thu Feb 11 12:26:07 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_133.png0000644000263000017630000000104111334764772015237 0ustar jorismkybPNG  IHDRBe0PLTEppp```PPP@@@000 4tRNS@fIDAT8͒K@ƟKҤMbpVqK"C,vp&?Ե:55%Ero~y$ 0gxYhc\$Nӡ4DMH|>#,$͘`i;Ɣے:!,$!PCoyZNш҆Zt PST6ܙm$f8RC$OJg >$|mB -|!Z6-1 !yAJ8N6%;ďf6?E!% libDAI: dai::ParameterEstimation Class Reference

dai::ParameterEstimation Class Reference

Base class for parameter estimation methods. More...

#include <dai/emalg.h>

Inheritance diagram for dai::ParameterEstimation:

dai::CondProbEstimation

List of all members.

Public Types

typedef ParameterEstimation *(* ParamEstFactory )(const PropertySet &)
 Type of pointer to factory function.

Public Member Functions

virtual ~ParameterEstimation ()
 Virtual destructor for deleting pointers to derived classes.
virtual ParameterEstimation * clone () const =0
 Virtual copy constructor.
virtual Prob estimate ()=0
 Estimate the factor using the accumulated sufficient statistics and reset.
virtual void addSufficientStatistics (const Prob &p)=0
 Accumulate the sufficient statistics for p.
virtual size_t probSize () const =0
 Returns the size of the Prob that should be passed to addSufficientStatistics.

Static Public Member Functions

static ParameterEstimation * construct (const std::string &method, const PropertySet &p)
 General factory method that constructs the desired ParameterEstimation subclass.
static void registerMethod (const std::string &method, const ParamEstFactory &f)
 Register a subclass so that it can be used with construct().

Static Private Member Functions

static void loadDefaultRegistry ()
 Registers default ParameterEstimation subclasses (currently, only CondProbEstimation).

Static Private Attributes

static std::map< std::string,
ParamEstFactory > * 		_registry = NULL
 A static registry containing all methods registered so far.

Detailed Description

Base class for parameter estimation methods.

This class defines the general interface of parameter estimation methods.

Implementations of this interface (see e.g. CondProbEstimation) should register a factory function (virtual constructor) via the static registerMethod() function. This factory function should return a pointer to a newly constructed object, whose type is a subclass of ParameterEstimation, and gets as input a PropertySet of parameters. After a subclass has been registered, instances of it can be constructed using the construct() method.

Implementations are responsible for collecting data from a probability vector passed to it from a SharedParameters container object.

The default registry only contains CondProbEstimation, named "CondProbEstimation".

Author:
Charles Vaske

Member Typedef Documentation

typedef ParameterEstimation*(* dai::ParameterEstimation::ParamEstFactory)(const PropertySet &)

Type of pointer to factory function.

Constructor & Destructor Documentation

virtual dai::ParameterEstimation::~ParameterEstimation (  )  [inline, virtual]

Virtual destructor for deleting pointers to derived classes.

Member Function Documentation

virtual ParameterEstimation* dai::ParameterEstimation::clone (  )  const [pure virtual]

Virtual copy constructor.

Implemented in dai::CondProbEstimation.

ParameterEstimation * dai::ParameterEstimation::construct ( const std::string &  method,
const PropertySet &  p 
) [static]

General factory method that constructs the desired ParameterEstimation subclass.

Parameters:
method Name of the subclass that should be constructed;
p Parameters passed to constructor of subclass.
Note:
method should either be in the default registry or should be registered first using registerMethod().
Exceptions:
UNKNOWN_PARAMETER_ESTIMATION_METHOD if the requested method is not registered.

static void dai::ParameterEstimation::registerMethod ( const std::string &  method,
const ParamEstFactory &  f 
) [inline, static]

Register a subclass so that it can be used with construct().

virtual Prob dai::ParameterEstimation::estimate (  )  [pure virtual]

Estimate the factor using the accumulated sufficient statistics and reset.

Implemented in dai::CondProbEstimation.

virtual void dai::ParameterEstimation::addSufficientStatistics ( const Prob &  p  )  [pure virtual]

Accumulate the sufficient statistics for p.

Implemented in dai::CondProbEstimation.

virtual size_t dai::ParameterEstimation::probSize (  )  const [pure virtual]

Returns the size of the Prob that should be passed to addSufficientStatistics.

Implemented in dai::CondProbEstimation.

void dai::ParameterEstimation::loadDefaultRegistry (  )  [static, private]

Registers default ParameterEstimation subclasses (currently, only CondProbEstimation).

Member Data Documentation

std::map< std::string, ParameterEstimation::ParamEstFactory > * dai::ParameterEstimation::_registry = NULL [static, private]

A static registry containing all methods registered so far.

The documentation for this class was generated from the following files:
Generated on Thu Feb 11 12:26:03 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1CBP.png0000644000263000017630000000104311334764772016460 0ustar jorismkybPNG  IHDR<)PLTE`{tRNS@fIDAThAr0 x'HH񴡍T`Lc.ilHvAvH7D=!&V @BKe$d Sp:Zw@Is 1Y@D4~ c[a<zt瓁4=8,88bT7 ,D&Rě{b2E9zW Ԙ$q4? J `.ʧr1Ȁ$&ְ;rfB=U 頤Ky `;,1E #1Y =pVj#:6brspx=*^Xn<А^ umBo41GAQGج] P3 Bri~.'[܉IENDB`libDAI-0.2.4/doc/html/functions_0x70.html0000644000263000017630000001547411334764772016673 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- p -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_18.png0000644000263000017630000000054111334764772015165 0ustar jorismkybPNG  IHDR00PLTEppp```PPP@@@000 4tRNS@fIDATc`  0A(;vPp :Bm@D1(% ! |h``b6~fVsd~14>l +CWC<q6jD4'Mml AvL`<HL DH1|d`T`<%ә} C8  P3^dpf`X(b 批000P2'6s#T_IENDB`libDAI-0.2.4/doc/html/form_102.png0000644000263000017630000000046411334764772015243 0ustar jorismkybPNG  IHDR60PLTEppp```PPP@@@000 4tRNS@fIDATc` bj* $8c\Hj$8A UnG0ώA^s̙!r>3c7`t EGGGDP # libDAI: dai::MF Class Reference

dai::MF Class Reference

Approximate inference algorithm "Mean Field". More...

#include <dai/mf.h>

Inheritance diagram for dai::MF:

dai::DAIAlg< GRM > dai::InfAlg

List of all members.

Public Member Functions

Constructors/destructors
 MF ()
 Default constructor.
 MF (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts.
General InfAlg interface
virtual MF * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
virtual std::string identify () const
 Identifies itself for logging purposes.
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable.
virtual Factor belief (const VarSet &vs) const
 Returns the (approximate) marginal probability distribution of a set of variables.
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i.
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).
virtual void init ()
 Initializes all data structures of the approximate inference algorithm.
virtual void init (const VarSet &ns)
 Initializes all data structures corresponding to some set of variables.
virtual Real run ()
 Runs the approximate inference algorithm.
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration.
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph).
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm.
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet.
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Public Attributes

struct dai::MF::Properties props

Static Public Attributes

static const char * Name = "MF"
 Name of this inference algorithm.

Private Member Functions

void construct ()
 Helper function for constructors.
Factor calcNewBelief (size_t i)
 Calculates an updated belief of variable i.

Private Attributes

std::vector< Factor > _beliefs
 Current approximations of single variable marginals.
Real _maxdiff
 Maximum difference encountered so far.
size_t _iters
 Number of iterations needed.

Classes

struct  Properties
 Parameters for MF. More...

Detailed Description

Approximate inference algorithm "Mean Field".

The Mean Field algorithm iteratively calculates approximations of single variable marginals (beliefs). The update equation for a single belief $b_i$ is given by:

\[ b_i^{\mathrm{new}}(x_i) \propto \prod_{I\in N_i} \exp \left( \sum_{x_{N_I \setminus \{i\}}} \log f_I(x_I) \prod_{j \in N_I \setminus \{i\}} b_j(x_j) \right) \]

These update equations are performed for all variables until convergence.

Constructor & Destructor Documentation

dai::MF::MF (  )  [inline]

Default constructor.

dai::MF::MF ( const FactorGraph &  fg,
const PropertySet &  opts 
) [inline]

Construct from FactorGraph fg and PropertySet opts.

Parameters:
opts Parameters
See also:
Properties

Member Function Documentation

virtual MF* dai::MF::clone (  )  const [inline, virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Implements dai::InfAlg.

string dai::MF::identify (  )  const [virtual]

Identifies itself for logging purposes.

Implements dai::InfAlg.

virtual Factor dai::MF::belief ( const Var &  v  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of a variable.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

Factor dai::MF::belief ( const VarSet &  vs  )  const [virtual]

Returns the (approximate) marginal probability distribution of a set of variables.

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported.
BELIEF_NOT_AVAILABLE if the requested belief cannot be calculated with this algorithm.

Implements dai::InfAlg.

Factor dai::MF::beliefV ( size_t  i  )  const [virtual]

Returns the (approximate) marginal probability distribution of the variable with index i.

For some approximate inference algorithms, using beliefV() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

vector< Factor > dai::MF::beliefs (  )  const [virtual]

Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.

Note:
Before this method is called, run() should have been called.

Implements dai::InfAlg.

Real dai::MF::logZ (  )  const [virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

void dai::MF::init (  )  [virtual]

Initializes all data structures of the approximate inference algorithm.

Note:
This method should be called at least once before run() is called.

Implements dai::InfAlg.

void dai::MF::init ( const VarSet &  vs  )  [virtual]

Initializes all data structures corresponding to some set of variables.

This method can be used to do a partial initialization after a part of the factor graph has changed. Instead of initializing all data structures, it only initializes those involving the variables in vs.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

Real dai::MF::run (  )  [virtual]

Runs the approximate inference algorithm.

Note:
Before run() is called the first time, init() should have been called.

Implements dai::InfAlg.

virtual Real dai::MF::maxDiff (  )  const [inline, virtual]

Returns maximum difference between single variable beliefs in the last iteration.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

virtual size_t dai::MF::Iterations (  )  const [inline, virtual]

Returns number of iterations done (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

void dai::MF::setProperties ( const PropertySet &  opts  )  [virtual]

Set parameters of this inference algorithm.

The parameters are set according to the PropertySet opts. The values can be stored either as std::string or as the type of the corresponding MF::props member.

Implements dai::InfAlg.

PropertySet dai::MF::getProperties (  )  const [virtual]

Returns parameters of this inference algorithm converted into a PropertySet.

Implements dai::InfAlg.

string dai::MF::printProperties (  )  const [virtual]

Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Implements dai::InfAlg.

void dai::MF::construct (  )  [private]

Helper function for constructors.

Factor dai::MF::calcNewBelief ( size_t  i  )  [private]

Calculates an updated belief of variable i.

Member Data Documentation

std::vector<Factor> dai::MF::_beliefs [private]

Current approximations of single variable marginals.

Real dai::MF::_maxdiff [private]

Maximum difference encountered so far.

size_t dai::MF::_iters [private]

Number of iterations needed.

const char * dai::MF::Name = "MF" [static]

Name of this inference algorithm.

The documentation for this class was generated from the following files:
  • include/dai/mf.h
  • src/mf.cpp
Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_90.png0000644000263000017630000000044111334764772015164 0ustar jorismkybPNG  IHDR, B0PLTEppp```PPP@@@000 4tRNS@fIDATc`2:  <`:sTp=CNH@^DNf`Z@ S j6;oB@!,1:$.X L[.^1k@JzE'+V"{QP^N5 IENDB`libDAI-0.2.4/doc/html/form_47.png0000644000263000017630000000050611334764772015170 0ustar jorismkybPNG  IHDR30PLTEppp```PPP@@@000 4tRNS@fIDATc`  03:II$'AAp G{0y8 Kq ,ia`FхdC/)3*c>,e=#Q,b libDAI: Class Members - Variables
 

- i -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1TFactor-members.html0000644000263000017630000004401611334764772021235 0ustar jorismkyb libDAI: Member List

dai::TFactor< T > Member List

This is the complete list of members for dai::TFactor< T >, including all inherited members.

_pdai::TFactor< T > [private]
_vsdai::TFactor< T > [private]
abs() const dai::TFactor< T > [inline]
binaryOp(const TFactor< T > &g, binOp op)dai::TFactor< T > [inline]
binaryTr(const TFactor< T > &g, binOp op) const dai::TFactor< T > [inline]
dist(const TFactor< T > &f, const TFactor< T > &g, typename TProb< T >::DistType dt)dai::TFactor< T > [related]
embed(const VarSet &vars) const dai::TFactor< T > [inline]
entropy() const dai::TFactor< T > [inline]
exp() const dai::TFactor< T > [inline]
fill(T x)dai::TFactor< T > [inline]
hasNaNs() const dai::TFactor< T > [inline]
hasNegatives() const dai::TFactor< T > [inline]
inverse(bool zero=true) const dai::TFactor< T > [inline]
log(bool zero=false) const dai::TFactor< T > [inline]
marginal(const VarSet &vars, bool normed=true) const dai::TFactor< T > [inline]
max() const dai::TFactor< T > [inline]
max(const TFactor< T > &f, const TFactor< T > &g)dai::TFactor< T > [related]
maxAbs() const dai::TFactor< T > [inline]
maxMarginal(const VarSet &vars, bool normed=true) const dai::TFactor< T > [inline]
min() const dai::TFactor< T > [inline]
min(const TFactor< T > &f, const TFactor< T > &g)dai::TFactor< T > [related]
MutualInfo(const TFactor< T > &f)dai::TFactor< T > [related]
normalize(typename TProb< T >::NormType norm=TProb< T >::NORMPROB)dai::TFactor< T > [inline]
normalized(typename TProb< T >::NormType norm=TProb< T >::NORMPROB) const dai::TFactor< T > [inline]
operator*(T x) const dai::TFactor< T > [inline]
operator*(const TFactor< T > &g) const dai::TFactor< T > [inline]
operator*=(T x)dai::TFactor< T > [inline]
operator*=(const TFactor< T > &g)dai::TFactor< T > [inline]
operator+(T x) const dai::TFactor< T > [inline]
operator+(const TFactor< T > &g) const dai::TFactor< T > [inline]
operator+=(T x)dai::TFactor< T > [inline]
operator+=(const TFactor< T > &g)dai::TFactor< T > [inline]
operator-(T x) const dai::TFactor< T > [inline]
operator-(const TFactor< T > &g) const dai::TFactor< T > [inline]
operator-=(T x)dai::TFactor< T > [inline]
operator-=(const TFactor< T > &g)dai::TFactor< T > [inline]
operator/(T x) const dai::TFactor< T > [inline]
operator/(const TFactor< T > &g) const dai::TFactor< T > [inline]
operator/=(T x)dai::TFactor< T > [inline]
operator/=(const TFactor< T > &g)dai::TFactor< T > [inline]
operator<<(std::ostream &os, const TFactor< T > &f)dai::TFactor< T > [related]
operator[](size_t i) const dai::TFactor< T > [inline]
operator[](size_t i)dai::TFactor< T > [inline]
operator^(T x) const dai::TFactor< T > [inline]
operator^=(T x)dai::TFactor< T > [inline]
p() const dai::TFactor< T > [inline]
p()dai::TFactor< T > [inline]
randomize()dai::TFactor< T > [inline]
setUniform()dai::TFactor< T > [inline]
slice(const VarSet &vars, size_t varsState) const dai::TFactor< T > [inline]
states() const dai::TFactor< T > [inline]
strength(const Var &i, const Var &j) const dai::TFactor< T > [inline]
sum() const dai::TFactor< T > [inline]
TFactor(T p=1)dai::TFactor< T > [inline]
TFactor(const Var &v)dai::TFactor< T > [inline]
TFactor(const VarSet &vars)dai::TFactor< T > [inline]
TFactor(const VarSet &vars, T p)dai::TFactor< T > [inline]
TFactor(const VarSet &vars, const std::vector< S > &x)dai::TFactor< T > [inline]
TFactor(const VarSet &vars, const T *p)dai::TFactor< T > [inline]
TFactor(const VarSet &vars, const TProb< T > &p)dai::TFactor< T > [inline]
TFactor(const std::vector< Var > &vars, const std::vector< T > &p)dai::TFactor< T > [inline]
vars() const dai::TFactor< T > [inline]
vars()dai::TFactor< T > [inline]

Generated on Thu Feb 11 12:26:04 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_23.png0000644000263000017630000000050311334764772015157 0ustar jorismkybPNG  IHDR00PLTEppp```PPP@@@000 4tRNS@fIDATc` 085(*3v 6 < bl @Xe`*dP`Pà+.``f`a`X?X@v(? B$d:3$7̜+ր @ N`vSA>gM`^b @keMa &E#IַIENDB`libDAI-0.2.4/doc/html/form_82.png0000644000263000017630000000210011334764772015157 0ustar jorismkybPNG  IHDR&TH0PLTEppp```PPP@@@000 4tRNS@fIDATXݖOhWǿf2;33 B =d5EClP,6x ZZ\)+XKsV`ORz &Ro7ߺkֹ ̼o~y{࣑ w8 9%ݝǒGzN'G?oHEfPg)9,>,LC.1%b/j s "]YoE\b~W 0qqiyZ)qʂs&&~p⏍46h.YaBE*yDn)^ᱎu}Na:ĔVg?peFlہQ'mDO9L})3[b},΃T|+a7Ybb+yRp ȓ u)JI*_❨CbN.oו]6EC]>S8*/ FX*4Jr>f ޾ mbO;~}`O.߿ v7}0u1{&[{ 9gȢ߽QoeKUJa𤽉TV#`G-K\TT3maG-#cjclҦGky[Ǹv2A H\n[ K܁(@+WWe3OOSl$_T@K' d=:aTǸ|p9I:&C. ^Ù,t3 Ʊe$~d&v1kIENDB`libDAI-0.2.4/doc/html/classdai_1_1SharedParameters-members.html0000644000263000017630000001323711334764772023126 0ustar jorismkyb libDAI: Member List

dai::SharedParameters Member List

This is the complete list of members for dai::SharedParameters, including all inherited members.

_estimationdai::SharedParameters [private]
_ownEstimationdai::SharedParameters [private]
_permsdai::SharedParameters [private]
_varordersdai::SharedParameters [private]
_varsetsdai::SharedParameters [private]
calculatePermutation(const std::vector< Var > &varOrder, VarSet &outVS)dai::SharedParameters [private, static]
collectSufficientStatistics(InfAlg &alg)dai::SharedParameters
FactorIndex typedefdai::SharedParameters
FactorOrientations typedefdai::SharedParameters
setParameters(FactorGraph &fg)dai::SharedParameters
setPermsAndVarSetsFromVarOrders()dai::SharedParameters [private]
SharedParameters(const FactorOrientations &varorders, ParameterEstimation *estimation, bool ownPE=false)dai::SharedParameters
SharedParameters(std::istream &is, const FactorGraph &fg)dai::SharedParameters
SharedParameters(const SharedParameters &sp)dai::SharedParameters [inline]
~SharedParameters()dai::SharedParameters [inline]

Generated on Thu Feb 11 12:26:03 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/doxygen.png0000644000263000017630000000240111334764772015364 0ustar jorismkybPNG  IHDRd-ok>gAMAOX2tEXtSoftwareAdobe ImageReadyqe<]PLTEǾ"&ﶻޠ{ԍ눙נED9hg]_X<@:#mhU1tRNSvIDATxbC: d#h` @X",***LK.], X@t b @BD6%""  % B:Hf@ RPy"K`\PbC(!II!h(!Cąl!0[X\J\$TM(>a$S @ Ш@R.$LJBRAG1 (FPhhT%!`&q%u P    CT$B|Wl!B`R$( @A%%@,(%$RPmB U`1IYB  99\1 yCCCf"[N'=TGȒl8^K5<SRɤ%@@  b1qAXH&BR y nP4A j>  t!+(.WQA2MU܂ `1%`19F< 3cZ`e!\ D+. 83!lYYA -6EJV @XXX 4 @86`RdB4I " "@xrʌHA`f ȰC"XV0C b@2H ȓ p)!( 04)(%R $Tʀbb,s@7 Ѱ?f֗\PIx!I"Ȉ3 QYt^^gv- }>WJOAV`$&#88\FF SFJ$ƀƊ 4 - Hf ?5 k1d, ."FˀI"4Hgx|fm)))9. aMD& X@t b @%DK.], X@t b @d`ɽSOIENDB`libDAI-0.2.4/doc/html/form_43.png0000644000263000017630000000246211334764772015167 0ustar jorismkybPNG  IHDRw+q0PLTEppp```PPP@@@000 4tRNS@fIDATXMlD/^ U![hQ Lq$(8Q)D(9$@@ ҒҔH S9pUU@HAp@ %Ě㱳6qxػZ +).SiV]):XPzXUgzOXbҺA3J nz+迖z-1B΋u70cqRLà80QKВ4$?7׵<2Zým, jÊXVC \j0muP.ɳƣ+DLp@uyS4>+͂nD9,0\bzUeՎ =H{nV. !Ə&y fsn=/Ym "KLE8vZ/񅘹)ڴ K:dAvY/B!ŕa ҔNN/x3̪U3c|r~ݭcU(|^LNYfO0I 2Vx&c>u+Ngy WG!pןC*Va2=‹s3U-UԉɀA7ǔ!GI+ᢞ:%:bA1&5*COߊ피ᬶM ^-8jd0Mkv%m#Ȣ#£0 zw}xdP.9-|œ YjB 3u{KìK6=^RakMj:#V,a^ic~r[㌡~:@ejtV,cGMڢeעK#bȺq`,QJb۶+@ d{mx8}m8pCr2߲ +7 e,2of>И72?*2m#gIENDB`libDAI-0.2.4/doc/html/functions_func_0x63.html0000644000263000017630000003125311334764772017701 0ustar jorismkyb libDAI: Class Members - Functions
 

- c -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1TRWBP-members.html0000644000263000017630000004305411334764772020572 0ustar jorismkyb libDAI: Member List

dai::TRWBP Member List

This is the complete list of members for dai::TRWBP, including all inherited members.

_edge2lutdai::BP [protected]
_edgesdai::BP [protected]
_itersdai::BP [protected]
_lutdai::BP [protected]
_maxdiffdai::BP [protected]
_sentMessagesdai::BP [protected]
_weightdai::TRWBP [protected]
backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
belief(const Var &v) const dai::BP [inline, virtual]
belief(const VarSet &vs) const dai::BP [virtual]
beliefF(size_t I) const dai::BP [virtual]
beliefs() const dai::BP [virtual]
beliefV(size_t i) const dai::BP [virtual]
BP()dai::BP [inline]
BP(const FactorGraph &fg, const PropertySet &opts)dai::BP [inline]
BP(const BP &x)dai::BP [inline]
calcBeliefF(size_t I, Prob &p) const dai::TRWBP [inline, protected, virtual]
calcBeliefV(size_t i, Prob &p) const dai::TRWBP [protected, virtual]
calcIncomingMessageProduct(size_t I, bool without_i, size_t i) const dai::TRWBP [protected, virtual]
calcNewMessage(size_t i, size_t _I)dai::BP [protected, virtual]
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clearSentMessages()dai::BP [inline]
clone() const dai::TRWBP [inline, virtual]
construct()dai::TRWBP [protected, virtual]
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
findMaximum() const dai::BP
findMaxResidual(size_t &i, size_t &_I)dai::BP [protected]
getProperties() const dai::BP [virtual]
getSentMessages() const dai::BP [inline]
identify() const dai::TRWBP [virtual]
ind_t typedefdai::BP [protected]
index(size_t i, size_t _I) const dai::BP [inline, protected]
index(size_t i, size_t _I)dai::BP [inline, protected]
init()dai::BP [virtual]
init(const VarSet &ns)dai::BP [virtual]
Iterations() const dai::BP [inline, virtual]
logZ() const dai::TRWBP [virtual]
LutType typedefdai::BP [protected]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
maxDiff() const dai::BP [inline, virtual]
message(size_t i, size_t _I) const dai::BP [inline, protected]
message(size_t i, size_t _I)dai::BP [inline, protected]
Namedai::TRWBP [static]
newMessage(size_t i, size_t _I) const dai::BP [inline, protected]
newMessage(size_t i, size_t _I)dai::BP [inline, protected]
operator=(const BP &x)dai::BP [inline]
printProperties() const dai::BP [virtual]
props (defined in dai::BP)dai::BP
recordSentMessagesdai::BP
residual(size_t i, size_t _I) const dai::BP [inline, protected]
residual(size_t i, size_t _I)dai::BP [inline, protected]
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
run()dai::BP [virtual]
setProperties(const PropertySet &opts)dai::BP [virtual]
setWeight(size_t I, Real c)dai::TRWBP [inline]
setWeights(const std::vector< Real > &c)dai::TRWBP [inline]
TRWBP()dai::TRWBP [inline]
TRWBP(const FactorGraph &fg, const PropertySet &opts)dai::TRWBP [inline]
updateMessage(size_t i, size_t _I)dai::BP [protected]
updateResidual(size_t i, size_t _I, Real r)dai::BP [protected]
Weight(size_t I) const dai::TRWBP [inline]
Weights() const dai::TRWBP [inline]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Feb 11 12:26:07 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1FBP-members.html0000644000263000017630000004271011334764772020301 0ustar jorismkyb libDAI: Member List

dai::FBP Member List

This is the complete list of members for dai::FBP, including all inherited members.

_edge2lutdai::BP [protected]
_edgesdai::BP [protected]
_itersdai::BP [protected]
_lutdai::BP [protected]
_maxdiffdai::BP [protected]
_sentMessagesdai::BP [protected]
_weightdai::FBP [protected]
backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
belief(const Var &v) const dai::BP [inline, virtual]
belief(const VarSet &vs) const dai::BP [virtual]
beliefF(size_t I) const dai::BP [virtual]
beliefs() const dai::BP [virtual]
beliefV(size_t i) const dai::BP [virtual]
BP()dai::BP [inline]
BP(const FactorGraph &fg, const PropertySet &opts)dai::BP [inline]
BP(const BP &x)dai::BP [inline]
calcBeliefF(size_t I, Prob &p) const dai::FBP [inline, protected, virtual]
calcBeliefV(size_t i, Prob &p) const dai::BP [protected, virtual]
calcIncomingMessageProduct(size_t I, bool without_i, size_t i) const dai::FBP [protected, virtual]
calcNewMessage(size_t i, size_t _I)dai::FBP [protected, virtual]
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clearSentMessages()dai::BP [inline]
clone() const dai::FBP [inline, virtual]
construct()dai::FBP [protected, virtual]
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
FBP()dai::FBP [inline]
FBP(const FactorGraph &fg, const PropertySet &opts)dai::FBP [inline]
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
findMaximum() const dai::BP
findMaxResidual(size_t &i, size_t &_I)dai::BP [protected]
getProperties() const dai::BP [virtual]
getSentMessages() const dai::BP [inline]
identify() const dai::FBP [virtual]
ind_t typedefdai::BP [protected]
index(size_t i, size_t _I) const dai::BP [inline, protected]
index(size_t i, size_t _I)dai::BP [inline, protected]
init()dai::BP [virtual]
init(const VarSet &ns)dai::BP [virtual]
Iterations() const dai::BP [inline, virtual]
logZ() const dai::FBP [virtual]
LutType typedefdai::BP [protected]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
maxDiff() const dai::BP [inline, virtual]
message(size_t i, size_t _I) const dai::BP [inline, protected]
message(size_t i, size_t _I)dai::BP [inline, protected]
Namedai::FBP [static]
newMessage(size_t i, size_t _I) const dai::BP [inline, protected]
newMessage(size_t i, size_t _I)dai::BP [inline, protected]
operator=(const BP &x)dai::BP [inline]
printProperties() const dai::BP [virtual]
props (defined in dai::BP)dai::BP
recordSentMessagesdai::BP
residual(size_t i, size_t _I) const dai::BP [inline, protected]
residual(size_t i, size_t _I)dai::BP [inline, protected]
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
run()dai::BP [virtual]
setProperties(const PropertySet &opts)dai::BP [virtual]
setWeight(size_t I, Real c)dai::FBP [inline]
setWeights(const std::vector< Real > &c)dai::FBP [inline]
updateMessage(size_t i, size_t _I)dai::BP [protected]
updateResidual(size_t i, size_t _I, Real r)dai::BP [protected]
Weight(size_t I) const dai::FBP [inline]
Weights() const dai::FBP [inline]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Feb 11 12:26:04 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_115.png0000644000263000017630000000042111334764772015240 0ustar jorismkybPNG  IHDR(SA0PLTEppp```PPP@@@000 4tRNS@fIDATc`ج 0&S\d p``H &U!(N i  = sf@ %D檉 H8$U\ SIENDB`libDAI-0.2.4/doc/html/structdai_1_1fo__id.html0000644000263000017630000000707211334764772017702 0ustar jorismkyb libDAI: dai::fo_id< T > Struct Template Reference

dai::fo_id< T > Struct Template Reference

Function object that returns the value itself. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &x) const
 Returns x.

Detailed Description

template<typename T>
struct dai::fo_id< T >

Function object that returns the value itself.

Member Function Documentation

template<typename T>
T dai::fo_id< T >::operator() ( const T &  x  )  const [inline]

Returns x.

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1fo__log0.html0000644000263000017630000000731611334764772020150 0ustar jorismkyb libDAI: dai::fo_log0< T > Struct Template Reference

dai::fo_log0< T > Struct Template Reference

Function object that takes the logarithm, except that log(0) is defined to be 0. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &x) const
 Returns (x == 0 ? 0 : log(x)).

Detailed Description

template<typename T>
struct dai::fo_log0< T >

Function object that takes the logarithm, except that log(0) is defined to be 0.

Member Function Documentation

template<typename T>
T dai::fo_log0< T >::operator() ( const T &  x  )  const [inline]

Returns (x == 0 ? 0 : log(x)).

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/lc_8h.html0000644000263000017630000000647411334764772015102 0ustar jorismkyb libDAI: include/dai/lc.h File Reference

include/dai/lc.h File Reference

Defines class LC, which implements loop corrections for approximate inference. More...

#include <string>
#include <dai/daialg.h>
#include <dai/enum.h>
#include <dai/factorgraph.h>
#include <dai/properties.h>
#include <dai/exceptions.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::LC
 Approximate inference algorithm "Loop Corrected Belief Propagation" [MoK07]. More...
struct  dai::LC::Properties
 Parameters for LC. More...

Detailed Description

Defines class LC, which implements loop corrections for approximate inference.

Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_59.png0000644000263000017630000000032211334764772015167 0ustar jorismkybPNG  IHDRr0PLTEppp```PPP@@@000 4tRNS@fPIDATc`@(&cfc 10 x libDAI: include/dai/mr.h File Reference

include/dai/mr.h File Reference

Defines class MR, which implements loop corrections as proposed by Montanari and Rizzo. More...

#include <vector>
#include <string>
#include <dai/factorgraph.h>
#include <dai/daialg.h>
#include <dai/enum.h>
#include <dai/properties.h>
#include <dai/exceptions.h>
#include <boost/dynamic_bitset.hpp>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::MR
 Approximate inference algorithm by Montanari and Rizzo [MoR05]. More...
struct  dai::MR::Properties
 Parameters for MR. More...

Detailed Description

Defines class MR, which implements loop corrections as proposed by Montanari and Rizzo.

Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions.html0000644000263000017630000004225411334764772016111 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- _ -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/bp__dual_8h-source.html0000644000263000017630000006142611334764772017545 0ustar jorismkyb libDAI: include/dai/bp_dual.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_39.png0000644000263000017630000000062011334764772015166 0ustar jorismkybPNG  IHDRgX0PLTEppp```PPP@@@000 4tRNS@fIDAT(c` 0F#(|Ab \pS1OP6\c%P4=J`)cbCEw\*2;cD@zf鑘X@ [` a_q,lg00D'y nBU Vf<kb`"?0ýC @W!T+6=vuyHqDX6+3DB8`)!<%HgfOim28V?}IENDB`libDAI-0.2.4/doc/html/gibbs_8h-source.html0000644000263000017630000005601411334764772017063 0ustar jorismkyb libDAI: include/dai/gibbs.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_117.png0000644000263000017630000000045611334764772015252 0ustar jorismkybPNG  IHDRd0PLTEppp```PPP@@@000 4tRNS@fIDATc`Q$<8Ik` :"+Q5Tw+/W+n204201 tB0oȘ` @ Hu@(W'{ـ߁!5cd` `U:3FCIENDB`libDAI-0.2.4/doc/html/form_143.png0000644000263000017630000000264311334764772015251 0ustar jorismkybPNG  IHDR[+$60PLTEppp```PPP@@@000 4tRNS@f!IDATX_h[UǿO7 Fq3Rq30t* NVPdKu1,i1$!XDW"JOV' >ͤsޛ6ԖGw=w ?ncyĭ _m)Hko+V﷖%Yo/sт6\>镎U*3ftٻu^>A{U3iΚtNcpdMKuNA؝ ADm~bo\Q=1Odu3GWZ Wx0Hc4*G]K}E+ǃf.P-*SS}@WNZzh7>0,*Jx[eGyfHW.9Z@ߠqhqʸeL}ڼij2jѴ-q p-2om Ɗ#F[ܴQNBZBxQ[XzMM +K\.{!C&˩OKotH1xd٥}py1 kD *k^k*3\!edS6u~ R-^,VEYƨiND\ey2,ϱv:ިߝ%6Ψ9~hvKl >B|DIENDB`libDAI-0.2.4/doc/html/form_27.png0000644000263000017630000000160711334764772015171 0ustar jorismkybPNG  IHDR'~C0PLTEppp```PPP@@@000 4tRNS@fIDATHKaǿ3;a^v@ñ !"8Z.ѡv BTVĢ`.E]\:Ա-C.";:8K><>\RN.71!B<#"FLy1XyZ~Q𗣷v>&P?kQfe.{q'RZzt0_aXf24ײͼ|ǹyLٕ!|3|90(|$9|21]CWaslٮ?+fEW37g+I!7pl﨔-٩Xba M؝j38v:-PDwk[LX" k:XLNqʰxUqZTVxZE=L0k˥g7ÍmS-PGW|kwTGsԋU/g)$i X9۟@1 QU_!bsd0TDXrIYOVlɤ^9ol X~A;Ӥ*IENDB`libDAI-0.2.4/doc/html/hak_8h-source.html0000644000263000017630000005760711334764772016551 0ustar jorismkyb libDAI: include/dai/hak.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1BP__dual_1_1messages.html0000644000263000017630000002164411334764772022321 0ustar jorismkyb libDAI: dai::BP_dual::messages Struct Reference

dai::BP_dual::messages Struct Reference

Groups together the data structures for storing the two types of messages and their normalizers. More...

#include <dai/bp_dual.h>

List of all members.

Public Attributes

_edges_t< Prob > n
 Unnormalized variable->factor messages.
_edges_t< Real > Zn
 Normalizers of variable->factor messages.
_edges_t< Prob > m
 Unnormalized Factor->variable messages.
_edges_t< Real > Zm
 Normalizers of factor->variable messages.

Detailed Description

Groups together the data structures for storing the two types of messages and their normalizers.

Member Data Documentation

_edges_t<Prob> dai::BP_dual::messages::n

Unnormalized variable->factor messages.

_edges_t<Real> dai::BP_dual::messages::Zn

Normalizers of variable->factor messages.

_edges_t<Prob> dai::BP_dual::messages::m

Unnormalized Factor->variable messages.

_edges_t<Real> dai::BP_dual::messages::Zm

Normalizers of factor->variable messages.

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_func_0x66.html0000644000263000017630000001452111334764772017703 0ustar jorismkyb libDAI: Class Members - Functions
 

- f -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/smallset_8h.html0000644000263000017630000000465511334764772016327 0ustar jorismkyb libDAI: include/dai/smallset.h File Reference

include/dai/smallset.h File Reference

Defines the SmallSet<> class, which represents a set (optimized for a small number of elements). More...

#include <vector>
#include <algorithm>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::SmallSet< T >
 Represents a set; the implementation is optimized for a small number of elements. More...

Detailed Description

Defines the SmallSet<> class, which represents a set (optimized for a small number of elements).

Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_99.png0000644000263000017630000000075711334764772015207 0ustar jorismkybPNG  IHDRT7D0PLTEppp```PPP@@@000 4tRNS@fmIDAT(c`;` @Q&TPhaH``(&<R < L& )Ub+&V^$ NHGDbD)3XK+X)3~dgV/u!u:M @ t3\c4 @1=fTS E)]@!Ryt,@_&OP=t (J=9?2/iabܠ >'ì)VY.\CJ +g._R Eq(\N~h`BLT yPDC009Eu>wb\WLaIENDB`libDAI-0.2.4/doc/html/form_19.png0000644000263000017630000000030011334764772015157 0ustar jorismkybPNG  IHDR 0PLTEppp```PPP@@@000 4tRNS@f>IDATc`](=D70;p^(P ;b 誙&  k IENDB`libDAI-0.2.4/doc/html/form_106.png0000644000263000017630000000352311334764772015246 0ustar jorismkybPNG  IHDR" 0PLTEppp```PPP@@@000 4tRNS@fIDATXXoE{ԄZ+%ГbE{P &MˁhUZC&"cB&0bfRh7{x)hxIo3y7fvZv/p` wD*ŋ%Z+++m zՇ(3Vx޸5-o1zuKh]pJ W䭂Gdm O#G { M Mo%-j̶ML8"xn|~M0XU>I4=~1"Εt T HIHn;0ȝeIL˝wTxm libDAI: include/dai/factorgraph.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_58.png0000644000263000017630000000056111334764772015173 0ustar jorismkybPNG  IHDR2u10PLTEppp```PPP@@@000 4tRNS@fIDATc`  #1! XZClX;0 Wpa3{ ~ ̟7d'03_42+d?U1l̟dz /6s ɰd2@e?Ae?d>dXA,NƯ`{d  2sd.b6PL pWT.D8 {2BIENDB`libDAI-0.2.4/doc/html/form_76.png0000644000263000017630000000035211334764772015171 0ustar jorismkybPNG  IHDRr0PLTEppp```PPP@@@000 4tRNS@fhIDATc`9PJ $4઺x""):) c `W1L:x G.$9&0,`` jS8y\ XrIENDB`libDAI-0.2.4/doc/html/functions_0x72.html0000644000263000017630000002537411334764772016675 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- r -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1TFactor.png0000644000263000017630000000063711334764772017426 0ustar jorismkybPNG  IHDRnP ]PLTE`{tRNS@f5IDATXQn Po7ݠv}G@(#TWI:Z n%=TrbM۱8g֦@,NK8ľo#Buquq棾zT2|l*n=8R}ǥznvm7q|MrV㭜ӐK|𤃋~Af;HOGvOlũ8J8Ol֙)ǁq libDAI: include/dai/weightedgraph.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_func_0x70.html0000644000263000017630000001533511334764772017702 0ustar jorismkyb libDAI: Class Members - Functions
 

- p -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_40.png0000644000263000017630000000051111334764772015155 0ustar jorismkybPNG  IHDR6V00PLTEppp```PPP@@@000 4tRNS@fIDATc`  ftAؓH,rT:,Z L  a2eu@X 7_Y 8>1c!W4Y)iS7`hG[% 2$X /20X`ZIGDp)9@+0o#F\y\P#dMeql6lKIENDB`libDAI-0.2.4/doc/html/classdai_1_1DEdge-members.html0000644000263000017630000000665711334764772020654 0ustar jorismkyb libDAI: Member List

dai::DEdge Member List

This is the complete list of members for dai::DEdge, including all inherited members.

DEdge()dai::DEdge [inline]
DEdge(size_t m1, size_t m2)dai::DEdge [inline]
n1dai::DEdge
n2dai::DEdge
operator!=(const DEdge &x) const dai::DEdge [inline]
operator<(const DEdge &x) const dai::DEdge [inline]
operator<<(std::ostream &os, const DEdge &e)dai::DEdge [friend]
operator==(const DEdge &x) const dai::DEdge [inline]

Generated on Thu Feb 11 12:26:08 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1RootedTree-members.html0000644000263000017630000000411211334764772021740 0ustar jorismkyb libDAI: Member List

dai::RootedTree Member List

This is the complete list of members for dai::RootedTree, including all inherited members.

RootedTree()dai::RootedTree [inline]
RootedTree(const GraphEL &T, size_t Root)dai::RootedTree

Generated on Thu Feb 11 12:26:08 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1SharedParameters.html0000644000263000017630000006537211334764772021505 0ustar jorismkyb libDAI: dai::SharedParameters Class Reference

dai::SharedParameters Class Reference

Represents a single factor or set of factors whose parameters should be estimated. More...

#include <dai/emalg.h>

List of all members.

Public Types

typedef size_t FactorIndex
 Convenience label for an index of a factor in a FactorGraph.
typedef std::map< FactorIndex,
std::vector< Var > > 		FactorOrientations
 Convenience label for a grouping of factor orientations.

Public Member Functions

 SharedParameters (const FactorOrientations &varorders, ParameterEstimation *estimation, bool ownPE=false)
 Constructor.
 SharedParameters (std::istream &is, const FactorGraph &fg)
 Construct a SharedParameters object from an input stream is and a factor graph fg.
 SharedParameters (const SharedParameters &sp)
 Copy constructor.
 ~SharedParameters ()
 Destructor.
void collectSufficientStatistics (InfAlg &alg)
 Collect the sufficient statistics from expected values (beliefs) according to alg.
void setParameters (FactorGraph &fg)
 Estimate and set the shared parameters.

Private Member Functions

void setPermsAndVarSetsFromVarOrders ()
 Initializes _varsets and _perms from _varorders and checks whether their state spaces correspond with _estimation.probSize().

Static Private Member Functions

static Permute calculatePermutation (const std::vector< Var > &varOrder, VarSet &outVS)
 Calculates the permutation that permutes the canonical ordering into the desired ordering.

Private Attributes

std::map< FactorIndex, VarSet > _varsets
 Maps factor indices to the corresponding VarSets.
std::map< FactorIndex, Permute > _perms
 Maps factor indices to the corresponding Permute objects that permute the canonical ordering into the desired ordering.
FactorOrientations _varorders
 Maps factor indices to the corresponding desired variable orderings.
ParameterEstimation * _estimation
 Parameter estimation method to be used.
bool _ownEstimation
 Indicates whether *this gets ownership of _estimation.

Detailed Description

Represents a single factor or set of factors whose parameters should be estimated.

To ensure that parameters can be shared between different factors during EM learning, each factor's values are reordered to match a desired variable ordering. The ordering of the variables in a factor may therefore differ from the canonical ordering used in libDAI. The SharedParameters class combines one or more factors (together with the specified orderings of the variables) with a ParameterEstimation object, taking care of the necessary permutations of the factor entries / parameters.

Author:
Charles Vaske

Member Typedef Documentation

typedef size_t dai::SharedParameters::FactorIndex

Convenience label for an index of a factor in a FactorGraph.

typedef std::map<FactorIndex, std::vector<Var> > dai::SharedParameters::FactorOrientations

Convenience label for a grouping of factor orientations.

Constructor & Destructor Documentation

dai::SharedParameters::SharedParameters ( const FactorOrientations &  varorders,
ParameterEstimation *  estimation,
bool  ownPE = false 
)

Constructor.

Parameters:
varorders all the factor orientations for this parameter
estimation a pointer to the parameter estimation method
ownPE whether the constructed object gets ownership of estimation

dai::SharedParameters::SharedParameters ( std::istream &  is,
const FactorGraph &  fg 
)

Construct a SharedParameters object from an input stream is and a factor graph fg.

See also:
Shared parameters block format
Exceptions:
INVALID_EMALG_FILE if the input stream is not valid

dai::SharedParameters::SharedParameters ( const SharedParameters &  sp  )  [inline]

Copy constructor.

dai::SharedParameters::~SharedParameters (  )  [inline]

Destructor.

Member Function Documentation

Permute dai::SharedParameters::calculatePermutation ( const std::vector< Var > &  varOrder,
VarSet &  outVS 
) [static, private]

Calculates the permutation that permutes the canonical ordering into the desired ordering.

Parameters:
varOrder Desired ordering of variables
outVS Contains variables in varOrder represented as a VarSet
Returns:
Permute object for permuting variables in varOrder from the canonical libDAI ordering into the desired ordering

void dai::SharedParameters::setPermsAndVarSetsFromVarOrders (  )  [private]

Initializes _varsets and _perms from _varorders and checks whether their state spaces correspond with _estimation.probSize().

void dai::SharedParameters::collectSufficientStatistics ( InfAlg &  alg  ) 

Collect the sufficient statistics from expected values (beliefs) according to alg.

For each of the relevant factors (that shares the parameters we are interested in), the corresponding belief according to alg is obtained and its entries are permuted such that their ordering corresponds with the shared parameters that we are estimating. Then, the parameter estimation subclass method addSufficientStatistics() is called with this vector of expected values of the parameters as input.

void dai::SharedParameters::setParameters ( FactorGraph &  fg  ) 

Estimate and set the shared parameters.

Based on the sufficient statistics collected so far, the shared parameters are estimated using the parameter estimation subclass method estimate(). Then, each of the relevant factors in fg (that shares the parameters we are interested in) is set according to those parameters (permuting the parameters accordingly).

Member Data Documentation

std::map<FactorIndex, VarSet> dai::SharedParameters::_varsets [private]

Maps factor indices to the corresponding VarSets.

std::map<FactorIndex, Permute> dai::SharedParameters::_perms [private]

Maps factor indices to the corresponding Permute objects that permute the canonical ordering into the desired ordering.

FactorOrientations dai::SharedParameters::_varorders [private]

Maps factor indices to the corresponding desired variable orderings.

ParameterEstimation* dai::SharedParameters::_estimation [private]

Parameter estimation method to be used.

bool dai::SharedParameters::_ownEstimation [private]

Indicates whether *this gets ownership of _estimation.

The documentation for this class was generated from the following files:
Generated on Thu Feb 11 12:26:03 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1TreeEP_1_1TreeEPSubTree-members.html0000644000263000017630000001551511334764772024020 0ustar jorismkyb libDAI: Member List

dai::TreeEP::TreeEPSubTree Member List

This is the complete list of members for dai::TreeEP::TreeEPSubTree, including all inherited members.

_adai::TreeEP::TreeEPSubTree [private]
_bdai::TreeEP::TreeEPSubTree [private]
_Idai::TreeEP::TreeEPSubTree [private]
_logZdai::TreeEP::TreeEPSubTree [private]
_nsdai::TreeEP::TreeEPSubTree [private]
_nsremdai::TreeEP::TreeEPSubTree [private]
_Qadai::TreeEP::TreeEPSubTree [private]
_Qbdai::TreeEP::TreeEPSubTree [private]
_RTreedai::TreeEP::TreeEPSubTree [private]
HUGIN_with_I(std::vector< Factor > &Qa, std::vector< Factor > &Qb)dai::TreeEP::TreeEPSubTree
I()dai::TreeEP::TreeEPSubTree [inline]
init()dai::TreeEP::TreeEPSubTree
InvertAndMultiply(const std::vector< Factor > &Qa, const std::vector< Factor > &Qb)dai::TreeEP::TreeEPSubTree
logZ(const std::vector< Factor > &Qa, const std::vector< Factor > &Qb) const dai::TreeEP::TreeEPSubTree
operator=(const TreeEPSubTree &x)dai::TreeEP::TreeEPSubTree [inline]
TreeEPSubTree()dai::TreeEP::TreeEPSubTree [inline]
TreeEPSubTree(const TreeEPSubTree &x)dai::TreeEP::TreeEPSubTree [inline]
TreeEPSubTree(const RootedTree &subRTree, const RootedTree &jt_RTree, const std::vector< Factor > &jt_Qa, const std::vector< Factor > &jt_Qb, const Factor *I)dai::TreeEP::TreeEPSubTree

Generated on Thu Feb 11 12:26:07 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_92.png0000644000263000017630000000031211334764772015163 0ustar jorismkybPNG  IHDR Ol0PLTEppp```PPP@@@000 4tRNS@fHIDATc`@&3,%b` f$$l `|SA,3k+ l e:IENDB`libDAI-0.2.4/doc/html/structdai_1_1fo__inv.html0000644000263000017630000000707711334764772020107 0ustar jorismkyb libDAI: dai::fo_inv< T > Struct Template Reference

dai::fo_inv< T > Struct Template Reference

Function object that takes the inverse. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &x) const
 Returns 1 / x.

Detailed Description

template<typename T>
struct dai::fo_inv< T >

Function object that takes the inverse.

Member Function Documentation

template<typename T>
T dai::fo_inv< T >::operator() ( const T &  x  )  const [inline]

Returns 1 / x.

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/build.html0000644000263000017630000001602211334764772015172 0ustar jorismkyb libDAI: Building libDAI

Building libDAI

Building libDAI under UNIX variants (Linux / Cygwin / Mac OS X)

Preparations

You need:
  • a recent version of gcc (at least version 3.4)
  • GNU make
  • doxygen
  • graphviz
  • recent boost C++ libraries (at least version 1.34 if you have a recent version of GCC, otherwise at least version 1.37; however, version 1.37 shipped with Ubuntu 9.04 is known not to work)

On Debian/Ubuntu, you can easily install all these packages with a single command: 

  apt-get install g++ make doxygen graphviz libboost-dev libboost-graph-dev libboost-program-options-dev
(root permissions needed).

On Mac OS X (10.4 is known to work), these packages can be installed easily via MacPorts. If MacPorts is not already installed, install it according to the instructions at http://www.macports.org/. Then, a simple 

  sudo port install gmake boost doxygen graphviz
should be enough to install everything that is needed.

On Cygwin, the prebuilt Cygwin package boost-1.33.1-x is known not to work. You can however obtain the latest boost version (you need at least 1.37.0) from http://www.boost.org/ and compile/install it with:

  ./configure
  make
  make install

Building libDAI

To build the libDAI source, first copy a template Makefile.* to Makefile.conf (for example, copy Makefile.LINUX to Makefile.conf if you use GNU/Linux). Then, edit the Makefile.conf template to adapt it to your local setup. Especially directories may differ from system to system. Platform independent build options can be set in Makefile.ALL. Finally, run 
  make
The build includes a regression test, which may take a while to complete.

If the build is successful, you can test the example program: 

  examples/example tests/alarm.fg
or the more extensive test program: 
  tests/testdai --aliases tests/aliases.conf --filename tests/alarm.fg --methods JTREE_HUGIN BP_SEQMAX

Building libDAI under Windows

Preparations

You need:
  • A recent version of MicroSoft Visual Studio (2008 is known to work)
  • recent boost C++ libraries (version 1.37 or higher)
  • GNU make (can be obtained from http://gnuwin32.sourceforge.net)

For the regression test, you need:

Building libDAI

To build the source, copy Makefile.WINDOWS to Makefile.conf. Then, edit Makefile.conf to adapt it to your local setup. Platform independent build options can be set in Makefile.ALL. Finally, run (from the command line) 
  make
The build includes a regression test, which may take a while to complete.

If the build is successful, you can test the example program: 

  examples\example tests\alarm.fg
or the more extensive test program: 
  tests\testdai --aliases tests\aliases.conf --filename tests\alarm.fg --methods JTREE_HUGIN BP_SEQMAX

Building the libDAI MatLab interface

You need:
  • MatLab
  • The platform-dependent requirements described above

First, you need to build the libDAI source as described above for your platform. By default, the MatLab interface is disabled, so before compiling the source, you have to enable it in Makefile.ALL by setting 

  WITH_MATLAB=true
Also, you have to configure the MatLab-specific parts of Makefile.conf to match your system (in particular, the Makefile variables ME, MATLABDIR and MEX). The MEX file extension depends on your platform; for a 64-bit linux x86_64 system this would be "ME=.mexa64", for a 32-bit linux x86 system "ME=.mexglx". If you are unsure about your MEX file extension: it needs to be the same as what the MatLab command "mexext" returns. The required MEX files are built by issuing 
  make
from the command line. The MatLab interface is much less powerful than using libDAI from C++. There are two reasons for this: (i) it is boring to write MEX files; (ii) the large performance penalty paid when large data structures (like factor graphs) have to be converted between their native C++ data structure to something that MatLab understands.

A simple example of how to use the MatLab interface is the following (entered at the MatLab prompt), which performs exact inference by the junction tree algorithm and approximate inference by belief propagation on the ALARM network: 

  cd path_to_libdai/matlab
  [psi] = dai_readfg ('../examples/alarm.fg');
  [logZ,q,md,qv,qf] = dai (psi, 'JTREE', '[updates=HUGIN,verbose=0]')
  [logZ,q,md,qv,qf] = dai (psi, 'BP', '[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0]')
where "path_to_libdai" has to be replaced with the directory in which libDAI was installed. For other algorithms and some default parameters, see the file tests/aliases.conf.

Building the documentation

Install doxygen, graphviz and a TeX distribution and use 
  make doc
to build the documentation. If the documentation is not clear enough, feel free to send me an email (or even better, to improve the documentation and send a patch!). The documentation can also be browsed online at http://www.libdai.org.
Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_56.png0000644000263000017630000000047711334764772015177 0ustar jorismkybPNG  IHDRT 0PLTEppp```PPP@@@000 4tRNS@fIDAT(c``MX`3RR L` @e&DUZ@0 EYZLea`*e4[}b``”Lg+eJRv(b@P̟@{(g"~Igf `ѩ(%0,ZY.QqIENDB`libDAI-0.2.4/doc/html/form_20.png0000644000263000017630000000127211334764772015160 0ustar jorismkybPNG  IHDR|$C0PLTEppp```PPP@@@000 4tRNS@f8IDATHՔkaǿe/ (4N:ՂA*(XpTIQt)PuʒW)E\}Jjs*xcf8/Q C9aBWr[Bn"U>އWZr:bti'|RsGY+%_%LIENDB`libDAI-0.2.4/doc/html/bbp_8h.html0000644000263000017630000001124511334764772015237 0ustar jorismkyb libDAI: include/dai/bbp.h File Reference

include/dai/bbp.h File Reference

Defines class BBP, which implements Back-Belief-Propagation. More...

#include <vector>
#include <utility>
#include <dai/prob.h>
#include <dai/daialg.h>
#include <dai/factorgraph.h>
#include <dai/enum.h>
#include <dai/bp_dual.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::BBPCostFunction
 Predefined cost functions that can be used with BBP. More...
class  dai::BBP
 Implements BBP (Back-Belief-Propagation) [EaG09]. More...
struct  dai::BBP::Properties
 Parameters for BBP. More...

Functions

 dai::DAI_ENUM (BBPCostFunctionBase, CFN_GIBBS_B, CFN_GIBBS_B2, CFN_GIBBS_EXP, CFN_GIBBS_B_FACTOR, CFN_GIBBS_B2_FACTOR, CFN_GIBBS_EXP_FACTOR, CFN_VAR_ENT, CFN_FACTOR_ENT, CFN_BETHE_ENT)
 Enumeration of several cost functions that can be used with BBP.

Detailed Description

Defines class BBP, which implements Back-Belief-Propagation.

Todo:
Clean up code
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_enum.html0000644000263000017630000000443211334764772017131 0ustar jorismkyb libDAI: Class Members - Enumerations
 

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_51.png0000644000263000017630000000030211334764772015155 0ustar jorismkybPNG  IHDR Rio0PLTEppp```PPP@@@000 4tRNS@f@IDATc`,)`0#;˖Y H+t030:0008)as`dR#0XIENDB`libDAI-0.2.4/doc/html/form_53.png0000644000263000017630000000414411334764772015167 0ustar jorismkybPNG  IHDRZMѵ0PLTEppp```PPP@@@000 4tRNS@fIDATh]lUnK(Q"iPn1aW%"$ P kD@ րƖ(X>0BLhQlXٝs Yd'={g~s=1{`O'@Dy5 Bj2TdޙՖ#_x~}8 s(MLMHQLJKB)f͙V4ujBbS2 yY2 ;XDӀ{H{l<| F]iH =J㱇lx7&|ẽFJ'e꫞_6'Xh y a>c` *St}9>"-P>g}N_^$ayN_ُ1x<i&n B mSOXNy|'Tx[پ+!%u<)MX FVmYǗVH3uD@2SpjjECnu q[P"Ej n"|['  5a㩟-А㝅 ,qi2n% aCH_LV y<=]IyE1p2bW@pgWp^?,qz0З({ՃKDP\/D +hDOvBK  k@4N-mzmʬce]Pe @&cSJS 0|`uOp&pMDTCzzT)]L[;|COBP|2r}}0`_/5fY' C8M a`u+`u/"GH&ZƧ/#ofVv!Gpɂ=Rrl0zb`~Hɳ5Ճoȧ7)1$1yM1aHSb#p,@~F~V4rxzlz mѐ#?rz8v=40pN]8AZ/ F~ԦO$@j?xxRGNҰZ& Pp#V1R/hŀzPB:R(4F埄^ۊo8@<FxZ%!-,n&zɹA5=`I@䭺R6q0Ꝥ||'r50 Zri :>scd 8@bWqW#^)L f]6 Xla8 Yzz~/p m@[F/0KAkj&Pui@Kݫ*&|yS,xie_233­Iw=LӐ#?/7Wꁑ@F#?p#?>`U|We~#??Fi遑[lhA1( <=׵Y5etӃѪ!,t襂YCXF .3YW z(\UCXF \=RYCXF `-i<=ԃi z?@_ʹ ۥ^`.z*;.;^wKpF~+F,?'rNcܟ=UJp~a&)%^8.PֵGlNoe{nLw?2o=lzqy<=6mzsfYI‘>}/A郓sz<z z #9z0yՅ<l:8E RIENDB`libDAI-0.2.4/doc/html/form_108.png0000644000263000017630000000064011334764772015245 0ustar jorismkybPNG  IHDR70PLTEppp```PPP@@@000 4tRNS@fIDAT(Pj@}٬ ؞BZ/EţJz&~z= BOl"t`vvx3>߰eP D+V!#0 HkHc}Sd jEsUeAV+Xa҃cQS⩋S7̺GiFQK O6Q~fOhIXߣ j ]Y=4\xa!~@xwps(3}B r76q6Z~#E%.2),<NA)IENDB`libDAI-0.2.4/doc/html/form_22.png0000644000263000017630000000047611334764772015167 0ustar jorismkybPNG  IHDR( 0PLTEppp```PPP@@@000 4tRNS@fIDATc`  BaS zL /$8``RD2003X2 ed td%T X13|La `tQY700T?0O$Õpj&EnS ^i`z$PrkHGԛ" q^IENDB`libDAI-0.2.4/doc/html/classdai_1_1CBP.html0000644000263000017630000017240611334764772016654 0ustar jorismkyb libDAI: dai::CBP Class Reference

dai::CBP Class Reference

Class for CBP (Conditioned Belief Propagation) [EaG09]. More...

#include <dai/cbp.h>

Inheritance diagram for dai::CBP:

dai::DAIAlg< GRM > dai::InfAlg

List of all members.

Public Member Functions

 CBP (const FactorGraph &fg, const PropertySet &opts)
 Construct CBP object from FactorGraph fg and PropertySet opts.
General InfAlg interface
virtual CBP * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
virtual std::string identify () const
 Identifies itself for logging purposes.
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable.
virtual Factor belief (const VarSet &) const
 Returns the (approximate) marginal probability distribution of a set of variables.
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i.
virtual Factor beliefF (size_t I) const
 Returns the (approximate) marginal probability distribution of the variables on which factor I depends.
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).
virtual void init ()
 Initializes all data structures of the approximate inference algorithm.
virtual void init (const VarSet &)
 Initializes all data structures corresponding to some set of variables.
virtual Real run ()
 Runs the approximate inference algorithm.
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration.
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph).
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm.
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet.
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Public Attributes

struct dai::CBP::Properties props

Static Public Attributes

static const char * Name = "CBP"
 Name of this inference algorithm.

Private Member Functions

void printDebugInfo ()
 Prints beliefs, variables and partition sum, in case of a debugging build.
void runRecurse (InfAlg *bp, Real orig_logZ, std::vector< size_t > clamped_vars_list, size_t &num_leaves, size_t &choose_count, Real &sum_level, Real &lz_out, std::vector< Factor > &beliefs_out)
 Called by run(), and by itself. Implements the main algorithm.
virtual bool chooseNextClampVar (InfAlg *bp, std::vector< size_t > &clamped_vars_list, size_t &i, std::vector< size_t > &xis, Real *maxVarOut)
 Choose the next variable to clamp.
InfAlg * getInfAlg ()
 Return the InfAlg to use at each step of the recursion.
void setBeliefs (const std::vector< Factor > &bs, Real logZ)
 Sets variable beliefs, factor beliefs and log partition sum to the specified values.
void construct ()
 Constructor helper function.

Private Attributes

std::vector< Factor > _beliefsV
 Variable beliefs.
std::vector< Factor > _beliefsF
 Factor beliefs.
Real _logZ
 Logarithm of partition sum.
size_t _iters
 Numer of iterations needed.
Real _maxdiff
 Maximum difference encountered so far.
Real _sum_level
 Number of clampings at each leaf node.
size_t _num_leaves
 Number of leaves of recursion tree.
boost::shared_ptr< std::ofstream > _clamp_ofstream
 Output stream where information about the clampings is written.

Related Functions

(Note that these are not member functions.)

std::pair< size_t, size_t > BBPFindClampVar (const InfAlg &in_bp, bool clampingVar, const PropertySet &bbp_props, const BBPCostFunction &cfn, Real *maxVarOut)
 Find the best variable/factor to clamp using BBP.

Classes

struct  Properties
 Parameters for CBP. More...

Detailed Description

Class for CBP (Conditioned Belief Propagation) [EaG09].

This approximate inference algorithm uses configurable heuristics to choose a variable $ x_i $ and a state $ x_i^* $. Inference is done with $ x_i $ "clamped" to $ x_i^* $ (i.e., conditional on $ x_i = x_i^* $), and also with the negation of this condition. Clamping is done recursively up to a fixed number of levels (other stopping criteria are also implemented, see the CBP::Properties::RecurseType property). The resulting approximate marginals are combined using estimates of the partition sum.

Author:
Frederik Eaton

Constructor & Destructor Documentation

dai::CBP::CBP ( const FactorGraph &  fg,
const PropertySet &  opts 
) [inline]

Construct CBP object from FactorGraph fg and PropertySet opts.

Parameters:
opts Parameters
See also:
Properties

Member Function Documentation

virtual CBP* dai::CBP::clone (  )  const [inline, virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Implements dai::InfAlg.

virtual std::string dai::CBP::identify (  )  const [inline, virtual]

Identifies itself for logging purposes.

Implements dai::InfAlg.

virtual Factor dai::CBP::belief ( const Var &  v  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of a variable.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

virtual Factor dai::CBP::belief ( const VarSet &  vs  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of a set of variables.

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported.
BELIEF_NOT_AVAILABLE if the requested belief cannot be calculated with this algorithm.

Implements dai::InfAlg.

virtual Factor dai::CBP::beliefV ( size_t  i  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of the variable with index i.

For some approximate inference algorithms, using beliefV() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

virtual Factor dai::CBP::beliefF ( size_t  I  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of the variables on which factor I depends.

For some approximate inference algorithms, using beliefF() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

virtual std::vector<Factor> dai::CBP::beliefs (  )  const [inline, virtual]

Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.

Note:
Before this method is called, run() should have been called.

Implements dai::InfAlg.

virtual Real dai::CBP::logZ (  )  const [inline, virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

virtual void dai::CBP::init (  )  [inline, virtual]

Initializes all data structures of the approximate inference algorithm.

Note:
This method should be called at least once before run() is called.

Implements dai::InfAlg.

virtual void dai::CBP::init ( const VarSet &  vs  )  [inline, virtual]

Initializes all data structures corresponding to some set of variables.

This method can be used to do a partial initialization after a part of the factor graph has changed. Instead of initializing all data structures, it only initializes those involving the variables in vs.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

Real dai::CBP::run (  )  [virtual]

Runs the approximate inference algorithm.

Note:
Before run() is called the first time, init() should have been called.

Implements dai::InfAlg.

virtual Real dai::CBP::maxDiff (  )  const [inline, virtual]

Returns maximum difference between single variable beliefs in the last iteration.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

virtual size_t dai::CBP::Iterations (  )  const [inline, virtual]

Returns number of iterations done (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

virtual void dai::CBP::setProperties ( const PropertySet &  opts  )  [inline, virtual]

Set parameters of this inference algorithm.

The parameters are set according to the PropertySet opts. The values can be stored either as std::string or as the type of the corresponding MF::props member.

Implements dai::InfAlg.

virtual PropertySet dai::CBP::getProperties (  )  const [inline, virtual]

Returns parameters of this inference algorithm converted into a PropertySet.

Implements dai::InfAlg.

virtual std::string dai::CBP::printProperties (  )  const [inline, virtual]

Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Implements dai::InfAlg.

void dai::CBP::printDebugInfo (  )  [private]

Prints beliefs, variables and partition sum, in case of a debugging build.

void dai::CBP::runRecurse ( InfAlg *  bp,
Real  orig_logZ,
std::vector< size_t >  clamped_vars_list,
size_t &  num_leaves,
size_t &  choose_count,
Real &  sum_level,
Real &  lz_out,
std::vector< Factor > &  beliefs_out 
) [private]

Called by run(), and by itself. Implements the main algorithm.

Chooses a variable to clamp, recurses, combines the partition sum and belief estimates of the children, and returns the improved estimates in lz_out and beliefs_out to its parent.

Idea:
dai::CBP::runRecurse() could be implemented more efficiently with a nesting version of backupFactors/restoreFactors

bool dai::CBP::chooseNextClampVar ( InfAlg *  bp,
std::vector< size_t > &  clamped_vars_list,
size_t &  i,
std::vector< size_t > &  xis,
Real *  maxVarOut 
) [private, virtual]

Choose the next variable to clamp.

Choose the next variable to clamp, given a converged InfAlg bp, and a vector of variables that are already clamped (clamped_vars_list). Returns the chosen variable in i, and the set of states in xis. If maxVarOut is non-NULL and props.choose == CHOOSE_BBP then it is used to store the adjoint of the chosen variable.

InfAlg * dai::CBP::getInfAlg (  )  [private]

Return the InfAlg to use at each step of the recursion.

Todo:
At present, CBP::getInfAlg() only returns a BP instance; it should be possible to select other inference algorithms via a property

void dai::CBP::setBeliefs ( const std::vector< Factor > &  bs,
Real  logZ 
) [private]

Sets variable beliefs, factor beliefs and log partition sum to the specified values.

Parameters:
bs should be a concatenation of the variable beliefs followed by the factor beliefs
logZ log partition sum

void dai::CBP::construct (  )  [private]

Constructor helper function.

Friends And Related Function Documentation

std::pair< size_t, size_t > BBPFindClampVar ( const InfAlg &  in_bp,
bool  clampingVar,
const PropertySet &  bbp_props,
const BBPCostFunction &  cfn,
Real *  maxVarOut 
) [related]

Find the best variable/factor to clamp using BBP.

Takes a converged inference algorithm as input, runs Gibbs and BP_dual, creates and runs a BBP object, finds the best variable/factor (the one with the maximum factor adjoint), and returns the corresponding (index,state) pair.

Parameters:
in_bp inference algorithm (compatible with BP) that should have converged;
clampingVar if true, finds best variable, otherwise, finds best factor;
bbp_props BBP parameters to use;
cfn BBP cost function to use;
maxVarOut maximum adjoint value (only set if not NULL).
See also:
BBP

Member Data Documentation

std::vector<Factor> dai::CBP::_beliefsV [private]

Variable beliefs.

std::vector<Factor> dai::CBP::_beliefsF [private]

Factor beliefs.

Real dai::CBP::_logZ [private]

Logarithm of partition sum.

size_t dai::CBP::_iters [private]

Numer of iterations needed.

Real dai::CBP::_maxdiff [private]

Maximum difference encountered so far.

Real dai::CBP::_sum_level [private]

Number of clampings at each leaf node.

size_t dai::CBP::_num_leaves [private]

Number of leaves of recursion tree.

boost::shared_ptr<std::ofstream> dai::CBP::_clamp_ofstream [private]

Output stream where information about the clampings is written.

const char * dai::CBP::Name = "CBP" [static]

Name of this inference algorithm.

The documentation for this class was generated from the following files:
  • include/dai/cbp.h
  • src/cbp.cpp
Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1InfAlg.html0000644000263000017630000017153311334764772017410 0ustar jorismkyb libDAI: dai::InfAlg Class Reference

dai::InfAlg Class Reference

InfAlg is an abstract base class, defining the common interface of all inference algorithms in libDAI. More...

#include <dai/daialg.h>

Inheritance diagram for dai::InfAlg:

dai::DAIAlg< GRM > dai::DAIAlg< dai::FactorGraph > dai::DAIAlg< dai::RegionGraph > dai::BP dai::CBP dai::ExactInf dai::Gibbs dai::HAK dai::JTree dai::LC dai::MF dai::MR

List of all members.

Public Member Functions

Constructors/destructors
virtual ~InfAlg ()
 Virtual destructor (needed because this class contains virtual functions).
virtual InfAlg * clone () const =0
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
Queries
virtual std::string identify () const =0
 Identifies itself for logging purposes.
virtual FactorGraph & fg ()=0
 Returns reference to underlying FactorGraph.
virtual const FactorGraph & fg () const =0
 Returns constant reference to underlying FactorGraph.
Inference interface
virtual void init ()=0
 Initializes all data structures of the approximate inference algorithm.
virtual void init (const VarSet &vs)=0
 Initializes all data structures corresponding to some set of variables.
virtual Real run ()=0
 Runs the approximate inference algorithm.
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable.
virtual Factor belief (const VarSet &vs) const =0
 Returns the (approximate) marginal probability distribution of a set of variables.
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i.
virtual Factor beliefF (size_t I) const
 Returns the (approximate) marginal probability distribution of the variables on which factor I depends.
virtual std::vector< Factor > beliefs () const =0
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.
virtual Real logZ () const =0
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).
virtual Real maxDiff () const =0
 Returns maximum difference between single variable beliefs in the last iteration.
virtual size_t Iterations () const =0
 Returns number of iterations done (one iteration passes over the complete factorgraph).
Changing the factor graph
virtual void clamp (size_t i, size_t x, bool backup=false)=0
 Clamp variable with index i to value x (i.e. multiply with a Kronecker delta $\delta_{x_i, x}$).
virtual void makeCavity (size_t i, bool backup=false)=0
 Sets all factors interacting with variable with index i to one.
Backup/restore mechanism for factors
virtual void backupFactor (size_t I)=0
 Make a backup copy of factor I.
virtual void backupFactors (const VarSet &vs)=0
 Make backup copies of all factors involving the variables in vs.
virtual void restoreFactor (size_t I)=0
 Restore factor I from its backup copy.
virtual void restoreFactors (const VarSet &vs)=0
 Restore the factors involving the variables in vs from their backup copies.
Managing parameters
virtual void setProperties (const PropertySet &opts)=0
 Set parameters of this inference algorithm.
virtual PropertySet getProperties () const =0
 Returns parameters of this inference algorithm converted into a PropertySet.
virtual std::string printProperties () const =0
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Detailed Description

InfAlg is an abstract base class, defining the common interface of all inference algorithms in libDAI.

Idea:
General marginalization functions like calcMarginal() now copy a complete InfAlg object. Instead, it would make more sense that they construct a new object without copying the FactorGraph or RegionGraph. Or they can simply be made methods of the general InfAlg class.
Idea:
Use a PropertySet as output of an InfAlg, instead of functions like maxDiff() and Iterations().
Examples:

example_sprinkler_em.cpp.

Constructor & Destructor Documentation

virtual dai::InfAlg::~InfAlg (  )  [inline, virtual]

Virtual destructor (needed because this class contains virtual functions).

Member Function Documentation

virtual InfAlg* dai::InfAlg::clone (  )  const [pure virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Implemented in dai::BP, dai::CBP, dai::ExactInf, dai::FBP, dai::Gibbs, dai::HAK, dai::JTree, dai::LC, dai::MF, dai::MR, dai::TreeEP, and dai::TRWBP.

virtual std::string dai::InfAlg::identify (  )  const [pure virtual]

Identifies itself for logging purposes.

Implemented in dai::BP, dai::CBP, dai::ExactInf, dai::FBP, dai::Gibbs, dai::HAK, dai::JTree, dai::LC, dai::MF, dai::MR, dai::TreeEP, and dai::TRWBP.

virtual FactorGraph& dai::InfAlg::fg (  )  [pure virtual]

Returns reference to underlying FactorGraph.

Implemented in dai::DAIAlg< GRM >, dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

Examples:
example_sprinkler_em.cpp.

virtual const FactorGraph& dai::InfAlg::fg (  )  const [pure virtual]

Returns constant reference to underlying FactorGraph.

Implemented in dai::DAIAlg< GRM >, dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

virtual void dai::InfAlg::init (  )  [pure virtual]

Initializes all data structures of the approximate inference algorithm.

Note:
This method should be called at least once before run() is called.

Implemented in dai::BP, dai::CBP, dai::ExactInf, dai::Gibbs, dai::HAK, dai::JTree, dai::LC, dai::MF, dai::MR, and dai::TreeEP.

Examples:
example_sprinkler_em.cpp.

virtual void dai::InfAlg::init ( const VarSet &  vs  )  [pure virtual]

Initializes all data structures corresponding to some set of variables.

This method can be used to do a partial initialization after a part of the factor graph has changed. Instead of initializing all data structures, it only initializes those involving the variables in vs.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implemented in dai::BP, dai::CBP, dai::ExactInf, dai::Gibbs, dai::HAK, dai::JTree, dai::LC, dai::MF, dai::MR, and dai::TreeEP.

virtual Real dai::InfAlg::run (  )  [pure virtual]

Runs the approximate inference algorithm.

Note:
Before run() is called the first time, init() should have been called.

Implemented in dai::BP, dai::CBP, dai::ExactInf, dai::Gibbs, dai::HAK, dai::JTree, dai::LC, dai::MF, dai::MR, and dai::TreeEP.

virtual Factor dai::InfAlg::belief ( const Var &  v  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of a variable.

Note:
Before this method is called, run() should have been called.

Reimplemented in dai::BP, dai::CBP, dai::ExactInf, dai::Gibbs, dai::LC, dai::MF, and dai::MR.

virtual Factor dai::InfAlg::belief ( const VarSet &  vs  )  const [pure virtual]

Returns the (approximate) marginal probability distribution of a set of variables.

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported.
BELIEF_NOT_AVAILABLE if the requested belief cannot be calculated with this algorithm.

Implemented in dai::BP, dai::CBP, dai::ExactInf, dai::Gibbs, dai::HAK, dai::JTree, dai::LC, dai::MF, and dai::MR.

virtual Factor dai::InfAlg::beliefV ( size_t  i  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of the variable with index i.

For some approximate inference algorithms, using beliefV() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented in dai::BP, dai::CBP, dai::ExactInf, dai::Gibbs, dai::LC, dai::MF, and dai::MR.

virtual Factor dai::InfAlg::beliefF ( size_t  I  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of the variables on which factor I depends.

For some approximate inference algorithms, using beliefF() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented in dai::BP, dai::CBP, dai::ExactInf, and dai::Gibbs.

Examples:
example.cpp.

virtual std::vector<Factor> dai::InfAlg::beliefs (  )  const [pure virtual]

Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.

Note:
Before this method is called, run() should have been called.

Implemented in dai::BP, dai::CBP, dai::ExactInf, dai::Gibbs, dai::HAK, dai::JTree, dai::LC, dai::MF, and dai::MR.

virtual Real dai::InfAlg::logZ (  )  const [pure virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implemented in dai::BP, dai::CBP, dai::ExactInf, dai::FBP, dai::Gibbs, dai::HAK, dai::JTree, dai::LC, dai::MF, dai::MR, dai::TreeEP, and dai::TRWBP.

virtual Real dai::InfAlg::maxDiff (  )  const [pure virtual]

Returns maximum difference between single variable beliefs in the last iteration.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implemented in dai::BP, dai::CBP, dai::ExactInf, dai::Gibbs, dai::HAK, dai::JTree, dai::LC, dai::MF, dai::MR, and dai::TreeEP.

virtual size_t dai::InfAlg::Iterations (  )  const [pure virtual]

Returns number of iterations done (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implemented in dai::BP, dai::CBP, dai::ExactInf, dai::Gibbs, dai::HAK, dai::JTree, dai::LC, dai::MF, dai::MR, and dai::TreeEP.

virtual void dai::InfAlg::clamp ( size_t  i,
size_t  x,
bool  backup = false 
) [pure virtual]

Clamp variable with index i to value x (i.e. multiply with a Kronecker delta $\delta_{x_i, x}$).

If backup == true, make a backup of all factors that are changed.

Implemented in dai::DAIAlg< GRM >, dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

virtual void dai::InfAlg::makeCavity ( size_t  i,
bool  backup = false 
) [pure virtual]

Sets all factors interacting with variable with index i to one.

If backup == true, make a backup of all factors that are changed.

Implemented in dai::DAIAlg< GRM >, dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

virtual void dai::InfAlg::backupFactor ( size_t  I  )  [pure virtual]

Make a backup copy of factor I.

Exceptions:
MULTIPLE_UNDO if a backup already exists

Implemented in dai::DAIAlg< GRM >, dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

virtual void dai::InfAlg::backupFactors ( const VarSet &  vs  )  [pure virtual]

Make backup copies of all factors involving the variables in vs.

Exceptions:
MULTIPLE_UNDO if a backup already exists

Implemented in dai::DAIAlg< GRM >, dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

virtual void dai::InfAlg::restoreFactor ( size_t  I  )  [pure virtual]

Restore factor I from its backup copy.

Implemented in dai::DAIAlg< GRM >, dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

virtual void dai::InfAlg::restoreFactors ( const VarSet &  vs  )  [pure virtual]

Restore the factors involving the variables in vs from their backup copies.

Implemented in dai::DAIAlg< GRM >, dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

virtual void dai::InfAlg::setProperties ( const PropertySet &  opts  )  [pure virtual]

Set parameters of this inference algorithm.

The parameters are set according to the PropertySet opts. The values can be stored either as std::string or as the type of the corresponding MF::props member.

Implemented in dai::BP, dai::CBP, dai::ExactInf, dai::Gibbs, dai::HAK, dai::JTree, dai::LC, dai::MF, dai::MR, and dai::TreeEP.

virtual PropertySet dai::InfAlg::getProperties (  )  const [pure virtual]

Returns parameters of this inference algorithm converted into a PropertySet.

Implemented in dai::BP, dai::CBP, dai::ExactInf, dai::Gibbs, dai::HAK, dai::JTree, dai::LC, dai::MF, dai::MR, and dai::TreeEP.

virtual std::string dai::InfAlg::printProperties (  )  const [pure virtual]

Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Implemented in dai::BP, dai::CBP, dai::ExactInf, dai::Gibbs, dai::HAK, dai::JTree, dai::LC, dai::MF, dai::MR, and dai::TreeEP.

The documentation for this class was generated from the following file:
Generated on Thu Feb 11 12:26:03 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_func_0x7a.html0000644000263000017630000001033211334764772017753 0ustar jorismkyb libDAI: Class Members - Functions
 

- z -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/mf_8h.html0000644000263000017630000000574511334764772015106 0ustar jorismkyb libDAI: include/dai/mf.h File Reference

include/dai/mf.h File Reference

Defines class MF which implements the Mean Field algorithm. More...

#include <string>
#include <dai/daialg.h>
#include <dai/factorgraph.h>
#include <dai/properties.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::MF
 Approximate inference algorithm "Mean Field". More...
struct  dai::MF::Properties
 Parameters for MF. More...

Detailed Description

Defines class MF which implements the Mean Field algorithm.

Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1HAK_1_1Properties-members.html0000644000263000017630000000776011334764772023237 0ustar jorismkyb libDAI: Member List

dai::HAK::Properties Member List

This is the complete list of members for dai::HAK::Properties, including all inherited members.

clustersdai::HAK::Properties
DAI_ENUM(ClustersType, MIN, BETHE, DELTA, LOOP)dai::HAK::Properties
DAI_ENUM(InitType, UNIFORM, RANDOM)dai::HAK::Properties
dampingdai::HAK::Properties
doubleloopdai::HAK::Properties
initdai::HAK::Properties
loopdepthdai::HAK::Properties
maxiterdai::HAK::Properties
toldai::HAK::Properties
verbosedai::HAK::Properties

Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_vars.html0000644000263000017630000004054311334764772017143 0ustar jorismkyb libDAI: Class Members - Variables
 

- _ -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/fbp_8h.html0000644000263000017630000000542411334764772015245 0ustar jorismkyb libDAI: include/dai/fbp.h File Reference

include/dai/fbp.h File Reference

Defines class FBP, which implements Fractional Belief Propagation. More...

#include <string>
#include <dai/daialg.h>
#include <dai/factorgraph.h>
#include <dai/properties.h>
#include <dai/enum.h>
#include <dai/bp.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::FBP
 Approximate inference algorithm "Fractional Belief Propagation" [WiH03]. More...

Detailed Description

Defines class FBP, which implements Fractional Belief Propagation.

Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_vars_0x62.html0000644000263000017630000001040711334764772017716 0ustar jorismkyb libDAI: Class Members - Variables
 

- b -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_72.png0000644000263000017630000000050611334764772015166 0ustar jorismkybPNG  IHDRFW0PLTEppp```PPP@@@000 4tRNS@fIDAT(c``bj8TRÖ2CMf3X(GU(5s j1g`00 Lgb܀^# @`: H3V&9iii)j?M9zAaGG_Gc ә1@h\ T /e2+1*\3g0b`^RH~d`P31,e`z3:(%"3&;ܪ0d8pT'm̙sNOx G@ P/104hb!cVY$$nK&IENDB`libDAI-0.2.4/doc/html/form_35.png0000644000263000017630000000042711334764772015167 0ustar jorismkybPNG  IHDR'^.0PLTEppp```PPP@@@000 4tRNS@fIDATc` 8> lS" \`b`` +Pq!)ጝ` ˠHUA`lR3A !!H= 2OXa 2-Tf`sԖ y ]z$ IENDB`libDAI-0.2.4/doc/html/classdai_1_1LC.html0000644000263000017630000014262311334764772016544 0ustar jorismkyb libDAI: dai::LC Class Reference

dai::LC Class Reference

Approximate inference algorithm "Loop Corrected Belief Propagation" [MoK07]. More...

#include <dai/lc.h>

Inheritance diagram for dai::LC:

dai::DAIAlg< GRM > dai::InfAlg

List of all members.

Public Member Functions

 LC ()
 Default constructor.
 LC (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts.
General InfAlg interface
virtual LC * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
virtual std::string identify () const
 Identifies itself for logging purposes.
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable.
virtual Factor belief (const VarSet &) const
 Returns the (approximate) marginal probability distribution of a set of variables.
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i.
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).
virtual void init ()
 Initializes all data structures of the approximate inference algorithm.
virtual void init (const VarSet &)
 Initializes all data structures corresponding to some set of variables.
virtual Real run ()
 Runs the approximate inference algorithm.
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration.
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph).
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm.
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet.
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".
Additional interface specific for LC
Real CalcCavityDist (size_t i, const std::string &name, const PropertySet &opts)
 Approximates the cavity distribution of variable i, using the inference algorithm name with parameters opts.
Real InitCavityDists (const std::string &name, const PropertySet &opts)
 Approximates all cavity distributions using inference algorithm name with parameters opts.
long SetCavityDists (std::vector< Factor > &Q)
 Sets approximate cavity distributions to Q.
Factor NewPancake (size_t i, size_t _I, bool &hasNaNs)
 Updates the belief of the Markov blanket of variable i based upon the information from its _I 'th neighboring factor.
void CalcBelief (size_t i)
 Calculates the belief of variable i.
const Factor & pancake (size_t i) const
 Returns the belief of the Markov blanket of variable i (including the variable itself).
const Factor & cavitydist (size_t i) const
 Returns the approximate cavity distribution for variable i.

Public Attributes

struct dai::LC::Properties props

Static Public Attributes

static const char * Name = "LC"
 Name of this inference algorithm.

Private Attributes

std::vector< Factor > _pancakes
 Stores for each variable the approximate cavity distribution multiplied with the omitted factors.
std::vector< Factor > _cavitydists
 Stores for each variable the approximate cavity distribution.
std::vector< std::vector
< Factor > > 		_phis
 _phis[i][_I] corresponds to $ \phi^{\setminus i}_I(x_{I \setminus i}) $ in the paper
std::vector< Factor > _beliefs
 Single variable beliefs.
Real _maxdiff
 Maximum difference encountered so far.
size_t _iters
 Number of iterations needed.

Classes

struct  Properties
 Parameters for LC. More...

Detailed Description

Approximate inference algorithm "Loop Corrected Belief Propagation" [MoK07].

Constructor & Destructor Documentation

dai::LC::LC (  )  [inline]

Default constructor.

dai::LC::LC ( const FactorGraph &  fg,
const PropertySet &  opts 
)

Construct from FactorGraph fg and PropertySet opts.

Parameters:
opts Parameters
See also:
Properties

Member Function Documentation

virtual LC* dai::LC::clone (  )  const [inline, virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Implements dai::InfAlg.

string dai::LC::identify (  )  const [virtual]

Identifies itself for logging purposes.

Implements dai::InfAlg.

virtual Factor dai::LC::belief ( const Var &  v  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of a variable.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

virtual Factor dai::LC::belief ( const VarSet &  vs  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of a set of variables.

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported.
BELIEF_NOT_AVAILABLE if the requested belief cannot be calculated with this algorithm.

Implements dai::InfAlg.

virtual Factor dai::LC::beliefV ( size_t  i  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of the variable with index i.

For some approximate inference algorithms, using beliefV() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

virtual std::vector<Factor> dai::LC::beliefs (  )  const [inline, virtual]

Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.

Note:
Before this method is called, run() should have been called.

Implements dai::InfAlg.

virtual Real dai::LC::logZ (  )  const [inline, virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

void dai::LC::init (  )  [virtual]

Initializes all data structures of the approximate inference algorithm.

Note:
This method should be called at least once before run() is called.

Implements dai::InfAlg.

virtual void dai::LC::init ( const VarSet &  vs  )  [inline, virtual]

Initializes all data structures corresponding to some set of variables.

This method can be used to do a partial initialization after a part of the factor graph has changed. Instead of initializing all data structures, it only initializes those involving the variables in vs.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

Real dai::LC::run (  )  [virtual]

Runs the approximate inference algorithm.

Note:
Before run() is called the first time, init() should have been called.

Implements dai::InfAlg.

virtual Real dai::LC::maxDiff (  )  const [inline, virtual]

Returns maximum difference between single variable beliefs in the last iteration.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

virtual size_t dai::LC::Iterations (  )  const [inline, virtual]

Returns number of iterations done (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

void dai::LC::setProperties ( const PropertySet &  opts  )  [virtual]

Set parameters of this inference algorithm.

The parameters are set according to the PropertySet opts. The values can be stored either as std::string or as the type of the corresponding MF::props member.

Implements dai::InfAlg.

PropertySet dai::LC::getProperties (  )  const [virtual]

Returns parameters of this inference algorithm converted into a PropertySet.

Implements dai::InfAlg.

string dai::LC::printProperties (  )  const [virtual]

Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Implements dai::InfAlg.

Real dai::LC::CalcCavityDist ( size_t  i,
const std::string &  name,
const PropertySet &  opts 
)

Approximates the cavity distribution of variable i, using the inference algorithm name with parameters opts.

Real dai::LC::InitCavityDists ( const std::string &  name,
const PropertySet &  opts 
)

Approximates all cavity distributions using inference algorithm name with parameters opts.

long dai::LC::SetCavityDists ( std::vector< Factor > &  Q  ) 

Sets approximate cavity distributions to Q.

Factor dai::LC::NewPancake ( size_t  i,
size_t  _I,
bool &  hasNaNs 
)

Updates the belief of the Markov blanket of variable i based upon the information from its _I 'th neighboring factor.

void dai::LC::CalcBelief ( size_t  i  ) 

Calculates the belief of variable i.

const Factor& dai::LC::pancake ( size_t  i  )  const [inline]

Returns the belief of the Markov blanket of variable i (including the variable itself).

const Factor& dai::LC::cavitydist ( size_t  i  )  const [inline]

Returns the approximate cavity distribution for variable i.

Member Data Documentation

std::vector<Factor> dai::LC::_pancakes [private]

Stores for each variable the approximate cavity distribution multiplied with the omitted factors.

std::vector<Factor> dai::LC::_cavitydists [private]

Stores for each variable the approximate cavity distribution.

std::vector<std::vector<Factor> > dai::LC::_phis [private]

_phis[i][_I] corresponds to $ \phi^{\setminus i}_I(x_{I \setminus i}) $ in the paper

std::vector<Factor> dai::LC::_beliefs [private]

Single variable beliefs.

Real dai::LC::_maxdiff [private]

Maximum difference encountered so far.

size_t dai::LC::_iters [private]

Number of iterations needed.

const char * dai::LC::Name = "LC" [static]

Name of this inference algorithm.

The documentation for this class was generated from the following files:
  • include/dai/lc.h
  • src/lc.cpp
Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_0x68.html0000644000263000017630000001223211334764772016667 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- h -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/inline_dotgraph_1.dot.png0000644000263000017630000000215111334764772020064 0ustar jorismkybPNG  IHDR:!PLTEOOO444iiinnatRNS@fIDATxKs0%+N fzF0$@cK'Q>%vcYݕ ҡWzxҟ***,>^rXhUXu*ckZ5r0kǚ5ʛHUBvo̹ͺϹO7Xa/m(@R2J=l_mA)F?|\SdzUc>0S;&ZS'ن9F1{S1J~4~MRi_UXUXϝ!.Va3eſ&E***' oUIENDB`libDAI-0.2.4/doc/html/classdai_1_1Region-members.html0000644000263000017630000003360011334764772021113 0ustar jorismkyb libDAI: Member List

dai::Region Member List

This is the complete list of members for dai::Region, including all inherited members.

_cdai::Region [private]
begin()dai::SmallSet< T > [inline]
begin() const dai::SmallSet< T > [inline]
c() const dai::Region [inline]
c()dai::Region [inline]
const_iterator typedefdai::SmallSet< T >
const_reverse_iterator typedefdai::SmallSet< T >
contains(const T &t) const dai::SmallSet< T > [inline]
elements()dai::SmallSet< T > [inline]
elements() const dai::SmallSet< T > [inline]
empty() const dai::SmallSet< T > [inline]
end()dai::SmallSet< T > [inline]
end() const dai::SmallSet< T > [inline]
front()dai::SmallSet< T > [inline]
front() const dai::SmallSet< T > [inline]
intersects(const SmallSet &x) const dai::SmallSet< T > [inline]
iterator typedefdai::SmallSet< T >
nrStates() const dai::VarSet [inline]
operator &(const SmallSet &x) const dai::SmallSet< T > [inline]
operator &=(const SmallSet &x)dai::SmallSet< T > [inline]
operator!=(const SmallSet &a, const SmallSet &b)dai::SmallSet< T > [friend]
operator/(const SmallSet &x) const dai::SmallSet< T > [inline]
operator/=(const SmallSet &x)dai::SmallSet< T > [inline]
operator/=(const T &t)dai::SmallSet< T > [inline]
operator<(const SmallSet &a, const SmallSet &b)dai::SmallSet< T > [friend]
operator<<(std::ostream &os, const VarSet &vs)dai::VarSet [friend]
dai::SmallSet::operator<<(const SmallSet &x) const dai::SmallSet< T > [inline]
operator==(const SmallSet &a, const SmallSet &b)dai::SmallSet< T > [friend]
operator>>(const SmallSet &x) const dai::SmallSet< T > [inline]
operator|(const SmallSet &x) const dai::SmallSet< T > [inline]
operator|=(const SmallSet &x)dai::SmallSet< T > [inline]
operator|=(const T &t)dai::SmallSet< T > [inline]
rbegin()dai::SmallSet< T > [inline]
rbegin() const dai::SmallSet< T > [inline]
Region()dai::Region [inline]
Region(const VarSet &x, Real c)dai::Region [inline]
rend()dai::SmallSet< T > [inline]
rend() const dai::SmallSet< T > [inline]
reverse_iterator typedefdai::SmallSet< T >
size() const dai::SmallSet< T > [inline]
SmallSet()dai::SmallSet< T > [inline]
SmallSet(const T &t)dai::SmallSet< T > [inline]
SmallSet(const T &t1, const T &t2)dai::SmallSet< T > [inline]
SmallSet(TIterator begin, TIterator end, size_t sizeHint=0)dai::SmallSet< T > [inline]
VarSet()dai::VarSet [inline]
VarSet(const SmallSet< Var > &x)dai::VarSet [inline]
VarSet(const Var &v)dai::VarSet [inline]
VarSet(const Var &v1, const Var &v2)dai::VarSet [inline]
VarSet(VarIterator begin, VarIterator end, size_t sizeHint=0)dai::VarSet [inline]

Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_96.png0000644000263000017630000000032011334764772015166 0ustar jorismkybPNG  IHDR]R0PLTEppp```PPP@@@000 4tRNS@fNIDATc`@JPහ14PVs#X10+l~Z[ @s+ 2 iZnBIENDB`libDAI-0.2.4/doc/html/form_57.png0000644000263000017630000000031311334764772015165 0ustar jorismkybPNG  IHDR Rio0PLTEppp```PPP@@@000 4tRNS@fIIDATc`,)`f #qQ-cAV`f`YJH KP \a-IENDB`libDAI-0.2.4/doc/html/classdai_1_1MR.png0000644000263000017630000000104511334764772016374 0ustar jorismkybPNG  IHDR<)PLTE`{tRNS@fIDAThAr0 P :텺G-Fn xF a1aL1Voӻ*+M |Š D:@j⡼@\FON v \Rs we|kh݂U Y?р'ey2p``/PYF 15&~ qUt DZΪS0#C#dDbZvf 44)(cb r<#=P rXÌI @p PazͰl. +F 0^yC‘nv=@S / |9`s" q[T' 9y2?_BW-IENDB`libDAI-0.2.4/doc/html/structdai_1_1fo__KL.html0000644000263000017630000000774611334764772017624 0ustar jorismkyb libDAI: dai::fo_KL< T > Struct Template Reference

dai::fo_KL< T > Struct Template Reference

Function object useful for calculating the KL distance. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &p, const T &q) const
 Returns (p == 0 ? 0 : (p * (log(p) - log(q)))).

Detailed Description

template<typename T>
struct dai::fo_KL< T >

Function object useful for calculating the KL distance.

Member Function Documentation

template<typename T>
T dai::fo_KL< T >::operator() ( const T &  p,
const T &  q 
) const [inline]

Returns (p == 0 ? 0 : (p * (log(p) - log(q)))).

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1fo__absdiff.html0000644000263000017630000000772711334764772020713 0ustar jorismkyb libDAI: dai::fo_absdiff< T > Struct Template Reference

dai::fo_absdiff< T > Struct Template Reference

Function object that returns the absolute difference of x and y. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &x, const T &y) const
 Returns abs( x - y ).

Detailed Description

template<typename T>
struct dai::fo_absdiff< T >

Function object that returns the absolute difference of x and y.

Member Function Documentation

template<typename T>
T dai::fo_absdiff< T >::operator() ( const T &  x,
const T &  y 
) const [inline]

Returns abs( x - y ).

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1Permute-members.html0000644000263000017630000000743311334764772021316 0ustar jorismkyb libDAI: Member List

dai::Permute Member List

This is the complete list of members for dai::Permute, including all inherited members.

_rangesdai::Permute [private]
_sigmadai::Permute [private]
convertLinearIndex(size_t li) const dai::Permute [inline]
operator[](size_t i) const dai::Permute [inline]
Permute()dai::Permute [inline]
Permute(const std::vector< size_t > &rs, const std::vector< size_t > &sigma)dai::Permute [inline]
Permute(const std::vector< Var > &vars)dai::Permute [inline]
sigma() const dai::Permute [inline]
sigma()dai::Permute [inline]

Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1ExactInf_1_1Properties.html0000644000263000017630000000721211334764772022675 0ustar jorismkyb libDAI: dai::ExactInf::Properties Struct Reference

dai::ExactInf::Properties Struct Reference

Parameters for ExactInf. More...

#include <dai/exactinf.h>

List of all members.

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr).

Detailed Description

Parameters for ExactInf.

Member Data Documentation

size_t dai::ExactInf::Properties::verbose

Verbosity (amount of output sent to stderr).

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:04 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1fo__pow.html0000644000263000017630000000757511334764772020123 0ustar jorismkyb libDAI: dai::fo_pow< T > Struct Template Reference

dai::fo_pow< T > Struct Template Reference

Function object that returns x to the power y. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &x, const T &y) const
 Returns (x ^ y).

Detailed Description

template<typename T>
struct dai::fo_pow< T >

Function object that returns x to the power y.

Member Function Documentation

template<typename T>
T dai::fo_pow< T >::operator() ( const T &  x,
const T &  y 
) const [inline]

Returns (x ^ y).

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1HAK_1_1Properties.html0000644000263000017630000003535211334764772021605 0ustar jorismkyb libDAI: dai::HAK::Properties Struct Reference

dai::HAK::Properties Struct Reference

Parameters for HAK. More...

#include <dai/hak.h>

List of all members.

Public Member Functions

 DAI_ENUM (ClustersType, MIN, BETHE, DELTA, LOOP)
 Enumeration of possible cluster choices.
 DAI_ENUM (InitType, UNIFORM, RANDOM)
 Enumeration of possible message initializations.

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr).
size_t maxiter
 Maximum number of iterations.
Real tol
 Tolerance for convergence test.
Real damping
 Damping constant (0.0 means no damping, 1.0 is maximum damping).
ClustersType clusters
 How to choose the outer regions.
InitType init
 How to initialize the messages.
bool doubleloop
 Use single-loop (GBP) or double-loop (HAK).
size_t loopdepth
 Depth of loops (only relevant for clusters == ClustersType::LOOP).

Detailed Description

Parameters for HAK.

Member Function Documentation

dai::HAK::Properties::DAI_ENUM ( ClustersType  ,
MIN  ,
BETHE  ,
DELTA  ,
LOOP   
)

Enumeration of possible cluster choices.

The following cluster choices are defined:

  • MIN minimal clusters, i.e., one outer region for each maximal factor
  • DELTA one outer region for each variable and its Markov blanket
  • LOOP one cluster for each loop of length at most Properties::loopdepth, and in addition one cluster for each maximal factor
  • BETHE Bethe approximation (one outer region for each maximal factor, inner regions are single variables)

dai::HAK::Properties::DAI_ENUM ( InitType  ,
UNIFORM  ,
RANDOM   
)

Enumeration of possible message initializations.

Member Data Documentation

size_t dai::HAK::Properties::verbose

Verbosity (amount of output sent to stderr).

size_t dai::HAK::Properties::maxiter

Maximum number of iterations.

Real dai::HAK::Properties::tol

Tolerance for convergence test.

Real dai::HAK::Properties::damping

Damping constant (0.0 means no damping, 1.0 is maximum damping).

ClustersType dai::HAK::Properties::clusters

How to choose the outer regions.

InitType dai::HAK::Properties::init

How to initialize the messages.

bool dai::HAK::Properties::doubleloop

Use single-loop (GBP) or double-loop (HAK).

size_t dai::HAK::Properties::loopdepth

Depth of loops (only relevant for clusters == ClustersType::LOOP).

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1FRegion.png0000644000263000017630000000062511334764772017412 0ustar jorismkybPNG  IHDRnP ]PLTE`{tRNS@f+IDATXKn `ڿo텺P5*A)DOa4 s޷x{ 'G!-~\Y_ :YT.M`-6澓 bOq:QiҟR ^:zN>\a>okp|ϋfR)9gX 'V[\n[n@S[/b-,c@1yՁC"iݚ)ڄnbzKuX{Ζr>J/e d/9 ԜJءwr>c&g,:xI?GwQZMIENDB`libDAI-0.2.4/doc/html/classdai_1_1ClusterGraph-members.html0000644000263000017630000001604711334764772022301 0ustar jorismkyb libDAI: Member List

dai::ClusterGraph Member List

This is the complete list of members for dai::ClusterGraph, including all inherited members.

adj(size_t i1, size_t i2) const dai::ClusterGraph [inline]
ClusterGraph()dai::ClusterGraph [inline]
ClusterGraph(const std::vector< VarSet > &cls)dai::ClusterGraph
clustersdai::ClusterGraph
Delta(size_t i) const dai::ClusterGraph [inline]
delta(size_t i) const dai::ClusterGraph [inline]
Edge typedefdai::ClusterGraph
eliminationCost(size_t i) const dai::ClusterGraph
eraseNonMaximal()dai::ClusterGraph [inline]
eraseSubsuming(size_t i)dai::ClusterGraph [inline]
findVar(const Var &n) const dai::ClusterGraph [inline]
Gdai::ClusterGraph
insert(const VarSet &cl)dai::ClusterGraph [inline]
isMaximal(size_t I) const dai::ClusterGraph [inline]
Neighbor typedefdai::ClusterGraph
operator<<(std::ostream &os, const ClusterGraph &cl)dai::ClusterGraph [friend]
size() const dai::ClusterGraph [inline]
toVector() const dai::ClusterGraph [inline]
VarElim(EliminationChoice f) const dai::ClusterGraph [inline]
VarElim(const std::vector< Var > &ElimSeq) const dai::ClusterGraph
VarElim_MinFill() const dai::ClusterGraph
varsdai::ClusterGraph

Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/mr_8h-source.html0000644000263000017630000007517211334764772016421 0ustar jorismkyb libDAI: include/dai/mr.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_127.png0000644000263000017630000000045611334764772015253 0ustar jorismkybPNG  IHDR#ni0PLTEppp```PPP@@@000 4tRNS@fIDATc`1ԁB\X \D8Xp9  l <\@5/z< \7Bu,?&X10330/ ÄBaB >2 ?dVJ繛yM,b `e``Fq=,F`=k u%IENDB`libDAI-0.2.4/doc/html/classdai_1_1TreeEP_1_1TreeEPSubTree.html0000644000263000017630000007111611334764772022367 0ustar jorismkyb libDAI: dai::TreeEP::TreeEPSubTree Class Reference

dai::TreeEP::TreeEPSubTree Class Reference

Stores the data structures needed to efficiently update the approximation of an off-tree factor. More...

List of all members.

Public Member Functions

void init ()
 Initializes beliefs of this subtree.
void InvertAndMultiply (const std::vector< Factor > &Qa, const std::vector< Factor > &Qb)
 Inverts this approximation and multiplies it by the (super) junction tree marginals Qa and Qb.
void HUGIN_with_I (std::vector< Factor > &Qa, std::vector< Factor > &Qb)
 Runs junction tree algorithm (including off-tree factor I) storing the results in the (super) junction tree Qa and Qb.
Real logZ (const std::vector< Factor > &Qa, const std::vector< Factor > &Qb) const
 Returns energy (?) of this subtree.
const Factor *& I ()
 Returns constant reference to the pointer to the off-tree factor.
Constructors/destructors
 TreeEPSubTree ()
 Default constructor.
 TreeEPSubTree (const TreeEPSubTree &x)
 Copy constructor.
TreeEPSubTree & operator= (const TreeEPSubTree &x)
 Assignment operator.
 TreeEPSubTree (const RootedTree &subRTree, const RootedTree &jt_RTree, const std::vector< Factor > &jt_Qa, const std::vector< Factor > &jt_Qb, const Factor *I)
 Construct from subRTree, which is a subtree of the main tree jt_RTree, with distribution represented by jt_Qa and jt_Qb, for off-tree factor I.

Private Attributes

std::vector< Factor > _Qa
 Outer region pseudomarginals (corresponding with the $\tilde f_i(x_j,x_k)$ in [MiQ04]).
std::vector< Factor > _Qb
 Inner region pseudomarginals (corresponding with the $\tilde f_i(x_s)$ in [MiQ04]).
RootedTree _RTree
 The junction tree (stored as a rooted tree).
std::vector< size_t > _a
 Index conversion table for outer region indices (_Qa[alpha] corresponds with Qa[_a[alpha]] of the supertree).
std::vector< size_t > _b
 Index conversion table for inner region indices (_Qb[beta] corresponds with Qb[_b[beta]] of the supertree).
const Factor * _I
 Pointer to off-tree factor.
VarSet _ns
 Variables in off-tree factor.
VarSet _nsrem
 Variables in off-tree factor which are not in the root of this subtree.
Real _logZ
 Used for calculating the free energy.

Detailed Description

Stores the data structures needed to efficiently update the approximation of an off-tree factor.

The TreeEP object stores a TreeEPSubTree object for each off-tree factor. It stores the approximation of that off-tree factor, which is represented as a distribution on a subtree of the main tree.

Constructor & Destructor Documentation

dai::TreeEP::TreeEPSubTree::TreeEPSubTree (  )  [inline]

Default constructor.

dai::TreeEP::TreeEPSubTree::TreeEPSubTree ( const TreeEPSubTree &  x  )  [inline]

Copy constructor.

dai::TreeEP::TreeEPSubTree::TreeEPSubTree ( const RootedTree &  subRTree,
const RootedTree &  jt_RTree,
const std::vector< Factor > &  jt_Qa,
const std::vector< Factor > &  jt_Qb,
const Factor *  I 
)

Construct from subRTree, which is a subtree of the main tree jt_RTree, with distribution represented by jt_Qa and jt_Qb, for off-tree factor I.

Member Function Documentation

TreeEPSubTree& dai::TreeEP::TreeEPSubTree::operator= ( const TreeEPSubTree &  x  )  [inline]

Assignment operator.

void dai::TreeEP::TreeEPSubTree::init (  ) 

Initializes beliefs of this subtree.

void dai::TreeEP::TreeEPSubTree::InvertAndMultiply ( const std::vector< Factor > &  Qa,
const std::vector< Factor > &  Qb 
)

Inverts this approximation and multiplies it by the (super) junction tree marginals Qa and Qb.

void dai::TreeEP::TreeEPSubTree::HUGIN_with_I ( std::vector< Factor > &  Qa,
std::vector< Factor > &  Qb 
)

Runs junction tree algorithm (including off-tree factor I) storing the results in the (super) junction tree Qa and Qb.

Real dai::TreeEP::TreeEPSubTree::logZ ( const std::vector< Factor > &  Qa,
const std::vector< Factor > &  Qb 
) const

Returns energy (?) of this subtree.

const Factor*& dai::TreeEP::TreeEPSubTree::I (  )  [inline]

Returns constant reference to the pointer to the off-tree factor.

Member Data Documentation

std::vector<Factor> dai::TreeEP::TreeEPSubTree::_Qa [private]

Outer region pseudomarginals (corresponding with the $\tilde f_i(x_j,x_k)$ in [MiQ04]).

std::vector<Factor> dai::TreeEP::TreeEPSubTree::_Qb [private]

Inner region pseudomarginals (corresponding with the $\tilde f_i(x_s)$ in [MiQ04]).

RootedTree dai::TreeEP::TreeEPSubTree::_RTree [private]

The junction tree (stored as a rooted tree).

std::vector<size_t> dai::TreeEP::TreeEPSubTree::_a [private]

Index conversion table for outer region indices (_Qa[alpha] corresponds with Qa[_a[alpha]] of the supertree).

std::vector<size_t> dai::TreeEP::TreeEPSubTree::_b [private]

Index conversion table for inner region indices (_Qb[beta] corresponds with Qb[_b[beta]] of the supertree).

const Factor* dai::TreeEP::TreeEPSubTree::_I [private]

Pointer to off-tree factor.

VarSet dai::TreeEP::TreeEPSubTree::_ns [private]

Variables in off-tree factor.

VarSet dai::TreeEP::TreeEPSubTree::_nsrem [private]

Variables in off-tree factor which are not in the root of this subtree.

Real dai::TreeEP::TreeEPSubTree::_logZ [private]

Used for calculating the free energy.

The documentation for this class was generated from the following files:
Generated on Thu Feb 11 12:26:07 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1ExactInf.png0000644000263000017630000000110411334764772017553 0ustar jorismkybPNG  IHDR<)PLTE`{tRNS@fIDAThAr E&kt uH2X$N äI)6c@~/_s|)s- Q@*1 HH|Mbt8,7 (sp ́V5]6 MU 0Z?ӑ'N/P8p\7 jE樖ew&/"d!EPe 5@a*G5^P"AՕ`p*~τ* @AQyE,$ `U,Vn@@XlspvCX!9u\7:ps8v4s\-DZw!e-n!|qىWc+^\b8@–(WTnf rLzZ(9ZN~}Qs?̾{IENDB`libDAI-0.2.4/doc/html/classdai_1_1GraphEL-members.html0000644000263000017630000000410411334764772021147 0ustar jorismkyb libDAI: Member List

dai::GraphEL Member List

This is the complete list of members for dai::GraphEL, including all inherited members.

GraphEL()dai::GraphEL [inline]
GraphEL(InputIterator begin, InputIterator end)dai::GraphEL [inline]

Generated on Thu Feb 11 12:26:08 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_0x73.html0000644000263000017630000002566311334764772016677 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- s -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1ParameterEstimation.png0000644000263000017630000000110611334764772022031 0ustar jorismkybPNG  IHDRP*{PLTE`{tRNS@fIDATXm l6p&qT`PNHGD 9]e„in[,hmIP,[3 X0xkXY W(K Q-sJnX1;W N`F ATSaJ+$: ѽ^8,k,zawVzb!D~fu'P Sga\c0˼OV;pEF5h3R1Zuάi/,K~)?YG*N`;&*N`;&*N`;&*}/g:Vf8eX3>r=zdUpՃaeOwHdfe1WL2dž\Y+vnfqLr3XzgǗx\ciTnyQ^ 2%F%+`g -bάx'P>;ǹ^S}ik+ՓW32>5Y7ZZoQ_\IENDB`libDAI-0.2.4/doc/html/classdai_1_1FactorGraph.png0000644000263000017630000000227411334764772020263 0ustar jorismkybPNG  IHDR?pPLTE`{tRNS@fRIDATx[ EO; Q5U0vlr+&E!:8]i=x)i Y] j DC;PozQ%YMRޘy'QZ?Rhʄ64zŁRa VZuzƉFar~& AGgDKă8<:&1̒$5 kkMĚ  $a$w|Ұc?ީ+ եTAړ< UA 9A 9A}~%BK:2݇3mHOtAҟI$iNI<'a`a`a`a`a`a`a`a`a`a`a`a`a`a`afp>_f , 8c`L,W3{3v54IKc֦ YGm<$q! pV&l9Ff/LC$,-  mwy\ OX/9~Kt_d-6&t*n&I;ի: I[FgH/$1`J3--B֩yjĘ͒$;ER# 4{Z;% p$&Mbn5Lb :ܚIOr0 gI$/%}<}4vޕ˹)Zս:߻0ےG}n6mC#H< ~be!q$$ۡ-K/H*A$ &7h] JN}3oCRQ¢g NL^:2y NL^:2y NL^:2y NL^:2y NL^:2y NL^:=r^AL$dCҖ9ZII2Y _f%YʫÜ$]>{B'Kt_I\)R?lH]}i]-T?lI\*^fMkҖJ'}0>iKtM) _?wa鉪^Hɩ^H&,|~ok A W"@QfIENDB`libDAI-0.2.4/doc/html/form_63.png0000644000263000017630000000077011334764772015171 0ustar jorismkybPNG  IHDRΪq0PLTEppp```PPP@@@000 4tRNS@fvIDAT8c``&AV6f06@؄GS I_AK^ 3t10p,> 2# Ð# m3( X>0|1 E2!a7} 2 L 8gΜ9!/p 굲 2,@fB aTu0]FmGGGa „?wX/@2a>{AAAp0~d2e Et'` /U@HJb֏ (Rb&C;# ، S7! g8T 7)  ıh솀L4Rvb~IENDB`libDAI-0.2.4/doc/html/classdai_1_1Gibbs.png0000644000263000017630000000106311334764772017104 0ustar jorismkybPNG  IHDR<)PLTE`{tRNS@fIDAThQr `x37XNi/']l410LL䓀:sG*q@V`ʱ@}R7(\8nIG`h;rKsp t΁${k螃Â~0~Rog~|=x\ <*88bƧQZ-135&^'f]X -jSP[aֈ#O-@LI \Gv-Ar¢\ϯpόҕ< :: ֘"S*t&,n^d=SnXvpRxns8\FnY ikУ!\IK+w1@9yvv'P::`&En ao^r 9, ρB U* 0 :*IVBX IENDB`libDAI-0.2.4/doc/html/classdai_1_1BP__dual-members.html0000644000263000017630000001752311334764772021343 0ustar jorismkyb libDAI: Member List

dai::BP_dual Member List

This is the complete list of members for dai::BP_dual, including all inherited members.

_beliefsdai::BP_dual [protected]
_iadai::BP_dual [protected]
_msgsdai::BP_dual [protected]
beliefF(size_t I) const dai::BP_dual [inline]
beliefFZ(size_t I) const dai::BP_dual [inline]
beliefV(size_t i) const dai::BP_dual [inline]
beliefVZ(size_t i) const dai::BP_dual [inline]
BP_dual(const InfAlg *ia)dai::BP_dual [inline]
calcBeliefF(size_t I)dai::BP_dual [protected]
calcBeliefs()dai::BP_dual [protected]
calcBeliefV(size_t i)dai::BP_dual [protected]
calcMessages()dai::BP_dual [protected]
calcNewM(size_t i, size_t _I)dai::BP_dual [protected]
calcNewN(size_t i, size_t _I)dai::BP_dual [protected]
fg() const dai::BP_dual [inline]
init()dai::BP_dual [protected]
msgM(size_t i, size_t _I)dai::BP_dual [inline]
msgM(size_t i, size_t _I) const dai::BP_dual [inline]
msgN(size_t i, size_t _I)dai::BP_dual [inline]
msgN(size_t i, size_t _I) const dai::BP_dual [inline]
regenerateBeliefs()dai::BP_dual [protected]
regenerateMessages()dai::BP_dual [protected]
zM(size_t i, size_t _I)dai::BP_dual [inline]
zM(size_t i, size_t _I) const dai::BP_dual [inline]
zN(size_t i, size_t _I)dai::BP_dual [inline]
zN(size_t i, size_t _I) const dai::BP_dual [inline]

Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1BipartiteGraph_1_1Neighbor-members.html0000644000263000017630000000645311334764772025140 0ustar jorismkyb libDAI: Member List

dai::BipartiteGraph::Neighbor Member List

This is the complete list of members for dai::BipartiteGraph::Neighbor, including all inherited members.

dualdai::BipartiteGraph::Neighbor
iterdai::BipartiteGraph::Neighbor
Neighbor()dai::BipartiteGraph::Neighbor [inline]
Neighbor(size_t iter, size_t node, size_t dual)dai::BipartiteGraph::Neighbor [inline]
nodedai::BipartiteGraph::Neighbor
operator size_t() const dai::BipartiteGraph::Neighbor [inline]

Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1ExactInf_1_1Properties-members.html0000644000263000017630000000356611334764772024335 0ustar jorismkyb libDAI: Member List

dai::ExactInf::Properties Member List

This is the complete list of members for dai::ExactInf::Properties, including all inherited members.

verbosedai::ExactInf::Properties

Generated on Thu Feb 11 12:26:04 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_46.png0000644000263000017630000000147411334764772015174 0ustar jorismkybPNG  IHDR+D0PLTEppp```PPP@@@000 4tRNS@fIDATHOk`Ӵ%vItRZVNE&nz)Tꔵl{x@`/`*7O`0D/`Tt>OI6M:y>}$O ג ^3=nͷ ;bdyEQާͳ>V3>X+l$/R-7| īv9Oˣ"uX]ysufU2A~b=BY,N0NUyۡ 6 $J-0 )g*A=QG鑃GΘb4VF;x{v;WM0.Otib1護rs&PaܸB4q1|>)yǸ-L _IVg`RtKFkV2,/hR:\FVˬtD* f#Nv;kdsۍ9Tb ;+ PiiX*nrE}Roe`cnX;;L{(.c"Xw2ywݿIWT#bcl=?dWؼ"\"'c m9,bDп*kBkSUY!ⳗhIa+Fֺ._ maZ2<0BW}GZsClk+i?//SZWRh?> i~6ǾIENDB`libDAI-0.2.4/doc/html/functions_func_0x7e.html0000644000263000017630000001124011334764772017756 0ustar jorismkyb libDAI: Class Members - Functions
 

- ~ -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_vars_0x6d.html0000644000263000017630000001254611334764772020006 0ustar jorismkyb libDAI: Class Members - Variables
 

- m -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_func_0x67.html0000644000263000017630000001777211334764772017717 0ustar jorismkyb libDAI: Class Members - Functions
 

- g -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/trwbp_8h-source.html0000644000263000017630000003432411334764772017133 0ustar jorismkyb libDAI: include/dai/trwbp.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/tab_b.gif0000644000263000017630000000004311334764772014737 0ustar jorismkybGIF89a,D;libDAI-0.2.4/doc/html/classdai_1_1GraphAL.html0000644000263000017630000011450111334764772017516 0ustar jorismkyb libDAI: dai::GraphAL Class Reference

dai::GraphAL Class Reference

Represents the neighborhood structure of nodes in an undirected graph. More...

#include <dai/graph.h>

List of all members.

Public Types

typedef std::vector< Neighbor > Neighbors
 Describes the neighbors of some node.
typedef std::pair< size_t, size_t > Edge
 Represents an edge: an Edge(n1,n2) corresponds to the edge between node n1 and node n2.

Public Member Functions

Constructors and destructors
 GraphAL ()
 Default constructor (creates an empty graph).
 GraphAL (size_t nr)
 Constructs GraphAL with nr nodes and no edges.
template<typename EdgeInputIterator>
 GraphAL (size_t nr, EdgeInputIterator begin, EdgeInputIterator end)
 Constructs GraphAL from a range of edges.
Accessors and mutators
const Neighbor & nb (size_t n1, size_t _n2) const
 Returns constant reference to the _n2 'th neighbor of node n1.
Neighbor & nb (size_t n1, size_t _n2)
 Returns reference to the _n2 'th neighbor of node n1.
const Neighbors & nb (size_t n) const
 Returns constant reference to all neighbors of node n.
Neighbors & nb (size_t n)
 Returns reference to all neighbors of node n.
Adding nodes and edges
template<typename EdgeInputIterator>
void construct (size_t nr, EdgeInputIterator begin, EdgeInputIterator end)
 (Re)constructs GraphAL from a range of edges.
size_t addNode ()
 Adds a node without neighbors and returns the index of the added node.
template<typename NodeInputIterator>
size_t addNode (NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0)
 Adds a node, with neighbors specified by a range of nodes.
void addEdge (size_t n1, size_t n2, bool check=true)
 Adds an edge between node n1 and node n2.
Erasing nodes and edges
void eraseNode (size_t n)
 Removes node n and all incident edges; indices of other nodes are changed accordingly.
void eraseEdge (size_t n1, size_t n2)
 Removes edge between node n1 and node n2.
Queries
size_t nrNodes () const
 Returns number of nodes.
size_t nrEdges () const
 Calculates the number of edges, time complexity: O(nrNodes()).
bool isConnected () const
 Returns true if the graph is connected.
bool isTree () const
 Returns true if the graph is a tree, i.e., if it is singly connected and connected.
void checkConsistency () const
 Checks internal consistency.
Input and output
void printDot (std::ostream &os) const
 Writes this GraphAL to an output stream in GraphALViz .dot syntax.

Private Types

typedef std::vector< size_t > levelType
 Used internally by isTree().

Private Attributes

std::vector< Neighbors > _nb
 Contains for each node a vector of its neighbors.

Classes

struct  Neighbor
 Describes the neighbor relationship of two nodes in a GraphAL. More...

Detailed Description

Represents the neighborhood structure of nodes in an undirected graph.

A graph has nodes connected by edges. Nodes are indexed by an unsigned integer. If there are nrNodes() nodes, they are numbered 0,1,2,...,nrNodes()-1. An edge between node n1 and node n2 is represented by a GraphAL::Edge(n1,n2).

GraphAL is implemented as a sparse adjacency list, i.e., it stores for each node a list of its neighboring nodes. The list of neighboring nodes is implemented as a vector of Neighbor structures (accessible by the nb() method). Thus, each node has an associated variable of type GraphAL::Neighbors, which is a vector of Neighbor structures, describing its neighboring nodes.

Member Typedef Documentation

typedef std::vector<Neighbor> dai::GraphAL::Neighbors

Describes the neighbors of some node.

typedef std::pair<size_t,size_t> dai::GraphAL::Edge

Represents an edge: an Edge(n1,n2) corresponds to the edge between node n1 and node n2.

typedef std::vector<size_t> dai::GraphAL::levelType [private]

Used internally by isTree().

Constructor & Destructor Documentation

dai::GraphAL::GraphAL (  )  [inline]

Default constructor (creates an empty graph).

dai::GraphAL::GraphAL ( size_t  nr  )  [inline]

Constructs GraphAL with nr nodes and no edges.

template<typename EdgeInputIterator>
dai::GraphAL::GraphAL ( size_t  nr,
EdgeInputIterator  begin,
EdgeInputIterator  end 
) [inline]

Constructs GraphAL from a range of edges.

Template Parameters:
EdgeInputIterator Iterator that iterates over instances of GraphAL::Edge.
Parameters:
nr The number of nodes.
begin Points to the first edge.
end Points just beyond the last edge.

Member Function Documentation

const Neighbor& dai::GraphAL::nb ( size_t  n1,
size_t  _n2 
) const [inline]

Returns constant reference to the _n2 'th neighbor of node n1.

Neighbor& dai::GraphAL::nb ( size_t  n1,
size_t  _n2 
) [inline]

Returns reference to the _n2 'th neighbor of node n1.

const Neighbors& dai::GraphAL::nb ( size_t  n  )  const [inline]

Returns constant reference to all neighbors of node n.

Neighbors& dai::GraphAL::nb ( size_t  n  )  [inline]

Returns reference to all neighbors of node n.

template<typename EdgeInputIterator>
void dai::GraphAL::construct ( size_t  nr,
EdgeInputIterator  begin,
EdgeInputIterator  end 
) [inline]

(Re)constructs GraphAL from a range of edges.

Template Parameters:
EdgeInputIterator Iterator that iterates over instances of GraphAL::Edge.
Parameters:
nr The number of nodes.
begin Points to the first edge.
end Points just beyond the last edge.

size_t dai::GraphAL::addNode (  )  [inline]

Adds a node without neighbors and returns the index of the added node.

template<typename NodeInputIterator>
size_t dai::GraphAL::addNode ( NodeInputIterator  begin,
NodeInputIterator  end,
size_t  sizeHint = 0 
) [inline]

Adds a node, with neighbors specified by a range of nodes.

Template Parameters:
NodeInputIterator Iterator that iterates over instances of size_t.
Parameters:
begin Points to the first index of the nodes that should become neighbors of the added node.
end Points just beyond the last index of the nodes that should become neighbors of the added node.
sizeHint For improved efficiency, the size of the range may be specified by sizeHint.
Returns:
Index of the added node.

void dai::GraphAL::addEdge ( size_t  n1,
size_t  n2,
bool  check = true 
)

Adds an edge between node n1 and node n2.

If check == true, only adds the edge if it does not exist already.

void dai::GraphAL::eraseNode ( size_t  n  ) 

Removes node n and all incident edges; indices of other nodes are changed accordingly.

void dai::GraphAL::eraseEdge ( size_t  n1,
size_t  n2 
)

Removes edge between node n1 and node n2.

size_t dai::GraphAL::nrNodes (  )  const [inline]

Returns number of nodes.

size_t dai::GraphAL::nrEdges (  )  const [inline]

Calculates the number of edges, time complexity: O(nrNodes()).

bool dai::GraphAL::isConnected (  )  const

Returns true if the graph is connected.

bool dai::GraphAL::isTree (  )  const

Returns true if the graph is a tree, i.e., if it is singly connected and connected.

void dai::GraphAL::checkConsistency (  )  const

Checks internal consistency.

void dai::GraphAL::printDot ( std::ostream &  os  )  const

Writes this GraphAL to an output stream in GraphALViz .dot syntax.

Member Data Documentation

std::vector<Neighbors> dai::GraphAL::_nb [private]

Contains for each node a vector of its neighbors.

The documentation for this class was generated from the following files:
Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/example_8cpp-example.html0000644000263000017630000005303611334764772020117 0ustar jorismkyb libDAI: example.cpp

example.cpp

This example illustrates how to read a factor graph from a file and how to run several inference algorithms (junction tree, loopy belief propagation, and the max-product algorithm) on it.

/*  This file is part of libDAI - http://www.libdai.org/
 *
 *  libDAI is licensed under the terms of the GNU General Public License version
 *  2, or (at your option) any later version. libDAI is distributed without any
 *  warranty. See the file COPYING for more details.
 *
 *  Copyright (C) 2006-2009  Joris Mooij  [joris dot mooij at libdai dot org]
 *  Copyright (C) 2006-2007  Radboud University Nijmegen, The Netherlands
 */


#include <iostream>
#include <dai/alldai.h>  // Include main libDAI header file


using namespace dai;
using namespace std;


int main( int argc, char *argv[] ) {
    if ( argc != 2 ) {
        cout << "Usage: " << argv[0] << " <filename.fg>" << endl << endl;
        cout << "Reads factor graph <filename.fg> and runs" << endl;
        cout << "Belief Propagation and JunctionTree on it." << endl << endl;
        return 1;
    } else {
        // Read FactorGraph from the file specified by the first command line argument
        FactorGraph fg;
        fg.ReadFromFile(argv[1]);

        // Set some constants
        size_t maxiter = 10000;
        Real   tol = 1e-9;
        size_t verb = 1;

        // Store the constants in a PropertySet object
        PropertySet opts;
        opts.Set("maxiter",maxiter);  // Maximum number of iterations
        opts.Set("tol",tol);          // Tolerance for convergence
        opts.Set("verbose",verb);     // Verbosity (amount of output generated)

        // Construct a JTree (junction tree) object from the FactorGraph fg
        // using the parameters specified by opts and an additional property
        // that specifies the type of updates the JTree algorithm should perform
        JTree jt( fg, opts("updates",string("HUGIN")) );
        // Initialize junction tree algorithm
        jt.init();
        // Run junction tree algorithm
        jt.run();

        // Construct another JTree (junction tree) object that is used to calculate
        // the joint configuration of variables that has maximum probability (MAP state)
        JTree jtmap( fg, opts("updates",string("HUGIN"))("inference",string("MAXPROD")) );
        // Initialize junction tree algorithm
        jtmap.init();
        // Run junction tree algorithm
        jtmap.run();
        // Calculate joint state of all variables that has maximum probability
        vector<size_t> jtmapstate = jtmap.findMaximum();

        // Construct a BP (belief propagation) object from the FactorGraph fg
        // using the parameters specified by opts and two additional properties,
        // specifying the type of updates the BP algorithm should perform and
        // whether they should be done in the real or in the logdomain
        BP bp(fg, opts("updates",string("SEQFIX"))("logdomain",false));
        // Initialize belief propagation algorithm
        bp.init();
        // Run belief propagation algorithm
        bp.run();

        // Construct a BP (belief propagation) object from the FactorGraph fg
        // using the parameters specified by opts and two additional properties,
        // specifying the type of updates the BP algorithm should perform and
        // whether they should be done in the real or in the logdomain
        //
        // Note that inference is set to MAXPROD, which means that the object
        // will perform the max-product algorithm instead of the sum-product algorithm
        BP mp(fg, opts("updates",string("SEQFIX"))("logdomain",false)("inference",string("MAXPROD")));
        // Initialize max-product algorithm
        mp.init();
        // Run max-product algorithm
        mp.run();
        // Calculate joint state of all variables that has maximum probability
        // based on the max-product result
        vector<size_t> mpstate = mp.findMaximum();

        // Report variable marginals for fg, calculated by the junction tree algorithm
        cout << "Exact variable marginals:" << endl;
        for( size_t i = 0; i < fg.nrVars(); i++ ) // iterate over all variables in fg
            cout << jt.belief(fg.var(i)) << endl; // display the "belief" of jt for that variable

        // Report variable marginals for fg, calculated by the belief propagation algorithm
        cout << "Approximate (loopy belief propagation) variable marginals:" << endl;
        for( size_t i = 0; i < fg.nrVars(); i++ ) // iterate over all variables in fg
            cout << bp.belief(fg.var(i)) << endl; // display the belief of bp for that variable

        // Report factor marginals for fg, calculated by the junction tree algorithm
        cout << "Exact factor marginals:" << endl;
        for( size_t I = 0; I < fg.nrFactors(); I++ ) // iterate over all factors in fg
            cout << jt.belief(fg.factor(I).vars()) << endl;  // display the "belief" of jt for the variables in that factor

        // Report factor marginals for fg, calculated by the belief propagation algorithm
        cout << "Approximate (loopy belief propagation) factor marginals:" << endl;
        for( size_t I = 0; I < fg.nrFactors(); I++ ) // iterate over all factors in fg
            cout << bp.belief(fg.factor(I).vars()) << endl; // display the belief of bp for the variables in that factor

        // Report log partition sum (normalizing constant) of fg, calculated by the junction tree algorithm
        cout << "Exact log partition sum: " << jt.logZ() << endl;

        // Report log partition sum of fg, approximated by the belief propagation algorithm
        cout << "Approximate (loopy belief propagation) log partition sum: " << bp.logZ() << endl;

        // Report exact MAP variable marginals
        cout << "Exact MAP variable marginals:" << endl;
        for( size_t i = 0; i < fg.nrVars(); i++ )
            cout << jtmap.belief(fg.var(i)) << endl;

        // Report max-product variable marginals
        cout << "Approximate (max-product) MAP variable marginals:" << endl;
        for( size_t i = 0; i < fg.nrVars(); i++ )
            cout << mp.belief(fg.var(i)) << endl;

        // Report exact MAP factor marginals
        cout << "Exact MAP factor marginals:" << endl;
        for( size_t I = 0; I < fg.nrFactors(); I++ )
            cout << jtmap.belief(fg.factor(I).vars()) << "=" << jtmap.beliefF(I) << endl;

        // Report max-product factor marginals
        cout << "Approximate (max-product) MAP factor marginals:" << endl;
        for( size_t I = 0; I < fg.nrFactors(); I++ )
            cout << mp.belief(fg.factor(I).vars()) << "=" << mp.beliefF(I) << endl;

        // Report exact MAP joint state
        cout << "Exact MAP state:" << endl;
        for( size_t i = 0; i < jtmapstate.size(); i++ )
            cout << fg.var(i) << ": " << jtmapstate[i] << endl;

        // Report max-product MAP joint state
        cout << "Approximate (max-product) MAP state:" << endl;
        for( size_t i = 0; i < mpstate.size(); i++ )
            cout << fg.var(i) << ": " << mpstate[i] << endl;
    }

    return 0;
}
Generated on Thu Feb 11 12:25:58 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/var_8h.html0000644000263000017630000000450711334764772015267 0ustar jorismkyb libDAI: include/dai/var.h File Reference

include/dai/var.h File Reference

Defines class Var, which represents a discrete random variable. More...

#include <iostream>
#include <dai/exceptions.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::Var
 Represents a discrete random variable. More...

Detailed Description

Defines class Var, which represents a discrete random variable.

Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/tabs.css0000644000263000017630000000334211334764772014651 0ustar jorismkyb/* tabs styles, based on http://www.alistapart.com/articles/slidingdoors */ DIV.tabs { float : left; width : 100%; background : url("tab_b.gif") repeat-x bottom; margin-bottom : 4px; } DIV.tabs UL { margin : 0px; padding-left : 10px; list-style : none; } DIV.tabs LI, DIV.tabs FORM { display : inline; margin : 0px; padding : 0px; } DIV.tabs FORM { float : right; } DIV.tabs A { float : left; background : url("tab_r.gif") no-repeat right top; border-bottom : 1px solid #84B0C7; font-size : x-small; font-weight : bold; text-decoration : none; } DIV.tabs A:hover { background-position: 100% -150px; } DIV.tabs A:link, DIV.tabs A:visited, DIV.tabs A:active, DIV.tabs A:hover { color: #1A419D; } DIV.tabs SPAN { float : left; display : block; background : url("tab_l.gif") no-repeat left top; padding : 5px 9px; white-space : nowrap; } DIV.tabs INPUT { float : right; display : inline; font-size : 1em; } DIV.tabs TD { font-size : x-small; font-weight : bold; text-decoration : none; } /* Commented Backslash Hack hides rule from IE5-Mac \*/ DIV.tabs SPAN {float : none;} /* End IE5-Mac hack */ DIV.tabs A:hover SPAN { background-position: 0% -150px; } DIV.tabs LI.current A { background-position: 100% -150px; border-width : 0px; } DIV.tabs LI.current SPAN { background-position: 0% -150px; padding-bottom : 6px; } DIV.navpath { background : none; border : none; border-bottom : 1px solid #84B0C7; } libDAI-0.2.4/doc/html/classdai_1_1HAK.html0000644000263000017630000014436311334764772016654 0ustar jorismkyb libDAI: dai::HAK Class Reference

dai::HAK Class Reference

Approximate inference algorithm: implementation of single-loop ("Generalized Belief Propagation") and double-loop algorithms by Heskes, Albers and Kappen [HAK03]. More...

#include <dai/hak.h>

Inheritance diagram for dai::HAK:

dai::DAIAlg< GRM > dai::InfAlg

List of all members.

Public Member Functions

Constructors/destructors
 HAK ()
 Default constructor.
 HAK (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts.
 HAK (const RegionGraph &rg, const PropertySet &opts)
 Construct from RegionGraph rg and PropertySet opts.
General InfAlg interface
virtual HAK * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
virtual std::string identify () const
 Identifies itself for logging purposes.
virtual Factor belief (const VarSet &vs) const
 Returns the (approximate) marginal probability distribution of a set of variables.
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).
virtual void init ()
 Initializes all data structures of the approximate inference algorithm.
virtual void init (const VarSet &vs)
 Initializes all data structures corresponding to some set of variables.
virtual Real run ()
 Runs the approximate inference algorithm.
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration.
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph).
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm.
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet.
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".
Additional interface specific for HAK
Factor & muab (size_t alpha, size_t _beta)
 Returns reference to message from outer region alpha to its _beta 'th neighboring inner region.
Factor & muba (size_t alpha, size_t _beta)
 Returns reference to message the _beta 'th neighboring inner region of outer region alpha to that outer region.
const Factor & Qa (size_t alpha) const
 Returns belief of outer region alpha.
const Factor & Qb (size_t beta) const
 Returns belief of inner region beta.
Real doGBP ()
 Runs single-loop algorithm (algorithm 1 in [HAK03]).
Real doDoubleLoop ()
 Runs double-loop algorithm (as described in section 4.2 of [HAK03]), which always convergences.

Public Attributes

struct dai::HAK::Properties props

Static Public Attributes

static const char * Name = "HAK"
 Name of this inference algorithm.

Private Member Functions

void construct ()
 Helper function for constructors.
void findLoopClusters (const FactorGraph &fg, std::set< VarSet > &allcl, VarSet newcl, const Var &root, size_t length, VarSet vars)
 Recursive procedure for finding clusters of variables containing loops of length at most length.

Private Attributes

std::vector< Factor > _Qa
 Outer region beliefs.
std::vector< Factor > _Qb
 Inner region beliefs.
std::vector< std::vector
< Factor > > 		_muab
 Messages from outer to inner regions.
std::vector< std::vector
< Factor > > 		_muba
 Messages from inner to outer regions.
Real _maxdiff
 Maximum difference encountered so far.
size_t _iters
 Number of iterations needed.

Classes

struct  Properties
 Parameters for HAK. More...

Detailed Description

Approximate inference algorithm: implementation of single-loop ("Generalized Belief Propagation") and double-loop algorithms by Heskes, Albers and Kappen [HAK03].

Constructor & Destructor Documentation

dai::HAK::HAK (  )  [inline]

Default constructor.

dai::HAK::HAK ( const FactorGraph &  fg,
const PropertySet &  opts 
)

Construct from FactorGraph fg and PropertySet opts.

Parameters:
opts Parameters
See also:
Properties

dai::HAK::HAK ( const RegionGraph &  rg,
const PropertySet &  opts 
)

Construct from RegionGraph rg and PropertySet opts.

Member Function Documentation

virtual HAK* dai::HAK::clone (  )  const [inline, virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Implements dai::InfAlg.

string dai::HAK::identify (  )  const [virtual]

Identifies itself for logging purposes.

Implements dai::InfAlg.

Factor dai::HAK::belief ( const VarSet &  vs  )  const [virtual]

Returns the (approximate) marginal probability distribution of a set of variables.

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported.
BELIEF_NOT_AVAILABLE if the requested belief cannot be calculated with this algorithm.

Implements dai::InfAlg.

vector< Factor > dai::HAK::beliefs (  )  const [virtual]

Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.

Note:
Before this method is called, run() should have been called.

Implements dai::InfAlg.

Real dai::HAK::logZ (  )  const [virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

void dai::HAK::init (  )  [virtual]

Initializes all data structures of the approximate inference algorithm.

Note:
This method should be called at least once before run() is called.

Implements dai::InfAlg.

void dai::HAK::init ( const VarSet &  vs  )  [virtual]

Initializes all data structures corresponding to some set of variables.

This method can be used to do a partial initialization after a part of the factor graph has changed. Instead of initializing all data structures, it only initializes those involving the variables in vs.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

Real dai::HAK::run (  )  [virtual]

Runs the approximate inference algorithm.

Note:
Before run() is called the first time, init() should have been called.

Implements dai::InfAlg.

virtual Real dai::HAK::maxDiff (  )  const [inline, virtual]

Returns maximum difference between single variable beliefs in the last iteration.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

virtual size_t dai::HAK::Iterations (  )  const [inline, virtual]

Returns number of iterations done (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

void dai::HAK::setProperties ( const PropertySet &  opts  )  [virtual]

Set parameters of this inference algorithm.

The parameters are set according to the PropertySet opts. The values can be stored either as std::string or as the type of the corresponding MF::props member.

Implements dai::InfAlg.

PropertySet dai::HAK::getProperties (  )  const [virtual]

Returns parameters of this inference algorithm converted into a PropertySet.

Implements dai::InfAlg.

string dai::HAK::printProperties (  )  const [virtual]

Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Implements dai::InfAlg.

Factor& dai::HAK::muab ( size_t  alpha,
size_t  _beta 
) [inline]

Returns reference to message from outer region alpha to its _beta 'th neighboring inner region.

Factor& dai::HAK::muba ( size_t  alpha,
size_t  _beta 
) [inline]

Returns reference to message the _beta 'th neighboring inner region of outer region alpha to that outer region.

const Factor& dai::HAK::Qa ( size_t  alpha  )  const [inline]

Returns belief of outer region alpha.

const Factor& dai::HAK::Qb ( size_t  beta  )  const [inline]

Returns belief of inner region beta.

Real dai::HAK::doGBP (  ) 

Runs single-loop algorithm (algorithm 1 in [HAK03]).

Real dai::HAK::doDoubleLoop (  ) 

Runs double-loop algorithm (as described in section 4.2 of [HAK03]), which always convergences.

void dai::HAK::construct (  )  [private]

Helper function for constructors.

void dai::HAK::findLoopClusters ( const FactorGraph &  fg,
std::set< VarSet > &  allcl,
VarSet  newcl,
const Var &  root,
size_t  length,
VarSet  vars 
) [private]

Recursive procedure for finding clusters of variables containing loops of length at most length.

Parameters:
fg the factor graph
allcl the clusters found so far
newcl partial candidate cluster
root start (and end) point of the loop
length number of variables that may be added to newcl
vars neighboring variables of newcl
Returns:
allcl all clusters of variables with loops of length at most length passing through root

Member Data Documentation

std::vector<Factor> dai::HAK::_Qa [private]

Outer region beliefs.

std::vector<Factor> dai::HAK::_Qb [private]

Inner region beliefs.

std::vector<std::vector<Factor> > dai::HAK::_muab [private]

Messages from outer to inner regions.

std::vector<std::vector<Factor> > dai::HAK::_muba [private]

Messages from inner to outer regions.

Real dai::HAK::_maxdiff [private]

Maximum difference encountered so far.

size_t dai::HAK::_iters [private]

Number of iterations needed.

const char * dai::HAK::Name = "HAK" [static]

Name of this inference algorithm.

The documentation for this class was generated from the following files:
  • include/dai/hak.h
  • src/hak.cpp
Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1Exception.html0000644000263000017630000003322511334764772020201 0ustar jorismkyb libDAI: dai::Exception Class Reference

dai::Exception Class Reference

Error handling in libDAI is done by throwing an instance of the Exception class. More...

#include <dai/exceptions.h>

List of all members.

Public Types

enum  Code {
  NOT_IMPLEMENTED, ASSERTION_FAILED, IMPOSSIBLE_TYPECAST, OBJECT_NOT_FOUND,
  BELIEF_NOT_AVAILABLE, UNKNOWN_ENUM_VALUE, UNKNOWN_DAI_ALGORITHM, UNKNOWN_PARAMETER_ESTIMATION_METHOD,
  UNKNOWN_PROPERTY_TYPE, UNKNOWN_PROPERTY, MALFORMED_PROPERTY, NOT_ALL_PROPERTIES_SPECIFIED,
  INVALID_ALIAS, CANNOT_READ_FILE, CANNOT_WRITE_FILE, INVALID_FACTORGRAPH_FILE,
  INVALID_EVIDENCE_FILE, INVALID_EMALG_FILE, NOT_NORMALIZABLE, MULTIPLE_UNDO,
  FACTORGRAPH_NOT_CONNECTED, INTERNAL_ERROR, RUNTIME_ERROR, NUM_ERRORS
}
 Enumeration of exceptions used in libDAI. More...

Public Member Functions

 Exception (Code _code, const std::string &msg="", const std::string &detailedMsg="")
 Constructor.
Code code () const
 Returns error code of this exception.
const std::string & message (const Code c) const
 Returns error message corresponding to an error code.

Private Attributes

Code errorcode
 Contains the error code of this exception.

Static Private Attributes

static std::string ErrorStrings [NUM_ERRORS]
 Error messages corresponding to the exceptions enumerated above.

Detailed Description

Error handling in libDAI is done by throwing an instance of the Exception class.

The Exception class inherits from std::runtime_error. It defines several types of exceptions and corresponding error messages. The recommended way to throw an instance of the Exception class is by using the DAI_THROW or DAI_THROWE macros.

Member Enumeration Documentation

enum dai::Exception::Code

Enumeration of exceptions used in libDAI.

Constructor & Destructor Documentation

dai::Exception::Exception ( Code  _code,
const std::string &  msg = "",
const std::string &  detailedMsg = "" 
) [inline]

Constructor.

Member Function Documentation

Code dai::Exception::code (  )  const [inline]

Returns error code of this exception.

const std::string& dai::Exception::message ( const Code  c  )  const [inline]

Returns error message corresponding to an error code.

Member Data Documentation

Code dai::Exception::errorcode [private]

Contains the error code of this exception.

std::string dai::Exception::ErrorStrings [static, private]

Initial value:

 {
        "Feature not implemented",
        "Assertion failed",
        "Impossible typecast",
        "Requested object not found",
        "Requested belief not available",
        "Unknown ENUM value",
        "Unknown DAI algorithm",
        "Unrecognized parameter estimation method",
        "Unknown Property type",
        "Unknown Property",
        "Malformed Property",
        "Not all mandatory Properties specified",
        "Invalid alias",
        "Cannot read file",
        "Cannot write file",
        "Invalid FactorGraph file",
        "Invalid Evidence file",
        "Invalid Expectation-Maximization file",
        "Quantity not normalizable",
        "Multiple undo levels unsupported",
        "FactorGraph is not connected",
        "Internal error",
        "Runtime error"
    }
Error messages corresponding to the exceptions enumerated above.

The documentation for this class was generated from the following files:
Generated on Thu Feb 11 12:26:04 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/exactinf_8h.html0000644000263000017630000000633211334764772016276 0ustar jorismkyb libDAI: include/dai/exactinf.h File Reference

include/dai/exactinf.h File Reference

Defines ExactInf class, which can be used for exact inference on small factor graphs. More...

#include <dai/daialg.h>
#include <dai/properties.h>
#include <dai/factorgraph.h>
#include <dai/enum.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::ExactInf
 Exact inference algorithm using brute force enumeration (mainly useful for testing purposes). More...
struct  dai::ExactInf::Properties
 Parameters for ExactInf. More...

Detailed Description

Defines ExactInf class, which can be used for exact inference on small factor graphs.

Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_38.png0000644000263000017630000000046611334764772015175 0ustar jorismkybPNG  IHDR'g{0PLTEppp```PPP@@@000 4tRNS@fIDATc` 3T @RX\ÁHq (_ 20R `< pA+ " b`? !ULq7B,Wg[ꕋ/0601[>0 @>b`*b0g@V !H*"YBf RqIENDB`libDAI-0.2.4/doc/html/form_105.png0000644000263000017630000000235711334764772015251 0ustar jorismkybPNG  IHDR$o80PLTEppp```PPP@@@000 4tRNS@fmIDATX]hU33ُ 4ZL,$&jFmY# N * V $j}rǨTjB>р|2ɍ-"ܝMfw2YXD̽s{{f]otQt廇՟Wtw[DQяm? S@j &%⍹5 \ǿаdvvTt036mpMRd:0S#)"pحZ L,/ݴ(zB7Գ~0J!m&&\J5.rA'kf)XfUQwb;څILҬ]8uHZ HW~ #!2\KB"F"6M ;y A83[SοȪ.=t&:5޶ee !y`~el}#X OCP #I3XU(i {"yP՚a-'tE-4u/:Z h4-0&}/4ȧi]($uB&2R![)iG'AeN]Y&aiaCx`q{'&[ $ N"RgV-iL4L0d1`i_\SɈuYZߘT{ΉIENDB`libDAI-0.2.4/doc/html/form_15.png0000644000263000017630000000043711334764772015166 0ustar jorismkybPNG  IHDRֹ0PLTEppp```PPP@@@000 4tRNS@fIDATc` ԁ8Y`N$>[e̬D B S0V20000\ 3;b`g`]` LyRX* / bV#nW``;v os)Oi .iP25IENDB`libDAI-0.2.4/doc/html/form_77.png0000644000263000017630000000105411334764772015172 0ustar jorismkybPNG  IHDR0PLTEppp```PPP@@@000 4tRNS@fIDAT8͒K@_~]R4"8jt&fD(N Z݂uNQp tpꠡC;K]~Gt w{޻;d&?SbBOTl%(-7b?_ _0N :)$ȹ31#__",=t$]kՐA~Kg֚2HX libDAI: Member List

dai::fo_log< T > Member List

This is the complete list of members for dai::fo_log< T >, including all inherited members.

operator()(const T &x) const dai::fo_log< T > [inline]

Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1RegionGraph.html0000644000263000017630000014050211334764772020445 0ustar jorismkyb libDAI: dai::RegionGraph Class Reference

dai::RegionGraph Class Reference

A RegionGraph combines a bipartite graph consisting of outer regions (type FRegion) and inner regions (type Region) with a FactorGraph. More...

#include <dai/regiongraph.h>

Inheritance diagram for dai::RegionGraph:

dai::FactorGraph dai::DAIAlg< dai::RegionGraph >

List of all members.

Public Member Functions

Constructors and destructors
 RegionGraph ()
 Default constructor.
 RegionGraph (const FactorGraph &fg)
 Partially constructs a region graph from a factor graph.
 RegionGraph (const FactorGraph &fg, const std::vector< VarSet > &ors, const std::vector< Region > &irs, const std::vector< std::pair< size_t, size_t > > &edges)
 Constructs a region graph from a factor graph, a vector of outer regions, a vector of inner regions and a vector of edges.
 RegionGraph (const FactorGraph &fg, const std::vector< Region > &ors, const std::vector< Region > &irs, const std::vector< std::pair< size_t, size_t > > &edges)
 Constructs a region graph from a factor graph, a vector of outer regions, a vector of inner regions and a vector of edges.
 RegionGraph (const FactorGraph &fg, const std::vector< VarSet > &cl)
 Constructs a region graph from a factor graph and a vector of outer clusters (CVM style).
virtual RegionGraph * clone () const
 Clone *this (virtual copy constructor).
Queries
size_t nrORs () const
 Returns number of outer regions.
size_t nrIRs () const
 Returns number of inner regions.
const FRegion & OR (size_t alpha) const
 Returns constant reference to outer region alpha.
FRegion & OR (size_t alpha)
 Returns reference to outer region alpha.
const Region & IR (size_t beta) const
 Returns constant reference to inner region beta.
Region & IR (size_t beta)
 Returns reference to inner region beta.
const Neighbors & nbOR (size_t alpha) const
 Returns constant reference to the neighbors of outer region alpha.
const Neighbors & nbIR (size_t beta) const
 Returns constant reference to the neighbors of inner region beta.
bool checkCountingNumbers () const
 Check whether the counting numbers are valid.
Operations
virtual void setFactor (size_t I, const Factor &newFactor, bool backup=false)
 Set the content of the I 'th factor and make a backup of its old content if backup == true.
virtual void setFactors (const std::map< size_t, Factor > &facs, bool backup=false)
 Set the contents of all factors as specified by facs and make a backup of the old contents if backup == true.
void RecomputeORs ()
 Recompute all outer regions.
void RecomputeORs (const VarSet &vs)
 Recompute all outer regions involving the variables in vs.
void RecomputeOR (size_t I)
 Recompute all outer regions involving factor I.
void calcCountingNumbers ()
 Calculates counting numbers of inner regions based upon counting numbers of outer regions.

Public Attributes

BipartiteGraph G
 Stores the neighborhood structure.
std::vector< FRegion > ORs
 The outer regions (corresponding to nodes of type 1).
std::vector< Region > IRs
 The inner regions (corresponding to nodes of type 2).
std::vector< size_t > fac2OR
 Stores for each factor index the index of the outer region it belongs to.

Protected Member Functions

void construct (const FactorGraph &fg, const std::vector< VarSet > &ors, const std::vector< Region > &irs, const std::vector< std::pair< size_t, size_t > > &edges)
 Helper function for constructors.
void constructCVM (const FactorGraph &fg, const std::vector< VarSet > &cl)
 Helper function for constructors (CVM style).

Friends

Input/output
std::ostream & operator<< (std::ostream &os, const RegionGraph &rg)
 Writes a RegionGraph to an output stream.

Detailed Description

A RegionGraph combines a bipartite graph consisting of outer regions (type FRegion) and inner regions (type Region) with a FactorGraph.

A RegionGraph inherits from a FactorGraph and adds additional structure in the form of a "region graph". Our definition of region graph is inspired by [HAK03], which is less general than the definition given in [YFW05].

The extra structure described by a RegionGraph over that described by a FactorGraph is:

  • a set of outer regions (indexed by $\alpha$), where each outer region consists of
    • a factor defined on a subset of variables
    • a counting number
  • a set of inner regions (indexed by $\beta$), where each inner region consists of
    • a subset of variables
    • a counting number
  • edges between inner and outer regions

Each factor in the factor graph belongs to an outer region; normally, the factor contents of an outer region would be the product of all the factors that belong to that region.

Constructor & Destructor Documentation

dai::RegionGraph::RegionGraph (  )  [inline]

Default constructor.

dai::RegionGraph::RegionGraph ( const FactorGraph &  fg  )  [inline]

Partially constructs a region graph from a factor graph.

dai::RegionGraph::RegionGraph ( const FactorGraph &  fg,
const std::vector< VarSet > &  ors,
const std::vector< Region > &  irs,
const std::vector< std::pair< size_t, size_t > > &  edges 
) [inline]

Constructs a region graph from a factor graph, a vector of outer regions, a vector of inner regions and a vector of edges.

The counting numbers for the outer regions are set to 1.

dai::RegionGraph::RegionGraph ( const FactorGraph &  fg,
const std::vector< Region > &  ors,
const std::vector< Region > &  irs,
const std::vector< std::pair< size_t, size_t > > &  edges 
)

Constructs a region graph from a factor graph, a vector of outer regions, a vector of inner regions and a vector of edges.

Note:
The counting numbers for the outer regions need to be 1.
Deprecated:
Please use dai::RegionGraph::RegionGraph( const FactorGraph &, const std::vector<VarSet> &, const std::vector<Region> &, const std::vector<std::pair<size_t,size_t> > & ) instead.

dai::RegionGraph::RegionGraph ( const FactorGraph &  fg,
const std::vector< VarSet > &  cl 
) [inline]

Constructs a region graph from a factor graph and a vector of outer clusters (CVM style).

The region graph is constructed as in the Cluster Variation Method.

The outer regions have as variable subsets the clusters specified in cl. Each factor in the factor graph fg is assigned to one of the outer regions. Each outer region gets counting number 1.

The inner regions are (repeated) intersections of outer regions. An inner and an outer region are connected if the variables in the inner region form a subset of the variables in the outer region. The counting numbers for the inner regions are calculated by calcCountingNumbers() and satisfy the Moebius formula.

Member Function Documentation

virtual RegionGraph* dai::RegionGraph::clone (  )  const [inline, virtual]

Clone *this (virtual copy constructor).

Reimplemented from dai::FactorGraph.

size_t dai::RegionGraph::nrORs (  )  const [inline]

Returns number of outer regions.

size_t dai::RegionGraph::nrIRs (  )  const [inline]

Returns number of inner regions.

const FRegion& dai::RegionGraph::OR ( size_t  alpha  )  const [inline]

Returns constant reference to outer region alpha.

FRegion& dai::RegionGraph::OR ( size_t  alpha  )  [inline]

Returns reference to outer region alpha.

const Region& dai::RegionGraph::IR ( size_t  beta  )  const [inline]

Returns constant reference to inner region beta.

Region& dai::RegionGraph::IR ( size_t  beta  )  [inline]

Returns reference to inner region beta.

const Neighbors& dai::RegionGraph::nbOR ( size_t  alpha  )  const [inline]

Returns constant reference to the neighbors of outer region alpha.

const Neighbors& dai::RegionGraph::nbIR ( size_t  beta  )  const [inline]

Returns constant reference to the neighbors of inner region beta.

bool dai::RegionGraph::checkCountingNumbers (  )  const

Check whether the counting numbers are valid.

Counting numbers are said to be (variable) valid if for each variable $x$,

\[\sum_{\alpha \ni x} c_\alpha + \sum_{\beta \ni x} c_\beta = 1\]

or in words, if the sum of the counting numbers of the regions that contain the variable equals one.

virtual void dai::RegionGraph::setFactor ( size_t  I,
const Factor &  newFactor,
bool  backup = false 
) [inline, virtual]

Set the content of the I 'th factor and make a backup of its old content if backup == true.

Reimplemented from dai::FactorGraph.

virtual void dai::RegionGraph::setFactors ( const std::map< size_t, Factor > &  facs,
bool  backup = false 
) [inline, virtual]

Set the contents of all factors as specified by facs and make a backup of the old contents if backup == true.

Reimplemented from dai::FactorGraph.

void dai::RegionGraph::RecomputeORs (  ) 

Recompute all outer regions.

The factor contents of each outer region is set to the product of the factors belonging to that region.

void dai::RegionGraph::RecomputeORs ( const VarSet &  vs  ) 

Recompute all outer regions involving the variables in vs.

The factor contents of each outer region involving at least one of the variables in vs is set to the product of the factors belonging to that region.

void dai::RegionGraph::RecomputeOR ( size_t  I  ) 

Recompute all outer regions involving factor I.

The factor contents of each outer region involving the I 'th factor is set to the product of the factors belonging to that region.

void dai::RegionGraph::calcCountingNumbers (  ) 

Calculates counting numbers of inner regions based upon counting numbers of outer regions.

The counting numbers of the inner regions are set using the Moebius inversion formula:

\[ c_\beta := 1 - \sum_{\gamma \in \mathrm{an}(\beta)} c_\gamma \]

where $\mathrm{an}(\beta)$ are the ancestors of inner region $\beta$ according to the partial ordering induced by the subset relation (i.e., a region is a child of another region if its variables are a subset of the variables of its parent region).

void dai::RegionGraph::construct ( const FactorGraph &  fg,
const std::vector< VarSet > &  ors,
const std::vector< Region > &  irs,
const std::vector< std::pair< size_t, size_t > > &  edges 
) [protected]

Helper function for constructors.

void dai::RegionGraph::constructCVM ( const FactorGraph &  fg,
const std::vector< VarSet > &  cl 
) [protected]

Helper function for constructors (CVM style).

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os,
const RegionGraph &  rg 
) [friend]

Writes a RegionGraph to an output stream.

Member Data Documentation

BipartiteGraph dai::RegionGraph::G

Stores the neighborhood structure.

Reimplemented from dai::FactorGraph.

std::vector<FRegion> dai::RegionGraph::ORs

The outer regions (corresponding to nodes of type 1).

std::vector<Region> dai::RegionGraph::IRs

The inner regions (corresponding to nodes of type 2).

std::vector<size_t> dai::RegionGraph::fac2OR

Stores for each factor index the index of the outer region it belongs to.

The documentation for this class was generated from the following files:
Generated on Thu Feb 11 12:26:07 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_0x6f.html0000644000263000017630000003604511334764772016755 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- o -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_vars_0x63.html0000644000263000017630000001146611334764772017725 0ustar jorismkyb libDAI: Class Members - Variables
 

- c -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1CBP_1_1Properties.html0000644000263000017630000007223011334764772021602 0ustar jorismkyb libDAI: dai::CBP::Properties Struct Reference

dai::CBP::Properties Struct Reference

Parameters for CBP. More...

#include <dai/cbp.h>

List of all members.

Public Types

typedef BP::Properties::UpdateType UpdateType
 Enumeration of possible update schedules.

Public Member Functions

 DAI_ENUM (RecurseType, REC_FIXED, REC_LOGZ, REC_BDIFF)
 Enumeration of possible methods for deciding when to stop recursing.
 DAI_ENUM (ChooseMethodType, CHOOSE_RANDOM, CHOOSE_MAXENT, CHOOSE_BBP, CHOOSE_BP_L1, CHOOSE_BP_CFN)
 Enumeration of possible heuristics for choosing clamping variable.
 DAI_ENUM (ClampType, CLAMP_VAR, CLAMP_FACTOR)
 Enumeration of possible clampings: variables or factors.
void set (const PropertySet &opts)
 Set members from PropertySet.
PropertySet get () const
 Get members into PropertySet.
std::string toString () const
 Convert to a string which can be parsed as a PropertySet.

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr).
Real tol
 Tolerance for BP convergence test.
UpdateType updates
 Update style for BP.
size_t maxiter
 Maximum number of iterations for BP.
Real rec_tol
 Tolerance used for controlling recursion depth (recurse is REC_LOGZ or REC_BDIFF).
size_t max_levels
 Maximum number of levels of recursion (recurse is REC_FIXED).
Real min_max_adj
 If choose==CHOOSE_BBP and maximum adjoint is less than this value, don't recurse.
ChooseMethodType choose
 Heuristic for choosing clamping variable.
RecurseType recursion
 Method for deciding when to stop recursing.
ClampType clamp
 Whether to clamp variables or factors.
PropertySet bbp_props
 Properties to pass to BBP.
BBPCostFunction bbp_cfn
 Cost function to use for BBP.
size_t rand_seed
 Random seed.
std::string clamp_outfile
 If non-empty, write clamping choices to this file.

Detailed Description

Parameters for CBP.

Member Typedef Documentation

typedef BP::Properties::UpdateType dai::CBP::Properties::UpdateType

Enumeration of possible update schedules.

Member Function Documentation

dai::CBP::Properties::DAI_ENUM ( RecurseType  ,
REC_FIXED  ,
REC_LOGZ  ,
REC_BDIFF   
)

Enumeration of possible methods for deciding when to stop recursing.

dai::CBP::Properties::DAI_ENUM ( ChooseMethodType  ,
CHOOSE_RANDOM  ,
CHOOSE_MAXENT  ,
CHOOSE_BBP  ,
CHOOSE_BP_L1  ,
CHOOSE_BP_CFN   
)

Enumeration of possible heuristics for choosing clamping variable.

dai::CBP::Properties::DAI_ENUM ( ClampType  ,
CLAMP_VAR  ,
CLAMP_FACTOR   
)

Enumeration of possible clampings: variables or factors.

void dai::CBP::Properties::set ( const PropertySet &  opts  ) 

Set members from PropertySet.

Exceptions:
UNKNOWN_PROPERTY if a Property key is not recognized
NOT_ALL_PROPERTIES_SPECIFIED if an expected Property is missing

PropertySet dai::CBP::Properties::get (  )  const

Get members into PropertySet.

string dai::CBP::Properties::toString (  )  const

Convert to a string which can be parsed as a PropertySet.

Member Data Documentation

size_t dai::CBP::Properties::verbose

Verbosity (amount of output sent to stderr).

Real dai::CBP::Properties::tol

Tolerance for BP convergence test.

UpdateType dai::CBP::Properties::updates

Update style for BP.

size_t dai::CBP::Properties::maxiter

Maximum number of iterations for BP.

Real dai::CBP::Properties::rec_tol

Tolerance used for controlling recursion depth (recurse is REC_LOGZ or REC_BDIFF).

size_t dai::CBP::Properties::max_levels

Maximum number of levels of recursion (recurse is REC_FIXED).

Real dai::CBP::Properties::min_max_adj

If choose==CHOOSE_BBP and maximum adjoint is less than this value, don't recurse.

ChooseMethodType dai::CBP::Properties::choose

Heuristic for choosing clamping variable.

RecurseType dai::CBP::Properties::recursion

Method for deciding when to stop recursing.

ClampType dai::CBP::Properties::clamp

Whether to clamp variables or factors.

PropertySet dai::CBP::Properties::bbp_props

Properties to pass to BBP.

BBPCostFunction dai::CBP::Properties::bbp_cfn

Cost function to use for BBP.

size_t dai::CBP::Properties::rand_seed

Random seed.

std::string dai::CBP::Properties::clamp_outfile

If non-empty, write clamping choices to this file.

The documentation for this struct was generated from the following files:
  • include/dai/cbp.h
  • src/cbp.cpp
Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/clustergraph_8h.html0000644000263000017630000001407611334764772017204 0ustar jorismkyb libDAI: include/dai/clustergraph.h File Reference

include/dai/clustergraph.h File Reference

Defines class ClusterGraph, which is used by JTree, TreeEP and HAK. More...

#include <set>
#include <vector>
#include <dai/varset.h>
#include <dai/bipgraph.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::ClusterGraph
 A ClusterGraph is a hypergraph with variables as nodes, and "clusters" (sets of variables) as hyperedges. More...
class  dai::sequentialVariableElimination
 Helper object for dai::ClusterGraph::VarElim(). More...
class  dai::greedyVariableElimination
 Helper object for dai::ClusterGraph::VarElim(). More...

Functions

size_t dai::eliminationCost_MinNeighbors (const ClusterGraph &cl, size_t i)
 Calculates cost of eliminating the i 'th variable from cluster graph cl according to the "MinNeighbors" criterion.
size_t dai::eliminationCost_MinWeight (const ClusterGraph &cl, size_t i)
 Calculates cost of eliminating the i 'th variable from cluster graph cl according to the "MinWeight" criterion.
size_t dai::eliminationCost_MinFill (const ClusterGraph &cl, size_t i)
 Calculates cost of eliminating the i 'th variable from cluster graph cl according to the "MinFill" criterion.
size_t dai::eliminationCost_WeightedMinFill (const ClusterGraph &cl, size_t i)
 Calculates cost of eliminating the i 'th variable from cluster graph cl according to the "WeightedMinFill" criterion.

Detailed Description

Defines class ClusterGraph, which is used by JTree, TreeEP and HAK.

Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/gibbs_8h.html0000644000263000017630000000573111334764772015565 0ustar jorismkyb libDAI: include/dai/gibbs.h File Reference

include/dai/gibbs.h File Reference

Defines class Gibbs, which implements Gibbs sampling. More...

#include <dai/daialg.h>
#include <dai/factorgraph.h>
#include <dai/properties.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::Gibbs
 Approximate inference algorithm "Gibbs sampling". More...
struct  dai::Gibbs::Properties
 Parameters for Gibbs. More...

Detailed Description

Defines class Gibbs, which implements Gibbs sampling.

Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_79.png0000644000263000017630000000210611334764772015173 0ustar jorismkybPNG  IHDR"{0PLTEppp```PPP@@@000 4tRNS@fIDATXWMGgg,^c&k Yb:DdUDC@oBCp!$s1Ê+DUMړELu{z}6h"(}Mu+)hvdqoL"; Ep.N֤Jg%p<*ro_ }uG>I0_ƪȵ˿z ;Bc(WHס.X=Ml>% 4bW?821D_[Jy\ts[]hmE[Åc:$@2ط?#oԚkт٢zBErt `Dĺ4~HmXP7A kVOWyiMCoKr_,ƱAݣ 5bGzHz5\km kA tnlo$;òz#,ef- ˰}%S:X'QfLJ"y,{3aЭ &Nn?-EYX5xs~΂MȈ>Mr0\{TKک#XQ슉=tu`aH|82< *CdSn\X0BʑrĴ|RLKՋy >g)VeA2J 9t2)-^яbk40خvLm^jZ =i,ZQDXp$uAtvD"QM,sOzj l+⅜՝p8ѧ,7,K!3JZ-y/Jn\z^Z9u)1.߰wx:~u#x{Ai[l](!E46IENDB`libDAI-0.2.4/doc/html/index_8h.html0000644000263000017630000000767311334764772015615 0ustar jorismkyb libDAI: include/dai/index.h File Reference

include/dai/index.h File Reference

Defines the IndexFor, multifor, Permute and State classes, which all deal with indexing multi-dimensional arrays. More...

#include <vector>
#include <algorithm>
#include <map>
#include <dai/varset.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::IndexFor
 Tool for looping over the states of several variables. More...
class  dai::Permute
 Tool for calculating permutations of linear indices of multi-dimensional arrays. More...
class  dai::multifor
 multifor makes it easy to perform a dynamic number of nested for loops. More...
class  dai::State
 Makes it easy to iterate over all possible joint states of variables within a VarSet. More...

Detailed Description

Defines the IndexFor, multifor, Permute and State classes, which all deal with indexing multi-dimensional arrays.

Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/prob_8h-source.html0000644000263000017630000030561211334764772016740 0ustar jorismkyb libDAI: include/dai/prob.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1FBP.png0000644000263000017630000000115211334764772016464 0ustar jorismkybPNG  IHDRPLTE`{tRNS@fIDAThAr0 PttB]G(l<\^ *88f6 whTs "^ﷀ1*,LtQ`"RLC8%B `\g %=X}8¢/Ȁ:TALy1,,M`),?-^`"`d{La MN9)Fpxf PPGᮿdQGC% TuI}uljˁxn|8paꛡe`L7V`(k=0qgFYgkg@F]&<~?\ONppx3si*;;j4Rc "ޒﷀ1&,H6L&(0FRZ%`FI)Gx!A$y@TR҃  0PP4+)/ż+1E S6=Ы@:LXs[-d=SbX,]F9Oύ8@%a{B +w@%u<QP(I+pl<@p%xntp8ľ: ļ&kGxk m!!_C@ cdPV=c =#2+hYA,J3: 6QA xkLIENDB`libDAI-0.2.4/doc/html/functions_type.html0000644000263000017630000001742311334764772017152 0ustar jorismkyb libDAI: Class Members - Typedefs
 

- _ -

- c -

- e -

- f -

- i -

- l -

- n -

- o -

- p -

- r -

- s -

- u -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/namespacemembers.html0000644000263000017630000002450411334764772017406 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented namespace members with links to the namespaces they belong to:

- _ -

  • _normal_dist : dai
  • _normal_rnd() : dai
  • _rnd_gen() : dai
  • _rnd_gen_type : dai
  • _uni_dist() : dai
  • _uni_rnd() : dai

- a -

- c -

  • calcLinearState() : dai
  • calcMarginal() : dai
  • calcPairBeliefs() : dai
  • calcState() : dai
  • complement() : dai
  • concat() : dai
  • createFactorDelta() : dai
  • createFactorExpGauss() : dai
  • createFactorIsing() : dai
  • createFactorPotts() : dai
  • createGraphFull() : dai
  • createGraphGrid() : dai
  • createGraphGrid3D() : dai
  • createGraphLoop() : dai
  • createGraphRegular() : dai
  • createGraphTree() : dai

- d -

  • DAI_ENUM() : dai
  • DAIAlgFG : dai
  • DAIAlgRG : dai
  • DAINames : dai
  • dist() : dai

- e -

  • eliminationCost_MinFill() : dai
  • eliminationCost_MinNeighbors() : dai
  • eliminationCost_MinWeight() : dai
  • eliminationCost_WeightedMinFill() : dai
  • exp() : dai

- f -

  • Factor : dai
  • Factors2mx() : dai

- g -

  • getFactorEntryForState() : dai
  • Graph : dai

- l -

- m -

  • makePositive() : dai
  • makeZero() : dai
  • max() : dai
  • MaxSpanningTreePrims() : dai
  • MinSpanningTreePrims() : dai
  • mixBeliefs() : dai
  • mx2Factor() : dai
  • mx2Factors() : dai

- n -

  • Neighbor : dai
  • newInfAlg() : dai
  • newInfAlgFromString() : dai

- o -

  • operator<<() : dai
  • operator>>() : dai

- p -

  • parseNameProperties() : dai
  • Prob : dai
  • Property : dai
  • PropertyKey : dai
  • PropertyValue : dai

- r -

  • RandomDRegularGraph() : dai
  • readAliasesFile() : dai
  • Real : dai
  • rnd() : dai
  • rnd_int() : dai
  • rnd_seed() : dai
  • rnd_stdnormal() : dai
  • rnd_uniform() : dai

- t -

  • toc() : dai
  • tokenizeString() : dai

- u -

  • unSoftMax() : dai
Generated on Thu Feb 11 12:26:08 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_36.png0000644000263000017630000000031611334764772015165 0ustar jorismkybPNG  IHDR <0PLTEppp```PPP@@@000 4tRNS@fLIDATc`@P_!”g`h08000}tf>"QXcl[$ HCIENDB`libDAI-0.2.4/doc/html/classdai_1_1TRWBP.html0000644000263000017630000007031511334764772017142 0ustar jorismkyb libDAI: dai::TRWBP Class Reference

dai::TRWBP Class Reference

Approximate inference algorithm "Tree-Reweighted Belief Propagation" [WJW03]. More...

#include <dai/trwbp.h>

Inheritance diagram for dai::TRWBP:

dai::BP dai::DAIAlg< GRM > dai::InfAlg

List of all members.

TRWBP accessors/mutators for scale parameters

Real Weight (size_t I) const
 Returns weight corresponding to the I 'th factor.
const std::vector< Real > & Weights () const
 Returns constant reference to vector of all weights.
void setWeight (size_t I, Real c)
 Sets the weight of the I 'th factor to c.
void setWeights (const std::vector< Real > &c)
 Sets the weights of all factors simultaenously.
virtual Prob calcIncomingMessageProduct (size_t I, bool without_i, size_t i) const
 Calculate the product of factor I and the incoming messages.
virtual void calcBeliefV (size_t i, Prob &p) const
 Calculates unnormalized belief of variable i.
virtual void calcBeliefF (size_t I, Prob &p) const
 Calculates unnormalized belief of factor I.
virtual void construct ()
 Helper function for constructors.

Public Member Functions

Constructors/destructors
 TRWBP ()
 Default constructor.
 TRWBP (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts.
General InfAlg interface
virtual TRWBP * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
virtual std::string identify () const
 Identifies itself for logging purposes.
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Static Public Attributes

static const char * Name = "TRWBP"
 Name of this inference algorithm.

Protected Attributes

std::vector< Real > _weight
 "Edge weights" (indexed by factor ID)

Detailed Description

Approximate inference algorithm "Tree-Reweighted Belief Propagation" [WJW03].

The Tree-Reweighted Belief Propagation algorithm is like Belief Propagation, but associates each factor with a scale parameter. which controls the divergence measure being minimized.

The messages $m_{I\to i}(x_i)$ are passed from factors $I$ to variables $i$. The update equation is given by:

\[ m_{I\to i}(x_i) \propto \sum_{x_{N_I\setminus\{i\}}} f_I(x_I)^{1/c_I} \prod_{j\in N_I\setminus\{i\}} m_{I\to j}^{c_I-1} \prod_{J\in N_j\setminus\{I\}} m_{J\to j}^{c_J} \]

After convergence, the variable beliefs are calculated by:

\[ b_i(x_i) \propto \prod_{I\in N_i} m_{I\to i}^{c_I} \]

and the factor beliefs are calculated by:

\[ b_I(x_I) \propto f_I(x_I)^{1/c_I} \prod_{j \in N_I} m_{I\to j}^{c_I-1} \prod_{J\in N_j\setminus\{I\}} m_{J\to j}^{c_J} \]

The logarithm of the partition sum is approximated by:

\[ \log Z = \sum_{I} \sum_{x_I} b_I(x_I) \big( \log f_I(x_I) - c_I \log b_I(x_I) \big) + \sum_{i} (c_i - 1) \sum_{x_i} b_i(x_i) \log b_i(x_i) \]

where the variable weights are defined as

\[ c_i := \sum_{I \in N_i} c_I \]

Note:
TRWBP is actually equivalent to FBP
Todo:
Add nice way to set weights
Todo:
Merge code of FBP and TRWBP

Constructor & Destructor Documentation

dai::TRWBP::TRWBP (  )  [inline]

Default constructor.

dai::TRWBP::TRWBP ( const FactorGraph &  fg,
const PropertySet &  opts 
) [inline]

Construct from FactorGraph fg and PropertySet opts.

Parameters:
opts Parameters
See also:
BP::Properties

Member Function Documentation

virtual TRWBP* dai::TRWBP::clone (  )  const [inline, virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Reimplemented from dai::BP.

string dai::TRWBP::identify (  )  const [virtual]

Identifies itself for logging purposes.

Reimplemented from dai::BP.

Real dai::TRWBP::logZ (  )  const [virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::BP.

Real dai::TRWBP::Weight ( size_t  I  )  const [inline]

Returns weight corresponding to the I 'th factor.

const std::vector<Real>& dai::TRWBP::Weights (  )  const [inline]

Returns constant reference to vector of all weights.

void dai::TRWBP::setWeight ( size_t  I,
Real  c 
) [inline]

Sets the weight of the I 'th factor to c.

void dai::TRWBP::setWeights ( const std::vector< Real > &  c  )  [inline]

Sets the weights of all factors simultaenously.

Note:
Faster than calling setWeight(size_t,Real) for each factor

Prob dai::TRWBP::calcIncomingMessageProduct ( size_t  I,
bool  without_i,
size_t  i 
) const [protected, virtual]

Calculate the product of factor I and the incoming messages.

If without_i == true, the message coming from variable i is omitted from the product

Note:
This function is used by calcNewMessage() and calcBeliefF()

Reimplemented from dai::BP.

void dai::TRWBP::calcBeliefV ( size_t  i,
Prob &  p 
) const [protected, virtual]

Calculates unnormalized belief of variable i.

Reimplemented from dai::BP.

virtual void dai::TRWBP::calcBeliefF ( size_t  I,
Prob &  p 
) const [inline, protected, virtual]

Calculates unnormalized belief of factor I.

Reimplemented from dai::BP.

void dai::TRWBP::construct (  )  [protected, virtual]

Helper function for constructors.

Reimplemented from dai::BP.

Member Data Documentation

std::vector<Real> dai::TRWBP::_weight [protected]

"Edge weights" (indexed by factor ID)

In [WJW03], only unary or pairwise factors are considered. Here we are more general by having a weight for each factor in the factor graph. If unary factors have weight 1, and higher-order factors are absent, then we have the special case considered in [WJW03].

const char * dai::TRWBP::Name = "TRWBP" [static]

Name of this inference algorithm.

Reimplemented from dai::BP.

The documentation for this class was generated from the following files:
Generated on Thu Feb 11 12:26:07 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_0x64.html0000644000263000017630000002107511334764772016670 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- d -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1JTree.html0000644000263000017630000015574211334764772017265 0ustar jorismkyb libDAI: dai::JTree Class Reference

dai::JTree Class Reference

Exact inference algorithm using junction tree. More...

#include <dai/jtree.h>

Inheritance diagram for dai::JTree:

dai::DAIAlg< GRM > dai::InfAlg dai::TreeEP

List of all members.

Public Member Functions

Constructors/destructors
 JTree ()
 Default constructor.
 JTree (const FactorGraph &fg, const PropertySet &opts, bool automatic=true)
 Construct from FactorGraph fg and PropertySet opts.
General InfAlg interface
virtual JTree * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
virtual std::string identify () const
 Identifies itself for logging purposes.
virtual Factor belief (const VarSet &vs) const
 Returns the (approximate) marginal probability distribution of a set of variables.
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).
virtual void init ()
 Initializes all data structures of the approximate inference algorithm.
virtual void init (const VarSet &)
 Initializes all data structures corresponding to some set of variables.
virtual Real run ()
 Runs the approximate inference algorithm.
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration.
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph).
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm.
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet.
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".
Additional interface specific for JTree
void construct (const std::vector< VarSet > &cl, bool verify=false)
 Constructs a junction tree based on the cliques cl (corresponding to some elimination sequence).
void GenerateJT (const std::vector< VarSet > &cl)
 Constructs a junction tree based on the cliques cl (corresponding to some elimination sequence).
const Factor & message (size_t alpha, size_t _beta) const
 Returns constant reference to the message from outer region alpha to its _beta 'th neighboring inner region.
Factor & message (size_t alpha, size_t _beta)
 Returns reference to the message from outer region alpha to its _beta 'th neighboring inner region.
void runHUGIN ()
 Runs junction tree algorithm using HUGIN (message-free) updates.
void runShaferShenoy ()
 Runs junction tree algorithm using Shafer-Shenoy updates.
size_t findEfficientTree (const VarSet &vs, RootedTree &Tree, size_t PreviousRoot=(size_t)-1) const
 Finds an efficient subtree for calculating the marginal of the variables in vs.
Factor calcMarginal (const VarSet &vs)
 Calculates the marginal of a set of variables (using cutset conditioning, if necessary).
std::vector< std::size_t > findMaximum () const
 Calculates the joint state of all variables that has maximum probability.

Public Attributes

RootedTree RTree
 The junction tree (stored as a rooted tree).
std::vector< Factor > Qa
 Outer region beliefs.
std::vector< Factor > Qb
 Inner region beliefs.
struct dai::JTree::Properties props

Static Public Attributes

static const char * Name = "JTREE"
 Name of this inference algorithm.

Private Attributes

std::vector< std::vector
< Factor > > 		_mes
 Stores the messages.
Real _logZ
 Stores the logarithm of the partition sum.

Related Functions

(Note that these are not member functions.)

std::pair< size_t, double > boundTreewidth (const FactorGraph &fg, greedyVariableElimination::eliminationCostFunction fn)
 Calculates upper bound to the treewidth of a FactorGraph, using the specified heuristic.

Classes

struct  Properties
 Parameters for JTree. More...

Detailed Description

Exact inference algorithm using junction tree.

The junction tree algorithm uses message passing on a junction tree to calculate exact marginal probability distributions ("beliefs") for specified cliques (outer regions) and separators (intersections of pairs of cliques).

There are two variants, the sum-product algorithm (corresponding to finite temperature) and the max-product algorithm (corresponding to zero temperature).

Examples:

example.cpp.

Constructor & Destructor Documentation

dai::JTree::JTree (  )  [inline]

Default constructor.

dai::JTree::JTree ( const FactorGraph &  fg,
const PropertySet &  opts,
bool  automatic = true 
)

Construct from FactorGraph fg and PropertySet opts.

Parameters:
fg factor graph (which has to be connected);
opts Parameters
See also:
Properties
Parameters:
automatic if true, construct the junction tree automatically, using the heuristic in opts['heuristic'].
Exceptions:
FACTORGRAPH_NOT_CONNECTED if fg is not connected

Member Function Documentation

virtual JTree* dai::JTree::clone (  )  const [inline, virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Implements dai::InfAlg.

Reimplemented in dai::TreeEP.

string dai::JTree::identify (  )  const [virtual]

Identifies itself for logging purposes.

Implements dai::InfAlg.

Reimplemented in dai::TreeEP.

Factor dai::JTree::belief ( const VarSet &  vs  )  const [virtual]

Returns the (approximate) marginal probability distribution of a set of variables.

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported.
BELIEF_NOT_AVAILABLE if the requested belief cannot be calculated with this algorithm.

Implements dai::InfAlg.

Examples:
example.cpp.

vector< Factor > dai::JTree::beliefs (  )  const [virtual]

Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.

Note:
Before this method is called, run() should have been called.

Implements dai::InfAlg.

Real dai::JTree::logZ (  )  const [virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

Reimplemented in dai::TreeEP.

Examples:
example.cpp.

virtual void dai::JTree::init (  )  [inline, virtual]

Initializes all data structures of the approximate inference algorithm.

Note:
This method should be called at least once before run() is called.

Implements dai::InfAlg.

Reimplemented in dai::TreeEP.

Examples:
example.cpp.

virtual void dai::JTree::init ( const VarSet &  vs  )  [inline, virtual]

Initializes all data structures corresponding to some set of variables.

This method can be used to do a partial initialization after a part of the factor graph has changed. Instead of initializing all data structures, it only initializes those involving the variables in vs.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

Reimplemented in dai::TreeEP.

Real dai::JTree::run (  )  [virtual]

Runs the approximate inference algorithm.

Note:
Before run() is called the first time, init() should have been called.

Implements dai::InfAlg.

Reimplemented in dai::TreeEP.

Examples:
example.cpp.

virtual Real dai::JTree::maxDiff (  )  const [inline, virtual]

Returns maximum difference between single variable beliefs in the last iteration.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

Reimplemented in dai::TreeEP.

virtual size_t dai::JTree::Iterations (  )  const [inline, virtual]

Returns number of iterations done (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

Reimplemented in dai::TreeEP.

void dai::JTree::setProperties ( const PropertySet &  opts  )  [virtual]

Set parameters of this inference algorithm.

The parameters are set according to the PropertySet opts. The values can be stored either as std::string or as the type of the corresponding MF::props member.

Implements dai::InfAlg.

Reimplemented in dai::TreeEP.

PropertySet dai::JTree::getProperties (  )  const [virtual]

Returns parameters of this inference algorithm converted into a PropertySet.

Implements dai::InfAlg.

Reimplemented in dai::TreeEP.

string dai::JTree::printProperties (  )  const [virtual]

Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Implements dai::InfAlg.

Reimplemented in dai::TreeEP.

void dai::JTree::construct ( const std::vector< VarSet > &  cl,
bool  verify = false 
)

Constructs a junction tree based on the cliques cl (corresponding to some elimination sequence).

First, constructs a weighted graph, where the nodes are the elements of cl, and each edge is weighted with the cardinality of the intersection of the state spaces of the nodes. Then, a maximal spanning tree for this weighted graph is calculated. Subsequently, a corresponding region graph is built:

  • the outer regions correspond with the cliques and have counting number 1;
  • the inner regions correspond with the seperators, i.e., the intersections of two cliques that are neighbors in the spanning tree, and have counting number -1;
  • inner and outer regions are connected by an edge if the inner region is a seperator for the outer region. Finally, Beliefs are constructed. If verify == true, checks whether each factor is subsumed by a clique.

void dai::JTree::GenerateJT ( const std::vector< VarSet > &  cl  ) 

Constructs a junction tree based on the cliques cl (corresponding to some elimination sequence).

Invokes construct() and then constructs messages.

See also:
construct()

const Factor& dai::JTree::message ( size_t  alpha,
size_t  _beta 
) const [inline]

Returns constant reference to the message from outer region alpha to its _beta 'th neighboring inner region.

Factor& dai::JTree::message ( size_t  alpha,
size_t  _beta 
) [inline]

Returns reference to the message from outer region alpha to its _beta 'th neighboring inner region.

void dai::JTree::runHUGIN (  ) 

Runs junction tree algorithm using HUGIN (message-free) updates.

Note:
The initial messages may be arbitrary; actually they are not used at all.

void dai::JTree::runShaferShenoy (  ) 

Runs junction tree algorithm using Shafer-Shenoy updates.

Note:
The initial messages may be arbitrary.

size_t dai::JTree::findEfficientTree ( const VarSet &  vs,
RootedTree &  Tree,
size_t  PreviousRoot = (size_t)-1 
) const

Finds an efficient subtree for calculating the marginal of the variables in vs.

First, the current junction tree is reordered such that it gets as root the clique that has maximal state space overlap with vs. Then, the minimal subtree (starting from the root) is identified that contains all the variables in vs and also the outer region with index PreviousRoot (if specified). Finally, the current junction tree is reordered such that this minimal subtree comes before the other edges, and the size of the minimal subtree is returned.

Factor dai::JTree::calcMarginal ( const VarSet &  vs  ) 

Calculates the marginal of a set of variables (using cutset conditioning, if necessary).

Precondition:
assumes that run() has been called already

std::vector< size_t > dai::JTree::findMaximum (  )  const

Calculates the joint state of all variables that has maximum probability.

Precondition:
Assumes that run() has been called and that props.inference == MAXPROD
Examples:
example.cpp.

Friends And Related Function Documentation

std::pair< size_t, double > boundTreewidth ( const FactorGraph &  fg,
greedyVariableElimination::eliminationCostFunction  fn 
) [related]

Calculates upper bound to the treewidth of a FactorGraph, using the specified heuristic.

Returns:
a pair (number of variables in largest clique, number of states in largest clique)

Member Data Documentation

std::vector<std::vector<Factor> > dai::JTree::_mes [private]

Stores the messages.

Real dai::JTree::_logZ [private]

Stores the logarithm of the partition sum.

RootedTree dai::JTree::RTree

The junction tree (stored as a rooted tree).

std::vector<Factor> dai::JTree::Qa

Outer region beliefs.

std::vector<Factor> dai::JTree::Qb

Inner region beliefs.

const char * dai::JTree::Name = "JTREE" [static]

Name of this inference algorithm.

Reimplemented in dai::TreeEP.

The documentation for this class was generated from the following files:
Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1BBP_1_1Properties.html0000644000263000017630000003577211334764772021613 0ustar jorismkyb libDAI: dai::BBP::Properties Struct Reference

dai::BBP::Properties Struct Reference

Parameters for BBP. More...

#include <dai/bbp.h>

List of all members.

Public Member Functions

 DAI_ENUM (UpdateType, SEQ_FIX, SEQ_MAX, SEQ_BP_REV, SEQ_BP_FWD, PAR)
 Enumeration of possible update schedules.
void set (const PropertySet &opts)
 Set members from PropertySet.
PropertySet get () const
 Get members into PropertySet.
std::string toString () const
 Convert to a string which can be parsed as a PropertySet.

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr).
size_t maxiter
 Maximum number of iterations.
Real tol
 Tolerance for convergence test.
Real damping
 Damping constant (0 for none); damping = 1 - lambda where lambda is the damping constant used in [EaG09].
UpdateType updates
 Update schedule.

Detailed Description

Parameters for BBP.

Member Function Documentation

dai::BBP::Properties::DAI_ENUM ( UpdateType  ,
SEQ_FIX  ,
SEQ_MAX  ,
SEQ_BP_REV  ,
SEQ_BP_FWD  ,
PAR   
)

Enumeration of possible update schedules.

The following update schedules are defined:

  • SEQ_FIX fixed sequential updates
  • SEQ_MAX maximum residual updates (inspired by [EMK06])
  • SEQ_BP_REV schedule used by BP, but reversed
  • SEQ_BP_FWD schedule used by BP
  • PAR parallel updates

void dai::BBP::Properties::set ( const PropertySet &  opts  ) 

Set members from PropertySet.

Exceptions:
UNKNOWN_PROPERTY if a Property key is not recognized
NOT_ALL_PROPERTIES_SPECIFIED if an expected Property is missing

PropertySet dai::BBP::Properties::get (  )  const

Get members into PropertySet.

string dai::BBP::Properties::toString (  )  const

Convert to a string which can be parsed as a PropertySet.

Member Data Documentation

size_t dai::BBP::Properties::verbose

Verbosity (amount of output sent to stderr).

size_t dai::BBP::Properties::maxiter

Maximum number of iterations.

Real dai::BBP::Properties::tol

Tolerance for convergence test.

Note:
Not used for updates = SEQ_BP_REV, SEQ_BP_FWD

Real dai::BBP::Properties::damping

Damping constant (0 for none); damping = 1 - lambda where lambda is the damping constant used in [EaG09].

UpdateType dai::BBP::Properties::updates

Update schedule.

The documentation for this struct was generated from the following files:
  • include/dai/bbp.h
  • src/bbp.cpp
Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_0x6e.html0000644000263000017630000002437211334764772016754 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- n -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_34.png0000644000263000017630000000102011334764772015154 0ustar jorismkybPNG  IHDR?*O0PLTEppp```PPP@@@000 4tRNS@fIDAT8?H1ƿ]g[앂. b*MEutKѡX݄N. t%p˗/$P?՚,.yus%iRQJr}BR&6qC cᚃȉ G^_DLi #J.;5bmOI1g 3[֝mǃH A jF+͔y 8!Q4ف+j71Y$U9tT'0A\T'=IENDB`libDAI-0.2.4/doc/html/form_103.png0000644000263000017630000000361311334764772015243 0ustar jorismkybPNG  IHDR3ٚ0PLTEppp```PPP@@@000 4tRNS@f IDAThY[lUnw۝ %h: -!l"&D@.۠D + Dc+Xh$Uh,^CBF}hE*Ecbݖq̔v/3sso? ?n;BYByٔN}jX 0J®4JFwQP.['R8t12wH+-cf@=-*]JŏEN {56e~;("b?z#H۫Jqɧ:iET̡otn$%^m0`__/(!S!Mm7pvΙT0j.Aqh 85yUDNN"n[#m2Rgk-bf^=:=ڥ~x8wƺ&=}%TTPXlvPr!j6ml2g G:R~"V)Q!_n.O^鳁7<d魸w`ASޱ)] _G!Zj2kƌ8I7K=5z;֊cZ0ӂn bl.% ?7mx>(arּtXbx!BG</ 7VV=qB",̊*R)w8x\eboIT7%MG h06XBf]"LeF8Ecc{FQE}4؋n5}1>5XMhJ&KDrI:E{E4I/eNݗDFDH5ZyX^$0,*ϓhL0Y҄"Fu07Jguxتy{ː~6%$b9Nuhq&>}ڢiLQwuc O;gЗڤe3XV@D {(01or'+g^^5bb;l(z[zL Rqycw~~"%(s#VhPDĝFyQA쟋KwgBڐ;]=X8f,]|]I+&nJSܿd@:i"8*QPصmpALw(UHfh!苍:Un6ǁQޯ xAea%O 4O'G糈 uZ:Iq$)%=od?w ZDNw"/Q,"8ߚaC"Ŀ]k"\tbx4 fX JwE^LB*AY"@lUVW_TE0TźI$< #?qܝE* :LjzU\K`D0DbFl8R[K>\!\<*sFqVE&xoeM2I7a#$OY,E>2 cCXZSxg *r' N|!Z7fEIjC-e616>fqR$"*0qrg|۽]p>[zPU4 L\Ǝԍ YG _2Z{!%R}fNVr*ٷt_Ij,IENDB`libDAI-0.2.4/doc/html/form_138.png0000644000263000017630000000413611334764772015254 0ustar jorismkybPNG  IHDR@ۦ0PLTEppp```PPP@@@000 4tRNS@fIDATh[kU>NeU;*OP),jBD b YW QaEح$ƢBR@&PeMt?1JziّR39}Ν @Uy"_*NRnA*j--:yDx_Fm}A|_Zx\[tRig!\*e9zt !F!RBe\ud\53KKyc¨ylMTRY{jA͵WmWY=d_rfJ]5VH#]yRn'/p4o 5I tQ 99^g׮-L5i{q\s*d~K4c+ ZQb|Tvh23YaD5ԯ0OhR,a$d5/eܵO YhJlЏO#<"-[B!-< j8WwdwxO}\~ 0fY`r̶ur qh0_ gWzixC5?I" 0ӂ"jUo*YDy٩ p ;H .{ZW?VUP ^o|3 y𬱵Q_UcG *B60/ˤP>VORx!|\<08^ш6NxDN}kNmcyw $nӟlChS&>@#NGK@z|ߵ)+zL$9w;&ʷ~&5P{q+'yp+K=>4ޠρ+z2ӗ\n |e4@ 4w45ZfdtI9UJWe/SF@?XAd|Jiwcs#^qF@]!͋;V.xXld5UYp-p݄ӊKKWy~y*.p' +r _(VZʣ7˲`,](GE>1*.PL=+zPnZxk]7c߳%ҩPeAW?x1*.oMr8T/ {B9"Xm%IFf-7 lya(ºȖ F}';|ngcKޣ, fBc;;wC29]VB ;d G(qjm٦O9vb~!G Ь2Xj$ ^ QeM\$mMc{ёd؜Bp7Iöe4DpFV+ G069g(nG  q~Ȃ=D f8EDՋ+2r#Hy AÀf=cSn4)&!b? Z [aHoSG.ؔ#) 3K> P6.OIm32veD&gլ+p(2-( UH)}9 ^2un2,#:B{[SR)++֡àWNFx<(&S2WIԆG:7]݌%Z.. bZk /d"tw-Do"U{%*Jҭ܀X@ˆԙ&'錀GpkX5.:e1k?bܤ:IENDB`libDAI-0.2.4/doc/html/structdai_1_1BP_1_1EdgeProp-members.html0000644000263000017630000000476411334764772022507 0ustar jorismkyb libDAI: Member List

dai::BP::EdgeProp Member List

This is the complete list of members for dai::BP::EdgeProp, including all inherited members.

indexdai::BP::EdgeProp
messagedai::BP::EdgeProp
newMessagedai::BP::EdgeProp
residualdai::BP::EdgeProp

Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1fo__inv0.html0000644000263000017630000000730611334764772020162 0ustar jorismkyb libDAI: dai::fo_inv0< T > Struct Template Reference

dai::fo_inv0< T > Struct Template Reference

Function object that takes the inverse, except that 1/0 is defined to be 0. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &x) const
 Returns (x == 0 ? 0 : (1 / x)).

Detailed Description

template<typename T>
struct dai::fo_inv0< T >

Function object that takes the inverse, except that 1/0 is defined to be 0.

Member Function Documentation

template<typename T>
T dai::fo_inv0< T >::operator() ( const T &  x  )  const [inline]

Returns (x == 0 ? 0 : (1 / x)).

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1SmallSet.html0000644000263000017630000016232511334764772017773 0ustar jorismkyb libDAI: dai::SmallSet< T > Class Template Reference

dai::SmallSet< T > Class Template Reference

Represents a set; the implementation is optimized for a small number of elements. More...

#include <dai/smallset.h>

Inheritance diagram for dai::SmallSet< T >:

dai::VarSet dai::Region

List of all members.

Public Types

typedef std::vector< T >
::const_iterator 		const_iterator
 Constant iterator over the elements.
typedef std::vector< T >::iterator iterator
 Iterator over the elements.
typedef std::vector< T >
::const_reverse_iterator 		const_reverse_iterator
 Constant reverse iterator over the elements.
typedef std::vector< T >
::reverse_iterator 		reverse_iterator
 Reverse iterator over the elements.

Public Member Functions

Constructors and destructors
 SmallSet ()
 Default constructor (constructs an empty set).
 SmallSet (const T &t)
 Construct a set consisting of one element.
 SmallSet (const T &t1, const T &t2)
 Construct a set consisting of two elements.
template<typename TIterator>
 SmallSet (TIterator begin, TIterator end, size_t sizeHint=0)
 Construct a SmallSet from a range of elements.
Operators for set-theoretic operations
SmallSet operator/ (const SmallSet &x) const
 Set-minus operator: returns all elements in *this, except those in x.
SmallSet operator| (const SmallSet &x) const
 Set-union operator: returns all elements in *this, plus those in x.
SmallSet operator & (const SmallSet &x) const
 Set-intersection operator: returns all elements in *this that are also contained in x.
SmallSet & operator/= (const SmallSet &x)
 Erases from *this all elements in x.
SmallSet & operator/= (const T &t)
 Erases one element.
SmallSet & operator|= (const SmallSet &x)
 Adds to *this all elements in x.
SmallSet & operator|= (const T &t)
 Adds one element.
SmallSet & operator &= (const SmallSet &x)
 Erases from *this all elements not in x.
bool operator<< (const SmallSet &x) const
 Returns true if *this is a subset of x.
bool operator>> (const SmallSet &x) const
 Returns true if x is a subset of *this.
Queries
bool intersects (const SmallSet &x) const
 Returns true if *this and x have elements in common.
bool contains (const T &t) const
 Returns true if *this contains the element t.
std::vector< T >::size_type size () const
 Returns number of elements.
bool empty () const
 Returns whether *this is empty.
std::vector< T > & elements ()
 Returns reference to the elements.
const std::vector< T > & elements () const
 Returns constant reference to the elements.
Iterator interface
iterator begin ()
 Returns iterator that points to the first element.
const_iterator begin () const
 Returns constant iterator that points to the first element.
iterator end ()
 Returns iterator that points beyond the last element.
const_iterator end () const
 Returns constant iterator that points beyond the last element.
reverse_iterator rbegin ()
 Returns reverse iterator that points to the last element.
const_reverse_iterator rbegin () const
 Returns constant reverse iterator that points to the last element.
reverse_iterator rend ()
 Returns reverse iterator that points beyond the first element.
const_reverse_iterator rend () const
 Returns constant reverse iterator that points beyond the first element.
T & front ()
 Returns reference to first element.
const T & front () const
 Returns constant reference to first element.

Private Attributes

std::vector< T > _elements
 The elements in this set.

Friends

Comparison operators
bool operator== (const SmallSet &a, const SmallSet &b)
 Returns true if a and b are identical.
bool operator!= (const SmallSet &a, const SmallSet &b)
 Returns true if a and b are not identical.
bool operator< (const SmallSet &a, const SmallSet &b)
 Lexicographical comparison of elements.

Detailed Description

template<typename T>
class dai::SmallSet< T >

Represents a set; the implementation is optimized for a small number of elements.

SmallSet uses an ordered std::vector<T> to represent a set; this is faster than using a std::set<T> if the number of elements is small.

Template Parameters:
T Should be less-than-comparable.

Member Typedef Documentation

template<typename T>
typedef std::vector<T>::const_iterator dai::SmallSet< T >::const_iterator

Constant iterator over the elements.

template<typename T>
typedef std::vector<T>::iterator dai::SmallSet< T >::iterator

Iterator over the elements.

template<typename T>
typedef std::vector<T>::const_reverse_iterator dai::SmallSet< T >::const_reverse_iterator

Constant reverse iterator over the elements.

template<typename T>
typedef std::vector<T>::reverse_iterator dai::SmallSet< T >::reverse_iterator

Reverse iterator over the elements.

Constructor & Destructor Documentation

template<typename T>
dai::SmallSet< T >::SmallSet (  )  [inline]

Default constructor (constructs an empty set).

template<typename T>
dai::SmallSet< T >::SmallSet ( const T &  t  )  [inline]

Construct a set consisting of one element.

template<typename T>
dai::SmallSet< T >::SmallSet ( const T &  t1,
const T &  t2 
) [inline]

Construct a set consisting of two elements.

template<typename T>
template<typename TIterator>
dai::SmallSet< T >::SmallSet ( TIterator  begin,
TIterator  end,
size_t  sizeHint = 0 
) [inline]

Construct a SmallSet from a range of elements.

Template Parameters:
TIterator Iterates over instances of type T.
Parameters:
begin Points to first element to be added.
end Points just beyond last element to be added.
sizeHint For efficiency, the number of elements can be speficied by sizeHint.

Member Function Documentation

template<typename T>
SmallSet dai::SmallSet< T >::operator/ ( const SmallSet< T > &  x  )  const [inline]

Set-minus operator: returns all elements in *this, except those in x.

template<typename T>
SmallSet dai::SmallSet< T >::operator| ( const SmallSet< T > &  x  )  const [inline]

Set-union operator: returns all elements in *this, plus those in x.

template<typename T>
SmallSet dai::SmallSet< T >::operator & ( const SmallSet< T > &  x  )  const [inline]

Set-intersection operator: returns all elements in *this that are also contained in x.

template<typename T>
SmallSet& dai::SmallSet< T >::operator/= ( const SmallSet< T > &  x  )  [inline]

Erases from *this all elements in x.

template<typename T>
SmallSet& dai::SmallSet< T >::operator/= ( const T &  t  )  [inline]

Erases one element.

template<typename T>
SmallSet& dai::SmallSet< T >::operator|= ( const SmallSet< T > &  x  )  [inline]

Adds to *this all elements in x.

template<typename T>
SmallSet& dai::SmallSet< T >::operator|= ( const T &  t  )  [inline]

Adds one element.

template<typename T>
SmallSet& dai::SmallSet< T >::operator &= ( const SmallSet< T > &  x  )  [inline]

Erases from *this all elements not in x.

template<typename T>
bool dai::SmallSet< T >::operator<< ( const SmallSet< T > &  x  )  const [inline]

Returns true if *this is a subset of x.

template<typename T>
bool dai::SmallSet< T >::operator>> ( const SmallSet< T > &  x  )  const [inline]

Returns true if x is a subset of *this.

template<typename T>
bool dai::SmallSet< T >::intersects ( const SmallSet< T > &  x  )  const [inline]

Returns true if *this and x have elements in common.

template<typename T>
bool dai::SmallSet< T >::contains ( const T &  t  )  const [inline]

Returns true if *this contains the element t.

template<typename T>
std::vector<T>::size_type dai::SmallSet< T >::size (  )  const [inline]

Returns number of elements.

Examples:
example_permute.cpp.

template<typename T>
bool dai::SmallSet< T >::empty (  )  const [inline]

Returns whether *this is empty.

template<typename T>
std::vector<T>& dai::SmallSet< T >::elements (  )  [inline]

Returns reference to the elements.

template<typename T>
const std::vector<T>& dai::SmallSet< T >::elements (  )  const [inline]

Returns constant reference to the elements.

template<typename T>
iterator dai::SmallSet< T >::begin (  )  [inline]

Returns iterator that points to the first element.

Examples:
example_permute.cpp.

template<typename T>
const_iterator dai::SmallSet< T >::begin (  )  const [inline]

Returns constant iterator that points to the first element.

template<typename T>
iterator dai::SmallSet< T >::end (  )  [inline]

Returns iterator that points beyond the last element.

template<typename T>
const_iterator dai::SmallSet< T >::end (  )  const [inline]

Returns constant iterator that points beyond the last element.

template<typename T>
reverse_iterator dai::SmallSet< T >::rbegin (  )  [inline]

Returns reverse iterator that points to the last element.

template<typename T>
const_reverse_iterator dai::SmallSet< T >::rbegin (  )  const [inline]

Returns constant reverse iterator that points to the last element.

template<typename T>
reverse_iterator dai::SmallSet< T >::rend (  )  [inline]

Returns reverse iterator that points beyond the first element.

template<typename T>
const_reverse_iterator dai::SmallSet< T >::rend (  )  const [inline]

Returns constant reverse iterator that points beyond the first element.

template<typename T>
T& dai::SmallSet< T >::front (  )  [inline]

Returns reference to first element.

template<typename T>
const T& dai::SmallSet< T >::front (  )  const [inline]

Returns constant reference to first element.

Friends And Related Function Documentation

template<typename T>
bool operator== ( const SmallSet< T > &  a,
const SmallSet< T > &  b 
) [friend]

Returns true if a and b are identical.

template<typename T>
bool operator!= ( const SmallSet< T > &  a,
const SmallSet< T > &  b 
) [friend]

Returns true if a and b are not identical.

template<typename T>
bool operator< ( const SmallSet< T > &  a,
const SmallSet< T > &  b 
) [friend]

Lexicographical comparison of elements.

Member Data Documentation

template<typename T>
std::vector<T> dai::SmallSet< T >::_elements [private]

The elements in this set.

The documentation for this class was generated from the following file:
Generated on Thu Feb 11 12:26:07 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1BP.html0000644000263000017630000024313011334764772016542 0ustar jorismkyb libDAI: dai::BP Class Reference

dai::BP Class Reference

Approximate inference algorithm "(Loopy) Belief Propagation". More...

#include <dai/bp.h>

Inheritance diagram for dai::BP:

dai::DAIAlg< GRM > dai::InfAlg dai::FBP dai::TRWBP

List of all members.

Public Member Functions

Constructors/destructors
 BP ()
 Default constructor.
 BP (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts.
 BP (const BP &x)
 Copy constructor.
BP & operator= (const BP &x)
 Assignment operator.
General InfAlg interface
virtual BP * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
virtual std::string identify () const
 Identifies itself for logging purposes.
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable.
virtual Factor belief (const VarSet &vs) const
 Returns the (approximate) marginal probability distribution of a set of variables.
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i.
virtual Factor beliefF (size_t I) const
 Returns the (approximate) marginal probability distribution of the variables on which factor I depends.
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).
virtual void init ()
 Initializes all data structures of the approximate inference algorithm.
virtual void init (const VarSet &ns)
 Initializes all data structures corresponding to some set of variables.
virtual Real run ()
 Runs the approximate inference algorithm.
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration.
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph).
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm.
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet.
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".
Additional interface specific for BP
std::vector< std::size_t > findMaximum () const
 Calculates the joint state of all variables that has maximum probability.
const std::vector< std::pair
< std::size_t, std::size_t > > & 		getSentMessages () const
 Returns history of which messages have been updated.
void clearSentMessages ()
 Clears history of which messages have been updated.

Public Attributes

struct dai::BP::Properties props
bool recordSentMessages
 Specifies whether the history of message updates should be recorded.

Static Public Attributes

static const char * Name = "BP"
 Name of this inference algorithm.

Protected Types

typedef std::vector< size_t > ind_t
 Type used for index cache.
typedef std::multimap< Real,
std::pair< std::size_t,
std::size_t > > 		LutType
 Type of lookup table (only used for maximum-residual BP).

Protected Member Functions

const Prob & message (size_t i, size_t _I) const
 Returns constant reference to message from the _I 'th neighbor of variable i to variable i.
Prob & message (size_t i, size_t _I)
 Returns reference to message from the _I 'th neighbor of variable i to variable i.
const Prob & newMessage (size_t i, size_t _I) const
 Returns constant reference to updated message from the _I 'th neighbor of variable i to variable i.
Prob & newMessage (size_t i, size_t _I)
 Returns reference to updated message from the _I 'th neighbor of variable i to variable i.
const ind_t & index (size_t i, size_t _I) const
 Returns constant reference to cached index for the edge between variable i and its _I 'th neighbor.
ind_t & index (size_t i, size_t _I)
 Returns reference to cached index for the edge between variable i and its _I 'th neighbor.
const Real & residual (size_t i, size_t _I) const
 Returns constant reference to residual for the edge between variable i and its _I 'th neighbor.
Real & residual (size_t i, size_t _I)
 Returns reference to residual for the edge between variable i and its _I 'th neighbor.
virtual Prob calcIncomingMessageProduct (size_t I, bool without_i, size_t i) const
 Calculate the product of factor I and the incoming messages.
virtual void calcNewMessage (size_t i, size_t _I)
 Calculate the updated message from the _I 'th neighbor of variable i to variable i.
void updateMessage (size_t i, size_t _I)
 Replace the "old" message from the _I 'th neighbor of variable i to variable i by the "new" (updated) message.
void updateResidual (size_t i, size_t _I, Real r)
 Set the residual (difference between new and old message) for the edge between variable i and its _I 'th neighbor to r.
void findMaxResidual (size_t &i, size_t &_I)
 Finds the edge which has the maximum residual (difference between new and old message).
virtual void calcBeliefV (size_t i, Prob &p) const
 Calculates unnormalized belief of variable i.
virtual void calcBeliefF (size_t I, Prob &p) const
 Calculates unnormalized belief of factor I.
virtual void construct ()
 Helper function for constructors.

Protected Attributes

std::vector< std::vector
< EdgeProp > > 		_edges
 Stores all edge properties.
std::vector< std::vector
< LutType::iterator > > 		_edge2lut
 Lookup table (only used for maximum-residual BP).
LutType _lut
 Lookup table (only used for maximum-residual BP).
Real _maxdiff
 Maximum difference between variable beliefs encountered so far.
size_t _iters
 Number of iterations needed.
std::vector< std::pair
< std::size_t, std::size_t > > 		_sentMessages
 The history of message updates (only recorded if recordSentMessages is true).

Classes

struct  EdgeProp
 Type used for storing edge properties. More...
struct  Properties
 Parameters for BP. More...

Detailed Description

Approximate inference algorithm "(Loopy) Belief Propagation".

The Loopy Belief Propagation algorithm uses message passing to approximate marginal probability distributions ("beliefs") for variables and factors (more precisely, for the subset of variables depending on the factor). There are two variants, the sum-product algorithm (corresponding to finite temperature) and the max-product algorithm (corresponding to zero temperature).

The messages $m_{I\to i}(x_i)$ are passed from factors $I$ to variables $i$. In case of the sum-product algorith, the update equation is:

\[ m_{I\to i}(x_i) \propto \sum_{x_{N_I\setminus\{i\}}} f_I(x_I) \prod_{j\in N_I\setminus\{i\}} \prod_{J\in N_j\setminus\{I\}} m_{J\to j}\]

and in case of the max-product algorithm:

\[ m_{I\to i}(x_i) \propto \max_{x_{N_I\setminus\{i\}}} f_I(x_I) \prod_{j\in N_I\setminus\{i\}} \prod_{J\in N_j\setminus\{I\}} m_{J\to j}\]

In order to improve convergence, the updates can be damped. For improved numerical stability, the updates can be done in the log-domain alternatively.

After convergence, the variable beliefs are calculated by:

\[ b_i(x_i) \propto \prod_{I\in N_i} m_{I\to i}(x_i)\]

and the factor beliefs are calculated by:

\[ b_I(x_I) \propto f_I(x_I) \prod_{j\in N_I} \prod_{J\in N_j\setminus\{I\}} m_{J\to j}(x_j) \]

The logarithm of the partition sum is calculated by:

\[ \log Z = \sum_i (1 - |N_i|) \sum_{x_i} b_i(x_i) \log b_i(x_i) - \sum_I \sum_{x_I} b_I(x_I) \log \frac{b_I(x_I)}{f_I(x_I)} \]

For the max-product algorithm, a heuristic way of finding the MAP state (the joint configuration of all variables which has maximum probability) is provided by the findMaximum() method, which can be called after convergence.

Note:
There are two implementations, an optimized one (the default) which caches IndexFor objects, and a slower, less complicated one which is easier to maintain/understand. The slower one can be enabled by defining DAI_BP_FAST as false in the source file.
Examples:

example.cpp.

Member Typedef Documentation

typedef std::vector<size_t> dai::BP::ind_t [protected]

Type used for index cache.

typedef std::multimap<Real, std::pair<std::size_t, std::size_t> > dai::BP::LutType [protected]

Type of lookup table (only used for maximum-residual BP).

Constructor & Destructor Documentation

dai::BP::BP (  )  [inline]

Default constructor.

dai::BP::BP ( const FactorGraph &  fg,
const PropertySet &  opts 
) [inline]

Construct from FactorGraph fg and PropertySet opts.

Parameters:
opts Parameters
See also:
Properties

dai::BP::BP ( const BP &  x  )  [inline]

Copy constructor.

Member Function Documentation

BP& dai::BP::operator= ( const BP &  x  )  [inline]

Assignment operator.

virtual BP* dai::BP::clone (  )  const [inline, virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Implements dai::InfAlg.

Reimplemented in dai::FBP, and dai::TRWBP.

string dai::BP::identify (  )  const [virtual]

Identifies itself for logging purposes.

Implements dai::InfAlg.

Reimplemented in dai::FBP, and dai::TRWBP.

virtual Factor dai::BP::belief ( const Var &  v  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of a variable.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

Examples:
example.cpp.

Factor dai::BP::belief ( const VarSet &  vs  )  const [virtual]

Returns the (approximate) marginal probability distribution of a set of variables.

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported.
BELIEF_NOT_AVAILABLE if the requested belief cannot be calculated with this algorithm.

Implements dai::InfAlg.

Factor dai::BP::beliefV ( size_t  i  )  const [virtual]

Returns the (approximate) marginal probability distribution of the variable with index i.

For some approximate inference algorithms, using beliefV() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

Factor dai::BP::beliefF ( size_t  I  )  const [virtual]

Returns the (approximate) marginal probability distribution of the variables on which factor I depends.

For some approximate inference algorithms, using beliefF() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

Examples:
example.cpp.

vector< Factor > dai::BP::beliefs (  )  const [virtual]

Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.

Note:
Before this method is called, run() should have been called.

Implements dai::InfAlg.

Real dai::BP::logZ (  )  const [virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

Reimplemented in dai::FBP, and dai::TRWBP.

Examples:
example.cpp.

void dai::BP::init (  )  [virtual]

Initializes all data structures of the approximate inference algorithm.

Note:
This method should be called at least once before run() is called.

Implements dai::InfAlg.

Examples:
example.cpp.

void dai::BP::init ( const VarSet &  vs  )  [virtual]

Initializes all data structures corresponding to some set of variables.

This method can be used to do a partial initialization after a part of the factor graph has changed. Instead of initializing all data structures, it only initializes those involving the variables in vs.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

Real dai::BP::run (  )  [virtual]

Runs the approximate inference algorithm.

Note:
Before run() is called the first time, init() should have been called.

Implements dai::InfAlg.

Examples:
example.cpp.

virtual Real dai::BP::maxDiff (  )  const [inline, virtual]

Returns maximum difference between single variable beliefs in the last iteration.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

virtual size_t dai::BP::Iterations (  )  const [inline, virtual]

Returns number of iterations done (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

void dai::BP::setProperties ( const PropertySet &  opts  )  [virtual]

Set parameters of this inference algorithm.

The parameters are set according to the PropertySet opts. The values can be stored either as std::string or as the type of the corresponding MF::props member.

Implements dai::InfAlg.

PropertySet dai::BP::getProperties (  )  const [virtual]

Returns parameters of this inference algorithm converted into a PropertySet.

Implements dai::InfAlg.

string dai::BP::printProperties (  )  const [virtual]

Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Implements dai::InfAlg.

std::vector< size_t > dai::BP::findMaximum (  )  const

Calculates the joint state of all variables that has maximum probability.

Precondition:
Assumes that run() has been called and that props.inference == MAXPROD
Examples:
example.cpp.

const std::vector<std::pair<std::size_t, std::size_t> >& dai::BP::getSentMessages (  )  const [inline]

Returns history of which messages have been updated.

void dai::BP::clearSentMessages (  )  [inline]

Clears history of which messages have been updated.

const Prob& dai::BP::message ( size_t  i,
size_t  _I 
) const [inline, protected]

Returns constant reference to message from the _I 'th neighbor of variable i to variable i.

Prob& dai::BP::message ( size_t  i,
size_t  _I 
) [inline, protected]

Returns reference to message from the _I 'th neighbor of variable i to variable i.

const Prob& dai::BP::newMessage ( size_t  i,
size_t  _I 
) const [inline, protected]

Returns constant reference to updated message from the _I 'th neighbor of variable i to variable i.

Prob& dai::BP::newMessage ( size_t  i,
size_t  _I 
) [inline, protected]

Returns reference to updated message from the _I 'th neighbor of variable i to variable i.

const ind_t& dai::BP::index ( size_t  i,
size_t  _I 
) const [inline, protected]

Returns constant reference to cached index for the edge between variable i and its _I 'th neighbor.

ind_t& dai::BP::index ( size_t  i,
size_t  _I 
) [inline, protected]

Returns reference to cached index for the edge between variable i and its _I 'th neighbor.

const Real& dai::BP::residual ( size_t  i,
size_t  _I 
) const [inline, protected]

Returns constant reference to residual for the edge between variable i and its _I 'th neighbor.

Real& dai::BP::residual ( size_t  i,
size_t  _I 
) [inline, protected]

Returns reference to residual for the edge between variable i and its _I 'th neighbor.

Prob dai::BP::calcIncomingMessageProduct ( size_t  I,
bool  without_i,
size_t  i 
) const [protected, virtual]

Calculate the product of factor I and the incoming messages.

If without_i == true, the message coming from variable i is omitted from the product

Note:
This function is used by calcNewMessage() and calcBeliefF()

Reimplemented in dai::FBP, and dai::TRWBP.

void dai::BP::calcNewMessage ( size_t  i,
size_t  _I 
) [protected, virtual]

Calculate the updated message from the _I 'th neighbor of variable i to variable i.

Reimplemented in dai::FBP.

void dai::BP::updateMessage ( size_t  i,
size_t  _I 
) [protected]

Replace the "old" message from the _I 'th neighbor of variable i to variable i by the "new" (updated) message.

void dai::BP::updateResidual ( size_t  i,
size_t  _I,
Real  r 
) [protected]

Set the residual (difference between new and old message) for the edge between variable i and its _I 'th neighbor to r.

void dai::BP::findMaxResidual ( size_t &  i,
size_t &  _I 
) [protected]

Finds the edge which has the maximum residual (difference between new and old message).

void dai::BP::calcBeliefV ( size_t  i,
Prob &  p 
) const [protected, virtual]

Calculates unnormalized belief of variable i.

Reimplemented in dai::TRWBP.

virtual void dai::BP::calcBeliefF ( size_t  I,
Prob &  p 
) const [inline, protected, virtual]

Calculates unnormalized belief of factor I.

Reimplemented in dai::FBP, and dai::TRWBP.

void dai::BP::construct (  )  [protected, virtual]

Helper function for constructors.

Reimplemented in dai::FBP, and dai::TRWBP.

Member Data Documentation

std::vector<std::vector<EdgeProp> > dai::BP::_edges [protected]

Stores all edge properties.

std::vector<std::vector<LutType::iterator> > dai::BP::_edge2lut [protected]

Lookup table (only used for maximum-residual BP).

LutType dai::BP::_lut [protected]

Lookup table (only used for maximum-residual BP).

Real dai::BP::_maxdiff [protected]

Maximum difference between variable beliefs encountered so far.

size_t dai::BP::_iters [protected]

Number of iterations needed.

std::vector<std::pair<std::size_t, std::size_t> > dai::BP::_sentMessages [protected]

The history of message updates (only recorded if recordSentMessages is true).

const char * dai::BP::Name = "BP" [static]

Name of this inference algorithm.

Reimplemented in dai::FBP, and dai::TRWBP.

bool dai::BP::recordSentMessages

Specifies whether the history of message updates should be recorded.

The documentation for this class was generated from the following files:
  • include/dai/bp.h
  • src/bp.cpp
Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1FactorGraph.html0000644000263000017630000030027511334764772020445 0ustar jorismkyb libDAI: dai::FactorGraph Class Reference

dai::FactorGraph Class Reference

Represents a factor graph. More...

#include <dai/factorgraph.h>

Inheritance diagram for dai::FactorGraph:

dai::RegionGraph dai::DAIAlg< dai::FactorGraph > dai::DAIAlg< dai::RegionGraph >

List of all members.

Input/Output

void ReadFromFile (const char *filename)
 Reads a factor graph from a file.
void WriteToFile (const char *filename, size_t precision=15) const
 Writes a factor graph to a file.
void printDot (std::ostream &os) const
 Writes a factor graph to a GraphViz .dot file.
std::ostream & operator<< (std::ostream &os, const FactorGraph &fg)
 Writes a factor graph to an output stream.
std::istream & operator>> (std::istream &is, FactorGraph &fg)
 Reads a factor graph from an input stream.

Public Types

typedef BipartiteGraph::Neighbor Neighbor
 Shorthand for BipartiteGraph::Neighbor.
typedef BipartiteGraph::Neighbors Neighbors
 Shorthand for BipartiteGraph::Neighbors.
typedef BipartiteGraph::Edge Edge
 Shorthand for BipartiteGraph::Edge.
typedef std::vector< Factor >
::iterator 		iterator
 Iterator over factors.
typedef std::vector< Factor >
::const_iterator 		const_iterator
 Constant iterator over factors.

Public Member Functions

Constructors and destructors
 FactorGraph ()
 Default constructor.
 FactorGraph (const std::vector< Factor > &P)
 Constructs a factor graph from a vector of factors.
template<typename FactorInputIterator, typename VarInputIterator>
 FactorGraph (FactorInputIterator fact_begin, FactorInputIterator fact_end, VarInputIterator var_begin, VarInputIterator var_end, size_t nr_fact_hint=0, size_t nr_var_hint=0)
 Constructs a factor graph from given factor and variable iterators.
virtual ~FactorGraph ()
 Destructor.
virtual FactorGraph * clone () const
 Virtual copy constructor.
Accessors and mutators
const Var & var (size_t i) const
 Returns constant reference the i 'th variable.
const std::vector< Var > & vars () const
 Returns constant reference to all variables.
Factor & factor (size_t I)
 Returns reference to I 'th factor.
const Factor & factor (size_t I) const
 Returns constant reference to I 'th factor.
const std::vector< Factor > & factors () const
 Returns constant reference to all factors.
const Neighbors & nbV (size_t i) const
 Returns constant reference to neighbors of the i 'th variable.
const Neighbors & nbF (size_t I) const
 Returns constant reference to neighbors of the I 'th factor.
const Neighbor & nbV (size_t i, size_t _I) const
 Returns constant reference to the _I 'th neighbor of the i 'th variable.
const Neighbor & nbF (size_t I, size_t _i) const
 Returns constant reference to the _i 'th neighbor of the I 'th factor.
Iterator interface
iterator begin ()
 Returns iterator pointing to first factor.
const_iterator begin () const
 Returns constant iterator pointing to first factor.
iterator end ()
 Returns iterator pointing beyond last factor.
const_iterator end () const
 Returns constant iterator pointing beyond last factor.
Queries
size_t nrVars () const
 Returns number of variables.
size_t nrFactors () const
 Returns number of factors.
size_t nrEdges () const
 Calculates number of edges.
size_t findVar (const Var &n) const
 Returns the index of a particular variable.
std::set< size_t > findVars (VarSet &ns) const
 Returns a set of indexes corresponding to a set of variables.
size_t findFactor (const VarSet &ns) const
 Returns index of the first factor that depends on the variables.
VarSet Delta (size_t i) const
 Return all variables that occur in a factor involving the i 'th variable, itself included.
VarSet Delta (const VarSet &vs) const
 Return all variables that occur in a factor involving some variable in vs, vs itself included.
VarSet delta (size_t i) const
 Return all variables that occur in a factor involving the i 'th variable, itself excluded.
VarSet delta (const VarSet &vs) const
 Return all variables that occur in a factor involving some variable in vs, vs itself excluded.
bool isConnected () const
 Returns true if the factor graph is connected.
bool isTree () const
 Returns true if the factor graph is a tree (i.e., has no cycles and is connected).
bool isPairwise () const
 Returns true if each factor depends on at most two variables.
bool isBinary () const
 Returns true if each variable has only two possible values.
std::vector< VarSet > Cliques () const
 Returns the cliques (fully connected subgraphs of the corresponding Markov graph) in this factor graph.
Backup/restore mechanism for factors
virtual void setFactor (size_t I, const Factor &newFactor, bool backup=false)
 Set the content of the I 'th factor and make a backup of its old content if backup == true.
virtual void setFactors (const std::map< size_t, Factor > &facs, bool backup=false)
 Set the contents of all factors as specified by facs and make a backup of the old contents if backup == true.
void backupFactor (size_t I)
 Makes a backup of the I 'th factor.
void restoreFactor (size_t I)
 Restores the I 'th factor from the backup (it should be backed up first).
virtual void backupFactors (const std::set< size_t > &facs)
 Backup the factors specified by indices in facs.
virtual void restoreFactors ()
 Restore all factors to the backup copies.
void backupFactors (const VarSet &ns)
 Makes a backup of all factors connected to a set of variables.
void restoreFactors (const VarSet &ns)
 Restores all factors connected to a set of variables from their backups.
Transformations
FactorGraph maximalFactors () const
 Returns a copy of *this, where all factors that are subsumed by some larger factor are merged with the larger factors.
FactorGraph clamped (size_t i, size_t x) const
 Clamp the i 'th variable to value x (i.e. multiply with a Kronecker delta $\delta_{x_i,x}$);.
Operations
virtual void clamp (size_t i, size_t x, bool backup=false)
 Clamp the i 'th variable to value x (i.e. multiply with a Kronecker delta $\delta_{x_i, x}$).
void clampVar (size_t i, const std::vector< size_t > &xis, bool backup=false)
 Clamp a variable in a factor graph to have one out of a list of values.
void clampFactor (size_t I, const std::vector< size_t > &xIs, bool backup=false)
 Clamp a factor in a factor graph to have one out of a list of values.
virtual void makeCavity (size_t i, bool backup=false)
 Set all factors interacting with the i 'th variable to 1.

Public Attributes

BipartiteGraph G
 Stores the neighborhood structure.

Private Member Functions

void constructGraph (size_t nrEdges)
 Part of constructors (creates edges, neighbors and adjacency matrix).

Private Attributes

std::vector< Var > _vars
 Stores the variables.
std::vector< Factor > _factors
 Stores the factors.
std::map< size_t, Factor > _backup
 Stores backups of some factors.

Detailed Description

Represents a factor graph.

Both Bayesian Networks and Markov random fields can be represented in a unifying representation, called factor graph [KFL01], implemented in libDAI by the FactorGraph class.

Consider a probability distribution over $N$ discrete random variables $x_0,x_1,\dots,x_{N-1}$ that factorizes as a product of $M$ factors, each of which depends on some subset of the variables:

\[ P(x_0,x_1,\dots,x_{N-1}) = \frac{1}{Z} \prod_{I=0}^{M-1} f_I(x_I), \qquad Z = \sum_{x_0}\dots\sum_{x_{N-1}} \prod_{I=0}^{M-1} f_I(X_I). \]

Each factor $f_I$ is a function from an associated subset of variables $X_I \subset \{x_0,x_1,\dots,x_{N-1}\}$ to the nonnegative real numbers.

For a Bayesian network, each factor corresponds to a (conditional) probability table, whereas for a Markov random field, each factor corresponds to a maximal clique of the undirected graph.

Factor graphs explicitly express the factorization structure of the corresponding probability distribution. A factor graph is a bipartite graph, containing variable nodes and factor nodes, and an edge between a variable node and a factor node if the corresponding factor depends on that variable. In libDAI, this structure is represented by a BipartiteGraph.

So basically, a FactorGraph consists of a BipartiteGraph, a vector of Var 's and a vector of TFactor 's.

Idea:
Alternative implementation of undo factor changes: the only things that have to be undone currently are setting a factor to 1 and setting a factor to a Kronecker delta. This could also be implemented in the TFactor itself, which could maintain its state (ones/delta/full) and act accordingly. Update: it seems that the proposed functionality would not be enough for CBP, for which it would make more sense to add more levels of backup/restore.
Examples:

example.cpp, example_sprinkler.cpp, example_sprinkler_em.cpp, and example_sprinkler_gibbs.cpp.

Member Typedef Documentation

typedef BipartiteGraph::Neighbor dai::FactorGraph::Neighbor

Shorthand for BipartiteGraph::Neighbor.

typedef BipartiteGraph::Neighbors dai::FactorGraph::Neighbors

Shorthand for BipartiteGraph::Neighbors.

typedef BipartiteGraph::Edge dai::FactorGraph::Edge

Shorthand for BipartiteGraph::Edge.

typedef std::vector<Factor>::iterator dai::FactorGraph::iterator

Iterator over factors.

typedef std::vector<Factor>::const_iterator dai::FactorGraph::const_iterator

Constant iterator over factors.

Constructor & Destructor Documentation

dai::FactorGraph::FactorGraph (  )  [inline]

Default constructor.

dai::FactorGraph::FactorGraph ( const std::vector< Factor > &  P  ) 

Constructs a factor graph from a vector of factors.

template<typename FactorInputIterator, typename VarInputIterator>
dai::FactorGraph::FactorGraph ( FactorInputIterator  fact_begin,
FactorInputIterator  fact_end,
VarInputIterator  var_begin,
VarInputIterator  var_end,
size_t  nr_fact_hint = 0,
size_t  nr_var_hint = 0 
) [inline]

Constructs a factor graph from given factor and variable iterators.

Template Parameters:
FactorInputIterator Iterates over instances of type dai::Factor
VarInputIterator Iterates over instances of type Var
Precondition:
Assumes that the set of variables in [var_begin, var_end) is the union of the variables in the factors in [fact_begin, fact_end)

virtual dai::FactorGraph::~FactorGraph (  )  [inline, virtual]

Destructor.

Member Function Documentation

virtual FactorGraph* dai::FactorGraph::clone (  )  const [inline, virtual]

Virtual copy constructor.

Reimplemented in dai::RegionGraph.

const Var& dai::FactorGraph::var ( size_t  i  )  const [inline]

Returns constant reference the i 'th variable.

Examples:
example.cpp, and example_sprinkler_gibbs.cpp.

const std::vector<Var>& dai::FactorGraph::vars (  )  const [inline]

Returns constant reference to all variables.

Factor& dai::FactorGraph::factor ( size_t  I  )  [inline]

Returns reference to I 'th factor.

Examples:
example.cpp, and example_sprinkler.cpp.

const Factor& dai::FactorGraph::factor ( size_t  I  )  const [inline]

Returns constant reference to I 'th factor.

const std::vector<Factor>& dai::FactorGraph::factors (  )  const [inline]

Returns constant reference to all factors.

const Neighbors& dai::FactorGraph::nbV ( size_t  i  )  const [inline]

Returns constant reference to neighbors of the i 'th variable.

const Neighbors& dai::FactorGraph::nbF ( size_t  I  )  const [inline]

Returns constant reference to neighbors of the I 'th factor.

const Neighbor& dai::FactorGraph::nbV ( size_t  i,
size_t  _I 
) const [inline]

Returns constant reference to the _I 'th neighbor of the i 'th variable.

const Neighbor& dai::FactorGraph::nbF ( size_t  I,
size_t  _i 
) const [inline]

Returns constant reference to the _i 'th neighbor of the I 'th factor.

iterator dai::FactorGraph::begin (  )  [inline]

Returns iterator pointing to first factor.

const_iterator dai::FactorGraph::begin (  )  const [inline]

Returns constant iterator pointing to first factor.

iterator dai::FactorGraph::end (  )  [inline]

Returns iterator pointing beyond last factor.

const_iterator dai::FactorGraph::end (  )  const [inline]

Returns constant iterator pointing beyond last factor.

size_t dai::FactorGraph::nrVars (  )  const [inline]

Returns number of variables.

Examples:
example.cpp, example_sprinkler.cpp, and example_sprinkler_gibbs.cpp.

size_t dai::FactorGraph::nrFactors (  )  const [inline]

Returns number of factors.

Examples:
example.cpp, example_sprinkler.cpp, and example_sprinkler_gibbs.cpp.

size_t dai::FactorGraph::nrEdges (  )  const [inline]

Calculates number of edges.

Note:
Time complexity: O(nrVars())

size_t dai::FactorGraph::findVar ( const Var &  n  )  const [inline]

Returns the index of a particular variable.

Note:
Time complexity: O(nrVars())
Exceptions:
OBJECT_NOT_FOUND if the variable is not part of this factor graph

std::set<size_t> dai::FactorGraph::findVars ( VarSet &  ns  )  const [inline]

Returns a set of indexes corresponding to a set of variables.

Note:
Time complexity: O( nrVars() * ns.size() )
Exceptions:
OBJECT_NOT_FOUND if one of the variables is not part of this factor graph

size_t dai::FactorGraph::findFactor ( const VarSet &  ns  )  const [inline]

Returns index of the first factor that depends on the variables.

Note:
Time complexity: O(nrFactors())
Exceptions:
OBJECT_NOT_FOUND if no factor in this factor graph depends on those variables

VarSet dai::FactorGraph::Delta ( size_t  i  )  const

Return all variables that occur in a factor involving the i 'th variable, itself included.

VarSet dai::FactorGraph::Delta ( const VarSet &  vs  )  const

Return all variables that occur in a factor involving some variable in vs, vs itself included.

VarSet dai::FactorGraph::delta ( size_t  i  )  const

Return all variables that occur in a factor involving the i 'th variable, itself excluded.

VarSet dai::FactorGraph::delta ( const VarSet &  vs  )  const [inline]

Return all variables that occur in a factor involving some variable in vs, vs itself excluded.

bool dai::FactorGraph::isConnected (  )  const [inline]

Returns true if the factor graph is connected.

bool dai::FactorGraph::isTree (  )  const [inline]

Returns true if the factor graph is a tree (i.e., has no cycles and is connected).

bool dai::FactorGraph::isPairwise (  )  const

Returns true if each factor depends on at most two variables.

bool dai::FactorGraph::isBinary (  )  const

Returns true if each variable has only two possible values.

vector< VarSet > dai::FactorGraph::Cliques (  )  const

Returns the cliques (fully connected subgraphs of the corresponding Markov graph) in this factor graph.

virtual void dai::FactorGraph::setFactor ( size_t  I,
const Factor &  newFactor,
bool  backup = false 
) [inline, virtual]

Set the content of the I 'th factor and make a backup of its old content if backup == true.

Reimplemented in dai::RegionGraph.

virtual void dai::FactorGraph::setFactors ( const std::map< size_t, Factor > &  facs,
bool  backup = false 
) [inline, virtual]

Set the contents of all factors as specified by facs and make a backup of the old contents if backup == true.

Reimplemented in dai::RegionGraph.

void dai::FactorGraph::backupFactor ( size_t  I  ) 

Makes a backup of the I 'th factor.

Exceptions:
MULTIPLE_UNDO if a backup already exists

Reimplemented in dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

void dai::FactorGraph::restoreFactor ( size_t  I  ) 

Restores the I 'th factor from the backup (it should be backed up first).

Reimplemented in dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

void dai::FactorGraph::backupFactors ( const std::set< size_t > &  facs  )  [virtual]

Backup the factors specified by indices in facs.

Exceptions:
MULTIPLE_UNDO if a backup already exists

void dai::FactorGraph::restoreFactors (  )  [virtual]

Restore all factors to the backup copies.

void dai::FactorGraph::backupFactors ( const VarSet &  ns  ) 

Makes a backup of all factors connected to a set of variables.

Exceptions:
MULTIPLE_UNDO if a backup already exists

Reimplemented in dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

void dai::FactorGraph::restoreFactors ( const VarSet &  ns  ) 

Restores all factors connected to a set of variables from their backups.

Reimplemented in dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

FactorGraph dai::FactorGraph::maximalFactors (  )  const

Returns a copy of *this, where all factors that are subsumed by some larger factor are merged with the larger factors.

FactorGraph dai::FactorGraph::clamped ( size_t  i,
size_t  x 
) const

Clamp the i 'th variable to value x (i.e. multiply with a Kronecker delta $\delta_{x_i,x}$);.

Note:
This version changes the factor graph structure and thus returns a newly constructed FactorGraph and keeps the current one constant, contrary to clamp()

void dai::FactorGraph::clamp ( size_t  i,
size_t  x,
bool  backup = false 
) [virtual]

Clamp the i 'th variable to value x (i.e. multiply with a Kronecker delta $\delta_{x_i, x}$).

If backup == true, make a backup of all factors that are changed

Reimplemented in dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

void dai::FactorGraph::clampVar ( size_t  i,
const std::vector< size_t > &  xis,
bool  backup = false 
)

Clamp a variable in a factor graph to have one out of a list of values.

If backup == true, make a backup of all factors that are changed

void dai::FactorGraph::clampFactor ( size_t  I,
const std::vector< size_t > &  xIs,
bool  backup = false 
)

Clamp a factor in a factor graph to have one out of a list of values.

If backup == true, make a backup of all factors that are changed

void dai::FactorGraph::makeCavity ( size_t  i,
bool  backup = false 
) [virtual]

Set all factors interacting with the i 'th variable to 1.

If backup == true, make a backup of all factors that are changed

Reimplemented in dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

void dai::FactorGraph::ReadFromFile ( const char *  filename  ) 

Reads a factor graph from a file.

See also:
Factor graph (.fg) file format
Exceptions:
CANNOT_READ_FILE if the file cannot be opened
INVALID_FACTORGRAPH_FILE if the file is not valid
Examples:
example.cpp, example_sprinkler_em.cpp, and example_sprinkler_gibbs.cpp.

void dai::FactorGraph::WriteToFile ( const char *  filename,
size_t  precision = 15 
) const

Writes a factor graph to a file.

See also:
Factor graph (.fg) file format
Exceptions:
CANNOT_WRITE_FILE if the file cannot be written
Examples:
example_sprinkler.cpp.

void dai::FactorGraph::printDot ( std::ostream &  os  )  const

Writes a factor graph to a GraphViz .dot file.

void dai::FactorGraph::constructGraph ( size_t  nrEdges  )  [private]

Part of constructors (creates edges, neighbors and adjacency matrix).

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os,
const FactorGraph &  fg 
) [friend]

Writes a factor graph to an output stream.

See also:
Factor graph (.fg) file format

std::istream& operator>> ( std::istream &  is,
FactorGraph &  fg 
) [friend]

Reads a factor graph from an input stream.

See also:
Factor graph (.fg) file format
Exceptions:
INVALID_FACTORGRAPH_FILE if the input stream is not valid

Member Data Documentation

BipartiteGraph dai::FactorGraph::G

Stores the neighborhood structure.

Reimplemented in dai::RegionGraph.

std::vector<Var> dai::FactorGraph::_vars [private]

Stores the variables.

std::vector<Factor> dai::FactorGraph::_factors [private]

Stores the factors.

std::map<size_t,Factor> dai::FactorGraph::_backup [private]

Stores backups of some factors.

The documentation for this class was generated from the following files:
Generated on Thu Feb 11 12:26:04 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_func_0x61.html0000644000263000017630000001516611334764772017704 0ustar jorismkyb libDAI: Class Members - Functions
 

- a -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/enum_8h.html0000644000263000017630000000766211334764772015450 0ustar jorismkyb libDAI: include/dai/enum.h File Reference

include/dai/enum.h File Reference

Defines the DAI_ENUM macro, which can be used to define an enum with additional functionality. More...

#include <cstring>
#include <iostream>
#include <dai/exceptions.h>

Go to the source code of this file.

Defines

#define DAI_ENUM(x, val0,...)
 Extends the C++ enum type by supporting input/output streaming and conversion to and from const char* and size_t.

Detailed Description

Defines the DAI_ENUM macro, which can be used to define an enum with additional functionality.

Define Documentation

#define DAI_ENUM ( x,
val0,
...   ) 

Extends the C++ enum type by supporting input/output streaming and conversion to and from const char* and size_t.

For more details see the source code.

Example:
  DAI_ENUM(colors,RED,GREEN,BLUE)
defines a class colors encapsulating an 
  enum {RED, GREEN, BLUE};
which offers additional functionality over the plain enum keyword.

Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/properties_8h.html0000644000263000017630000001124011334764772016663 0ustar jorismkyb libDAI: include/dai/properties.h File Reference

include/dai/properties.h File Reference

Defines the Property and PropertySet classes, which are mainly used for managing parameters of inference algorithms. More...

#include <iostream>
#include <sstream>
#include <boost/any.hpp>
#include <map>
#include <vector>
#include <typeinfo>
#include <dai/exceptions.h>
#include <dai/util.h>
#include <boost/lexical_cast.hpp>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::PropertySet
 Represents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue). More...

Typedefs

typedef std::string dai::PropertyKey
 Type of the key of a Property.
typedef boost::any dai::PropertyValue
 Type of the value of a Property.
typedef std::pair< PropertyKey,
PropertyValue > 		dai::Property
 A Property is a pair of a key and a corresponding value.

Functions

std::ostream & dai::operator<< (std::ostream &os, const Property &p)
 Writes a Property object (key-value pair) to an output stream.

Detailed Description

Defines the Property and PropertySet classes, which are mainly used for managing parameters of inference algorithms.

Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1GraphAL-members.html0000644000263000017630000001573411334764772021156 0ustar jorismkyb libDAI: Member List

dai::GraphAL Member List

This is the complete list of members for dai::GraphAL, including all inherited members.

_nbdai::GraphAL [private]
addEdge(size_t n1, size_t n2, bool check=true)dai::GraphAL
addNode()dai::GraphAL [inline]
addNode(NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0)dai::GraphAL [inline]
checkConsistency() const dai::GraphAL
construct(size_t nr, EdgeInputIterator begin, EdgeInputIterator end)dai::GraphAL [inline]
Edge typedefdai::GraphAL
eraseEdge(size_t n1, size_t n2)dai::GraphAL
eraseNode(size_t n)dai::GraphAL
GraphAL()dai::GraphAL [inline]
GraphAL(size_t nr)dai::GraphAL [inline]
GraphAL(size_t nr, EdgeInputIterator begin, EdgeInputIterator end)dai::GraphAL [inline]
isConnected() const dai::GraphAL
isTree() const dai::GraphAL
levelType typedefdai::GraphAL [private]
nb(size_t n1, size_t _n2) const dai::GraphAL [inline]
nb(size_t n1, size_t _n2)dai::GraphAL [inline]
nb(size_t n) const dai::GraphAL [inline]
nb(size_t n)dai::GraphAL [inline]
Neighbors typedefdai::GraphAL
nrEdges() const dai::GraphAL [inline]
nrNodes() const dai::GraphAL [inline]
printDot(std::ostream &os) const dai::GraphAL

Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1fo__Hellinger.html0000644000263000017630000000777311334764772021227 0ustar jorismkyb libDAI: dai::fo_Hellinger< T > Struct Template Reference

dai::fo_Hellinger< T > Struct Template Reference

Function object useful for calculating the Hellinger distance. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &p, const T &q) const
 Returns (sqrt(p) - sqrt(q))^2.

Detailed Description

template<typename T>
struct dai::fo_Hellinger< T >

Function object useful for calculating the Hellinger distance.

Member Function Documentation

template<typename T>
T dai::fo_Hellinger< T >::operator() ( const T &  p,
const T &  q 
) const [inline]

Returns (sqrt(p) - sqrt(q))^2.

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/regiongraph_8h.html0000644000263000017630000001020711334764772016776 0ustar jorismkyb libDAI: include/dai/regiongraph.h File Reference

include/dai/regiongraph.h File Reference

Defines classes Region, FRegion and RegionGraph, which implement a particular subclass of region graphs. More...

#include <iostream>
#include <dai/bipgraph.h>
#include <dai/factorgraph.h>
#include <dai/weightedgraph.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::Region
 A Region is a set of variables with a counting number. More...
class  dai::FRegion
 An FRegion is a factor with a counting number. More...
class  dai::RegionGraph
 A RegionGraph combines a bipartite graph consisting of outer regions (type FRegion) and inner regions (type Region) with a FactorGraph. More...

Detailed Description

Defines classes Region, FRegion and RegionGraph, which implement a particular subclass of region graphs.

Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_func_0x6e.html0000644000263000017630000001710311334764773017762 0ustar jorismkyb libDAI: Class Members - Functions
 

- n -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1MR.html0000644000263000017630000022111611334764773016560 0ustar jorismkyb libDAI: dai::MR Class Reference

dai::MR Class Reference

Approximate inference algorithm by Montanari and Rizzo [MoR05]. More...

#include <dai/mr.h>

Inheritance diagram for dai::MR:

dai::DAIAlg< GRM > dai::InfAlg

List of all members.

Public Member Functions

 MR ()
 Default constructor.
 MR (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts.
General InfAlg interface
virtual MR * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
virtual std::string identify () const
 Identifies itself for logging purposes.
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable.
virtual Factor belief (const VarSet &) const
 Returns the (approximate) marginal probability distribution of a set of variables.
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i.
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).
virtual void init ()
 Initializes all data structures of the approximate inference algorithm.
virtual void init (const VarSet &)
 Initializes all data structures corresponding to some set of variables.
virtual Real run ()
 Runs the approximate inference algorithm.
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration.
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph).
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm.
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet.
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Public Attributes

struct dai::MR::Properties props

Static Public Attributes

static const char * Name = "MR"
 Name of this inference method.

Private Types

typedef boost::dynamic_bitset sub_nb
 Type used for managing a subset of neighbors.

Private Member Functions

Real sign (Real a)
 Returns the signum of a.
void init (size_t Nin, Real *_w, Real *_th)
 Initialize N, con, nb, tJ, theta.
void makekindex ()
 Initialize kindex.
Real init_cor ()
 Initialize cors.
Real init_cor_resp ()
 Calculate cors using response propagation.
void solvemcav ()
 Iterate update equations for cavity fields.
void solveM ()
 Calculate magnetizations.
Real _tJ (size_t i, sub_nb A)
 Calculate the product of all tJ[i][_j] for _j in A.
Real Omega (size_t i, size_t _j, size_t _l)
 Calculate $ \Omega^{(i)}_{j,l} $ as defined in [MoR05] eqn. (2.15).
Real T (size_t i, sub_nb A)
 Calculate $ T^{(i)}_A $ as defined in [MoR05] eqn. (2.17) with $ A = \{l_1,l_2,\dots\} $.
Real T (size_t i, size_t _j)
 Calculates $ T^{(i)}_j $ where j is the _j 'th neighbor of i.
Real Gamma (size_t i, size_t _j, size_t _l1, size_t _l2)
 Calculates $ \Gamma^{(i)}_{j,l_1l_2} $ as defined in [MoR05] eqn. (2.16).
Real Gamma (size_t i, size_t _l1, size_t _l2)
 Calculates $ \Gamma^{(i)}_{l_1l_2} $ as defined in [MoK07] on page 1141.
Real appM (size_t i, sub_nb A)
 Approximates moments of variables in A.
void sum_subs (size_t j, sub_nb A, Real *sum_even, Real *sum_odd)
 Calculate sum over all even/odd subsets B of A of _tJ(j,B) appM(j,B).

Private Attributes

bool supported
 Is the underlying factor graph supported?
std::vector< size_t > con
 con[i] = connectivity of spin i
std::vector< std::vector
< size_t > > 		nb
 nb[i] are the neighbours of spin i
std::vector< std::vector< Real > > tJ
 tJ[i][_j] is the hyperbolic tangent of the interaction between spin i and its neighbour nb[i][_j]
std::vector< Real > theta
 theta[i] is the local field on spin i
std::vector< std::vector< Real > > M
 M[i][_j] is $ M^{(i)}_j $.
std::vector< std::vector
< size_t > > 		kindex
 The _j 'th neighbour of spin i has spin i as its kindex[i][_j]'th neighbour.
std::vector< std::vector
< std::vector< Real > > > 		cors
 Cavity correlations.
size_t N
 Number of variables (spins).
std::vector< Real > Mag
 Magnetizations.
Real _maxdiff
 Maximum difference encountered so far.
size_t _iters
 Number of iterations needed.

Static Private Attributes

static const size_t kmax = 31
 Maximum connectivity.

Classes

struct  Properties
 Parameters for MR. More...

Detailed Description

Approximate inference algorithm by Montanari and Rizzo [MoR05].

Author:
Bastian Wemmenhove wrote the original implementation before it was merged into libDAI
Todo:
Clean up code (use a BipartiteGraph-like implementation for the graph structure, and BBP for response propagation).

Member Typedef Documentation

typedef boost::dynamic_bitset dai::MR::sub_nb [private]

Type used for managing a subset of neighbors.

Constructor & Destructor Documentation

dai::MR::MR (  )  [inline]

Default constructor.

dai::MR::MR ( const FactorGraph &  fg,
const PropertySet &  opts 
)

Construct from FactorGraph fg and PropertySet opts.

Parameters:
opts Parameters
See also:
Properties
Note:
This implementation only deals with binary variables and pairwise interactions.
Exceptions:
NOT_IMPLEMENTED if fg has factors depending on three or more variables or has variables with more than two possible states.

Member Function Documentation

virtual MR* dai::MR::clone (  )  const [inline, virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Implements dai::InfAlg.

string dai::MR::identify (  )  const [virtual]

Identifies itself for logging purposes.

Implements dai::InfAlg.

virtual Factor dai::MR::belief ( const Var &  v  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of a variable.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

virtual Factor dai::MR::belief ( const VarSet &  vs  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of a set of variables.

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported.
BELIEF_NOT_AVAILABLE if the requested belief cannot be calculated with this algorithm.

Implements dai::InfAlg.

Factor dai::MR::beliefV ( size_t  i  )  const [virtual]

Returns the (approximate) marginal probability distribution of the variable with index i.

For some approximate inference algorithms, using beliefV() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

vector< Factor > dai::MR::beliefs (  )  const [virtual]

Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.

Note:
Before this method is called, run() should have been called.

Implements dai::InfAlg.

virtual Real dai::MR::logZ (  )  const [inline, virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

virtual void dai::MR::init (  )  [inline, virtual]

Initializes all data structures of the approximate inference algorithm.

Note:
This method should be called at least once before run() is called.

Implements dai::InfAlg.

virtual void dai::MR::init ( const VarSet &  vs  )  [inline, virtual]

Initializes all data structures corresponding to some set of variables.

This method can be used to do a partial initialization after a part of the factor graph has changed. Instead of initializing all data structures, it only initializes those involving the variables in vs.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

Real dai::MR::run (  )  [virtual]

Runs the approximate inference algorithm.

Note:
Before run() is called the first time, init() should have been called.

Implements dai::InfAlg.

virtual Real dai::MR::maxDiff (  )  const [inline, virtual]

Returns maximum difference between single variable beliefs in the last iteration.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

virtual size_t dai::MR::Iterations (  )  const [inline, virtual]

Returns number of iterations done (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

void dai::MR::setProperties ( const PropertySet &  opts  )  [virtual]

Set parameters of this inference algorithm.

The parameters are set according to the PropertySet opts. The values can be stored either as std::string or as the type of the corresponding MF::props member.

Implements dai::InfAlg.

PropertySet dai::MR::getProperties (  )  const [virtual]

Returns parameters of this inference algorithm converted into a PropertySet.

Implements dai::InfAlg.

string dai::MR::printProperties (  )  const [virtual]

Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Implements dai::InfAlg.

Real dai::MR::sign ( Real  a  )  [inline, private]

Returns the signum of a.

void dai::MR::init ( size_t  Nin,
Real *  _w,
Real *  _th 
) [private]

Initialize N, con, nb, tJ, theta.

void dai::MR::makekindex (  )  [private]

Initialize kindex.

Real dai::MR::init_cor (  )  [private]

Initialize cors.

Real dai::MR::init_cor_resp (  )  [private]

Calculate cors using response propagation.

void dai::MR::solvemcav (  )  [private]

Iterate update equations for cavity fields.

void dai::MR::solveM (  )  [private]

Calculate magnetizations.

Real dai::MR::_tJ ( size_t  i,
sub_nb  A 
) [private]

Calculate the product of all tJ[i][_j] for _j in A.

Parameters:
i variable index
A subset of neighbors of variable i

Real dai::MR::Omega ( size_t  i,
size_t  _j,
size_t  _l 
) [private]

Calculate $ \Omega^{(i)}_{j,l} $ as defined in [MoR05] eqn. (2.15).

Real dai::MR::T ( size_t  i,
sub_nb  A 
) [private]

Calculate $ T^{(i)}_A $ as defined in [MoR05] eqn. (2.17) with $ A = \{l_1,l_2,\dots\} $.

Parameters:
i variable index
A subset of neighbors of variable i

Real dai::MR::T ( size_t  i,
size_t  _j 
) [private]

Calculates $ T^{(i)}_j $ where j is the _j 'th neighbor of i.

Real dai::MR::Gamma ( size_t  i,
size_t  _j,
size_t  _l1,
size_t  _l2 
) [private]

Calculates $ \Gamma^{(i)}_{j,l_1l_2} $ as defined in [MoR05] eqn. (2.16).

Real dai::MR::Gamma ( size_t  i,
size_t  _l1,
size_t  _l2 
) [private]

Calculates $ \Gamma^{(i)}_{l_1l_2} $ as defined in [MoK07] on page 1141.

Real dai::MR::appM ( size_t  i,
sub_nb  A 
) [private]

Approximates moments of variables in A.

Calculate the moment of variables in A from M and cors, neglecting higher order cumulants, defined as the sum over all partitions of A into subsets of cardinality two at most of the product of the cumulants (either first order, i.e. M, or second order, i.e. cors) of the entries of the partitions.

Parameters:
i variable index
A subset of neighbors of variable i

void dai::MR::sum_subs ( size_t  j,
sub_nb  A,
Real *  sum_even,
Real *  sum_odd 
) [private]

Calculate sum over all even/odd subsets B of A of _tJ(j,B) appM(j,B).

Parameters:
j variable index
A subset of neighbors of variable j
sum_even on return, will contain the sum over all even subsets
sum_odd on return, will contain the sum over all odd subsets

Member Data Documentation

bool dai::MR::supported [private]

Is the underlying factor graph supported?

std::vector<size_t> dai::MR::con [private]

con[i] = connectivity of spin i

std::vector<std::vector<size_t> > dai::MR::nb [private]

nb[i] are the neighbours of spin i

std::vector<std::vector<Real> > dai::MR::tJ [private]

tJ[i][_j] is the hyperbolic tangent of the interaction between spin i and its neighbour nb[i][_j]

std::vector<Real> dai::MR::theta [private]

theta[i] is the local field on spin i

std::vector<std::vector<Real> > dai::MR::M [private]

M[i][_j] is $ M^{(i)}_j $.

std::vector<std::vector<size_t> > dai::MR::kindex [private]

The _j 'th neighbour of spin i has spin i as its kindex[i][_j]'th neighbour.

std::vector<std::vector<std::vector<Real> > > dai::MR::cors [private]

Cavity correlations.

const size_t dai::MR::kmax = 31 [static, private]

Maximum connectivity.

size_t dai::MR::N [private]

Number of variables (spins).

std::vector<Real> dai::MR::Mag [private]

Magnetizations.

Real dai::MR::_maxdiff [private]

Maximum difference encountered so far.

size_t dai::MR::_iters [private]

Number of iterations needed.

const char * dai::MR::Name = "MR" [static]

Name of this inference method.

The documentation for this class was generated from the following files:
  • include/dai/mr.h
  • src/mr.cpp
Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1Var.html0000644000263000017630000005204111334764773016771 0ustar jorismkyb libDAI: dai::Var Class Reference

dai::Var Class Reference

Represents a discrete random variable. More...

#include <dai/var.h>

List of all members.

Public Member Functions

 Var ()
 Default constructor (creates a variable with label -1 and 0 states).
 Var (size_t label, size_t states)
 Constructs a variable with a given label and number of states.
size_t label () const
 Returns the label.
size_t & label ()
 Returns reference to label.
size_t states () const
 Returns the number of states.
size_t & states ()
 Returns reference to number of states.
bool operator< (const Var &n) const
 Smaller-than operator (only compares labels).
bool operator> (const Var &n) const
 Larger-than operator (only compares labels).
bool operator<= (const Var &n) const
 Smaller-than-or-equal-to operator (only compares labels).
bool operator>= (const Var &n) const
 Larger-than-or-equal-to operator (only compares labels).
bool operator!= (const Var &n) const
 Not-equal-to operator (only compares labels).
bool operator== (const Var &n) const
 Equal-to operator (only compares labels).

Private Attributes

size_t _label
 Label of the variable (its unique ID).
size_t _states
 Number of possible values.

Friends

std::ostream & operator<< (std::ostream &os, const Var &n)
 Writes a Var to an output stream.

Detailed Description

Represents a discrete random variable.

A Var stores the label of the variable (a nonnegative integer-valued unique ID) and the number of possible values (states) of that variable. Two Var objects with the same label are assumed to be identical (i.e., it is assumed that they have the same number of possible states).

In the documentation, we use the following notational conventions. The discrete random variable with label $l$ is denoted as $x_l$, and the number of possible values of this variable as $S_l$; this is represented in code by the object Var($l$,$S_l$). The set of possible values of variable $x_l$ is denoted $X_l := \{0,1,\dots,S_l-1\}$.

Examples:

example_permute.cpp, example_sprinkler.cpp, and example_varset.cpp.

Constructor & Destructor Documentation

dai::Var::Var (  )  [inline]

Default constructor (creates a variable with label -1 and 0 states).

dai::Var::Var ( size_t  label,
size_t  states 
) [inline]

Constructs a variable with a given label and number of states.

Member Function Documentation

size_t dai::Var::label (  )  const [inline]

Returns the label.

Examples:
example_sprinkler_gibbs.cpp.

size_t& dai::Var::label (  )  [inline]

Returns reference to label.

size_t dai::Var::states (  )  const [inline]

Returns the number of states.

Examples:
example_varset.cpp.

size_t& dai::Var::states (  )  [inline]

Returns reference to number of states.

bool dai::Var::operator< ( const Var &  n  )  const [inline]

Smaller-than operator (only compares labels).

bool dai::Var::operator> ( const Var &  n  )  const [inline]

Larger-than operator (only compares labels).

bool dai::Var::operator<= ( const Var &  n  )  const [inline]

Smaller-than-or-equal-to operator (only compares labels).

bool dai::Var::operator>= ( const Var &  n  )  const [inline]

Larger-than-or-equal-to operator (only compares labels).

bool dai::Var::operator!= ( const Var &  n  )  const [inline]

Not-equal-to operator (only compares labels).

bool dai::Var::operator== ( const Var &  n  )  const [inline]

Equal-to operator (only compares labels).

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os,
const Var &  n 
) [friend]

Writes a Var to an output stream.

Member Data Documentation

size_t dai::Var::_label [private]

Label of the variable (its unique ID).

size_t dai::Var::_states [private]

Number of possible values.

The documentation for this class was generated from the following file:
Generated on Thu Feb 11 12:26:08 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1CBP-members.html0000644000263000017630000003105311334764773020275 0ustar jorismkyb libDAI: Member List

dai::CBP Member List

This is the complete list of members for dai::CBP, including all inherited members.

_beliefsFdai::CBP [private]
_beliefsVdai::CBP [private]
_clamp_ofstreamdai::CBP [private]
_itersdai::CBP [private]
_logZdai::CBP [private]
_maxdiffdai::CBP [private]
_num_leavesdai::CBP [private]
_sum_leveldai::CBP [private]
backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
BBPFindClampVar(const InfAlg &in_bp, bool clampingVar, const PropertySet &bbp_props, const BBPCostFunction &cfn, Real *maxVarOut)dai::CBP [related]
belief(const Var &v) const dai::CBP [inline, virtual]
belief(const VarSet &) const dai::CBP [inline, virtual]
beliefF(size_t I) const dai::CBP [inline, virtual]
beliefs() const dai::CBP [inline, virtual]
beliefV(size_t i) const dai::CBP [inline, virtual]
CBP(const FactorGraph &fg, const PropertySet &opts)dai::CBP [inline]
chooseNextClampVar(InfAlg *bp, std::vector< size_t > &clamped_vars_list, size_t &i, std::vector< size_t > &xis, Real *maxVarOut)dai::CBP [private, virtual]
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clone() const dai::CBP [inline, virtual]
construct()dai::CBP [private]
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
getInfAlg()dai::CBP [private]
getProperties() const dai::CBP [inline, virtual]
identify() const dai::CBP [inline, virtual]
init()dai::CBP [inline, virtual]
init(const VarSet &)dai::CBP [inline, virtual]
Iterations() const dai::CBP [inline, virtual]
logZ() const dai::CBP [inline, virtual]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
maxDiff() const dai::CBP [inline, virtual]
Namedai::CBP [static]
printDebugInfo()dai::CBP [private]
printProperties() const dai::CBP [inline, virtual]
props (defined in dai::CBP)dai::CBP
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
run()dai::CBP [virtual]
runRecurse(InfAlg *bp, Real orig_logZ, std::vector< size_t > clamped_vars_list, size_t &num_leaves, size_t &choose_count, Real &sum_level, Real &lz_out, std::vector< Factor > &beliefs_out)dai::CBP [private]
setBeliefs(const std::vector< Factor > &bs, Real logZ)dai::CBP [private]
setProperties(const PropertySet &opts)dai::CBP [inline, virtual]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1fo__max.html0000644000263000017630000000762311334764773020076 0ustar jorismkyb libDAI: dai::fo_max< T > Struct Template Reference

dai::fo_max< T > Struct Template Reference

Function object that returns the maximum of two values. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &x, const T &y) const
 Returns (x > y ? x : y).

Detailed Description

template<typename T>
struct dai::fo_max< T >

Function object that returns the maximum of two values.

Member Function Documentation

template<typename T>
T dai::fo_max< T >::operator() ( const T &  x,
const T &  y 
) const [inline]

Returns (x > y ? x : y).

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_131.png0000644000263000017630000000121611334764773015242 0ustar jorismkybPNG  IHDRr#!C0PLTEppp```PPP@@@000 4tRNS@f IDAT8ݔkpǿ5I?hEjWi.CrNPŒRR ":Hŵ(x/]{pd蹎iKߍ6퐙 ljbD7QrWSv#2G*$?w;z_!=N9CVV['/!ri~1tk~rRiiGnamؔ \> V0dRH]"9ɃKVJ֍'B wyj m\],VBEiB|` 'iu:m<Ζۂѩ<4'8c>ǣ|M݆ݝG[;D% $@gjOגg;aExD.eHW=|Tw'H9kDV@lJ^b잚+2{S5Td:OwGg1Z_\18SMƓBkD{b/}Z>IENDB`libDAI-0.2.4/doc/html/license.html0000644000263000017630000004670311334764773015527 0ustar jorismkyb libDAI: License

License

License

libDAI is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

libDAI is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

GNU General Public License version 2

		    GNU GENERAL PUBLIC LICENSE
		       Version 2, June 1991

 Copyright (C) 1989, 1991 Free Software Foundation, Inc.
                       51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

			    Preamble

  The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users.  This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it.  (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.)  You can apply it to
your programs, too.

  When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.

  To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.

  For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have.  You must make sure that they, too, receive or can get the
source code.  And you must show them these terms so they know their
rights.

  We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.

  Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software.  If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.

  Finally, any free program is threatened constantly by software
patents.  We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary.  To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.

  The precise terms and conditions for copying, distribution and
modification follow.

		    GNU GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

  0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License.  The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language.  (Hereinafter, translation is included without limitation in
the term "modification".)  Each licensee is addressed as "you".

Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope.  The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.

  1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.

You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.

  2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:

    a) You must cause the modified files to carry prominent notices
    stating that you changed the files and the date of any change.

    b) You must cause any work that you distribute or publish, that in
    whole or in part contains or is derived from the Program or any
    part thereof, to be licensed as a whole at no charge to all third
    parties under the terms of this License.

    c) If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an
    announcement including an appropriate copyright notice and a
    notice that there is no warranty (or else, saying that you provide
    a warranty) and that users may redistribute the program under
    these conditions, and telling the user how to view a copy of this
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based on
    the Program is not required to print an announcement.)

These requirements apply to the modified work as a whole.  If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works.  But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.

Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.

In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.

  3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:

    a) Accompany it with the complete corresponding machine-readable
    source code, which must be distributed under the terms of Sections
    1 and 2 above on a medium customarily used for software interchange; or,

    b) Accompany it with a written offer, valid for at least three
    years, to give any third party, for a charge no more than your
    cost of physically performing source distribution, a complete
    machine-readable copy of the corresponding source code, to be
    distributed under the terms of Sections 1 and 2 above on a medium
    customarily used for software interchange; or,

    c) Accompany it with the information you received as to the offer
    to distribute corresponding source code.  (This alternative is
    allowed only for noncommercial distribution and only if you
    received the program in object code or executable form with such
    an offer, in accord with Subsection b above.)

The source code for a work means the preferred form of the work for
making modifications to it.  For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable.  However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.

If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.

  4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License.  Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.

  5. You are not required to accept this License, since you have not
signed it.  However, nothing else grants you permission to modify or
distribute the Program or its derivative works.  These actions are
prohibited by law if you do not accept this License.  Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.

  6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions.  You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.

  7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all.  For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.

If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.

It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices.  Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.

This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.

  8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded.  In such case, this License incorporates
the limitation as if written in the body of this License.

  9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time.  Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.

Each version is given a distinguishing version number.  If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation.  If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.

  10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission.  For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this.  Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.

			    NO WARRANTY

  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.

  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.

		     END OF TERMS AND CONDITIONS

	    How to Apply These Terms to Your New Programs

  If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.

  To do so, attach the following notices to the program.  It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.

    <one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA


Also add information on how to contact you by electronic and paper mail.

If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:

    Gnomovision version 69, Copyright (C) year name of author
    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.

The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License.  Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.

You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary.  Here is a sample; alter the names:

  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
  `Gnomovision' (which makes passes at compilers) written by James Hacker.

  <signature of Ty Coon>, 1 April 1989
  Ty Coon, President of Vice

This General Public License does not permit incorporating your program into
proprietary programs.  If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library.  If this is what you want to do, use the GNU Library General
Public License instead of this License.
Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1DAIAlg.png0000644000263000017630000000330111334764773017075 0ustar jorismkybPNG  IHDRHohg=PLTE`{tRNS@fWIDATxan8Ea P@dK)銔cNJ$9M8_9U}>џ~W @Cx݄^MiKx.CC|ś>;q#mQsK- rK~4'"*Ï;f츟D}n7 {#L?Wy '_ F6vL @( @( @:! |3mιSS nx[WK"#a+,-W_"D>4!XDnEl^DCW.G3HOώ"⇁KBP BP BP BP L$q5y 8{?m{aF,ЍLz:\\Cw4)Ѝbk"aFlrl^tnHk&Dn?cώw@X8/BP BP BP BPσ0q" V!e>UW^>L㹚EZ㏛3::F55EqJzg6[o]?NG[DT~ff[c !@( @( @( @( z$6N/V!X+OyD6UZqTTtb5D@h*RsTtu_u9mȧ 1^]@BX8paqѶCҁP BP BP BP <'I^<&wBkNC"[H(j-ݻ3⢈t!t["Z{[mOZqBĺ@ @( @( @( @(y&N8]Jb,ҩݝ?]76CcYmƢޅĥX|=͵sXtbǖǢVFcfՁKBP BP BP BP L$q/s}^N\>\\t+й/ǪVE#nE#Vw@< Q{2IENDB`libDAI-0.2.4/doc/html/form_136.png0000644000263000017630000000052511334764773015251 0ustar jorismkybPNG  IHDR7@\0PLTEppp```PPP@@@000 4tRNS@fIDATc` q@(flt#&B(XJKH<g @@6\C?H>Vk82gΜ9&߀H}d`D)h(,J^gXG@j5df~^k9 A (8d` >2l8n) jIENDB`libDAI-0.2.4/doc/html/classdai_1_1multifor-members.html0000644000263000017630000000772411334764773021542 0ustar jorismkyb libDAI: Member List

dai::multifor Member List

This is the complete list of members for dai::multifor, including all inherited members.

_indicesdai::multifor [private]
_linear_indexdai::multifor [private]
_rangesdai::multifor [private]
multifor()dai::multifor [inline]
multifor(const std::vector< size_t > &d)dai::multifor [inline]
operator size_t() const dai::multifor [inline]
operator++()dai::multifor [inline]
operator++(int)dai::multifor [inline]
operator[](size_t k) const dai::multifor [inline]
valid() const dai::multifor [inline]

Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/index.html0000644000263000017630000001506011334764773015204 0ustar jorismkyb libDAI: Reference manual for libDAI - A free/open source C++ library for Discrete Approximate Inference methods

Reference manual for libDAI - A free/open source C++ library for Discrete Approximate Inference methods

Author:
Joris Mooij, Frederik Eaton
Version:
0.2.4
Date:
February 11, 2010

About libDAI

libDAI is a free/open source C++ library (licensed under GPL 2+) that provides implementations of various (approximate) inference methods for discrete graphical models. libDAI supports arbitrary factor graphs with discrete variables; this includes discrete Markov Random Fields and Bayesian Networks.

The library is targeted at researchers. To be able to use the library, a good understanding of graphical models is needed.

The best way to use libDAI is by writing C++ code that invokes the library; in addition, part of the functionality is accessibly by using the

  • command line interface
  • (limited) MatLab interface
  • (experimental) python interface
  • (experimental) octave interface.

libDAI can be used to implement novel (approximate) inference algorithms and to easily compare the accuracy and performance with existing algorithms that have been implemented already.

Features

Currently, libDAI supports the following (approximate) inference methods:
  • Exact inference by brute force enumeration;
  • Exact inference by junction-tree methods;
  • Mean Field;
  • Loopy Belief Propagation [KFL01];
  • Fractional Belief Propagation [WiH03];
  • Tree-Reweighted Belief Propagation [WJW03];
  • Tree Expectation Propagation [MiQ04];
  • Generalized Belief Propagation [YFW05];
  • Double-loop GBP [HAK03];
  • Various variants of Loop Corrected Belief Propagation [MoK07, MoR05];
  • Gibbs sampler;
  • Conditioned Belief Propagation [EaG09].

These inference methods can be used to calculate partition sums, marginals over subsets of variables, and MAP states (the joint state of variables that has maximum probability).

In addition, libDAI supports parameter learning of conditional probability tables by Expectation Maximization.

Limitations

libDAI is not intended to be a complete package for approximate inference. Instead, it should be considered as an "inference engine", providing various inference methods. In particular, it contains no GUI, currently only supports its own file format for input and output (although support for standard file formats may be added later), and provides very limited visualization functionalities. The only learning method supported currently is Expectation Maximization (or Maximum Likelihood if no data is missing) for learning factor parameters.

Rationale

In my opinion, the lack of open source "reference" implementations hampers progress in research on approximate inference. Methods differ widely in terms of quality and performance characteristics, which also depend in different ways on various properties of the graphical models. Finding the best approximate inference method for a particular application therefore often requires empirical comparisons. However, implementing and debugging these methods takes a lot of time which could otherwise be spent on research. I hope that this code will aid researchers to be able to easily compare various (existing as well as new) approximate inference methods, in this way accelerating research and stimulating real-world applications of approximate inference.

Language

Because libDAI is implemented in C++, it is very fast compared with implementations in MatLab (a factor 1000 faster is not uncommon). libDAI does provide a (limited) MatLab interface for easy integration with MatLab. It also provides a command line interface and experimental python and octave interfaces (thanks to Patrick Pletscher).

Compatibility

The code has been developed under Debian GNU/Linux with the GCC compiler suite. libDAI compiles successfully with g++ versions 3.4, 4.1, 4.2 and 4.3.

libDAI has also been successfully compiled with MS Visual Studio 2008 under Windows (but not all build targets are supported yet) and with Cygwin under Windows.

Finally, libDAI has been compiled successfully on MacOS X.

Downloading libDAI

The libDAI sources and documentation can be downloaded from the libDAI website: http://www.libdai.org.

Mailing list

The Google group "libDAI" (http://groups.google.com/group/libdai) can be used for getting support and discussing development issues.
Generated on Thu Feb 11 12:25:58 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/annotated.html0000644000263000017630000005630711334764773016063 0ustar jorismkyb libDAI: Class List

Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
dai::BBPImplements BBP (Back-Belief-Propagation) [EaG09]
dai::BBP::PropertiesParameters for BBP
dai::BBPCostFunctionPredefined cost functions that can be used with BBP
dai::BipartiteGraphRepresents the neighborhood structure of nodes in an undirected, bipartite graph
dai::BipartiteGraph::levelTypeUsed internally by isTree()
dai::BipartiteGraph::NeighborDescribes the neighbor relationship of two nodes in a BipartiteGraph
dai::BPApproximate inference algorithm "(Loopy) Belief Propagation"
dai::BP::EdgePropType used for storing edge properties
dai::BP::PropertiesParameters for BP
dai::BP_dualCalculates both types of BP messages and their normalizers from an InfAlg
dai::BP_dual::_edges_t< T >Convenience label for storing edge properties
dai::BP_dual::beliefsGroups together the data structures for storing the two types of beliefs and their normalizers
dai::BP_dual::messagesGroups together the data structures for storing the two types of messages and their normalizers
dai::CBPClass for CBP (Conditioned Belief Propagation) [EaG09]
dai::CBP::PropertiesParameters for CBP
dai::ClusterGraphA ClusterGraph is a hypergraph with variables as nodes, and "clusters" (sets of variables) as hyperedges
dai::CondProbEstimationEstimates the parameters of a conditional probability table, using pseudocounts
dai::DAIAlg< GRM >Combines the abstract base class InfAlg with a graphical model (e.g., a FactorGraph or RegionGraph)
dai::DEdgeRepresents a directed edge
dai::EMAlgEMAlg performs Expectation Maximization to learn factor parameters
dai::EvidenceStores a data set consisting of multiple samples, where each sample is the observed joint state of some variables
dai::ExactInfExact inference algorithm using brute force enumeration (mainly useful for testing purposes)
dai::ExactInf::PropertiesParameters for ExactInf
dai::ExceptionError handling in libDAI is done by throwing an instance of the Exception class
dai::FactorGraphRepresents a factor graph
dai::FBPApproximate inference algorithm "Fractional Belief Propagation" [WiH03]
dai::fo_abs< T >Function object that takes the absolute value
dai::fo_absdiff< T >Function object that returns the absolute difference of x and y
dai::fo_divides0< T >Function object similar to std::divides(), but different in that dividing by zero results in zero
dai::fo_exp< T >Function object that takes the exponent
dai::fo_Hellinger< T >Function object useful for calculating the Hellinger distance
dai::fo_id< T >Function object that returns the value itself
dai::fo_inv< T >Function object that takes the inverse
dai::fo_inv0< T >Function object that takes the inverse, except that 1/0 is defined to be 0
dai::fo_KL< T >Function object useful for calculating the KL distance
dai::fo_log< T >Function object that takes the logarithm
dai::fo_log0< T >Function object that takes the logarithm, except that log(0) is defined to be 0
dai::fo_max< T >Function object that returns the maximum of two values
dai::fo_min< T >Function object that returns the minimum of two values
dai::fo_plog0p< T >Function object that returns p*log0(p)
dai::fo_pow< T >Function object that returns x to the power y
dai::FRegionAn FRegion is a factor with a counting number
dai::GibbsApproximate inference algorithm "Gibbs sampling"
dai::Gibbs::PropertiesParameters for Gibbs
dai::GraphALRepresents the neighborhood structure of nodes in an undirected graph
dai::GraphAL::NeighborDescribes the neighbor relationship of two nodes in a GraphAL
dai::GraphELRepresents an undirected graph, implemented as a std::set of undirected edges
dai::greedyVariableEliminationHelper object for dai::ClusterGraph::VarElim()
dai::HAKApproximate inference algorithm: implementation of single-loop ("Generalized Belief Propagation") and double-loop algorithms by Heskes, Albers and Kappen [HAK03]
dai::HAK::PropertiesParameters for HAK
dai::hash_map< T, U, H >Hash_map is an alias for std::tr1::unordered_map
dai::IndexForTool for looping over the states of several variables
dai::InfAlgInfAlg is an abstract base class, defining the common interface of all inference algorithms in libDAI
dai::JTreeExact inference algorithm using junction tree
dai::JTree::PropertiesParameters for JTree
dai::LCApproximate inference algorithm "Loop Corrected Belief Propagation" [MoK07]
dai::LC::PropertiesParameters for LC
dai::MaximizationStepA MaximizationStep groups together several parameter estimation tasks (SharedParameters objects) into a single unit
dai::MFApproximate inference algorithm "Mean Field"
dai::MF::PropertiesParameters for MF
dai::MRApproximate inference algorithm by Montanari and Rizzo [MoR05]
dai::MR::PropertiesParameters for MR
dai::multiforMultifor makes it easy to perform a dynamic number of nested for loops
dai::ParameterEstimationBase class for parameter estimation methods
dai::PermuteTool for calculating permutations of linear indices of multi-dimensional arrays
dai::PropertySetRepresents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue)
dai::RegionA Region is a set of variables with a counting number
dai::RegionGraphA RegionGraph combines a bipartite graph consisting of outer regions (type FRegion) and inner regions (type Region) with a FactorGraph
dai::RootedTreeRepresents a rooted tree, implemented as a vector of directed edges
dai::sequentialVariableEliminationHelper object for dai::ClusterGraph::VarElim()
dai::SharedParametersRepresents a single factor or set of factors whose parameters should be estimated
dai::SmallSet< T >Represents a set; the implementation is optimized for a small number of elements
dai::StateMakes it easy to iterate over all possible joint states of variables within a VarSet
dai::TFactor< T >Represents a (probability) factor
dai::TProb< T >Represents a vector with entries of type T
dai::TreeEPApproximate inference algorithm "Tree Expectation Propagation" [MiQ04]
dai::TreeEP::PropertiesParameters for TreeEP
dai::TreeEP::TreeEPSubTreeStores the data structures needed to efficiently update the approximation of an off-tree factor
dai::TRWBPApproximate inference algorithm "Tree-Reweighted Belief Propagation" [WJW03]
dai::UEdgeRepresents an undirected edge
dai::VarRepresents a discrete random variable
dai::VarSetRepresents a set of variables
dai::WeightedGraph< T >Represents an undirected weighted graph, with weights of type T, implemented as a std::map mapping undirected edges to weights
Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/trwbp_8h.html0000644000263000017630000000546311334764773015640 0ustar jorismkyb libDAI: include/dai/trwbp.h File Reference

include/dai/trwbp.h File Reference

Defines class TRWBP, which implements Tree-Reweighted Belief Propagation. More...

#include <string>
#include <dai/daialg.h>
#include <dai/factorgraph.h>
#include <dai/properties.h>
#include <dai/enum.h>
#include <dai/bp.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::TRWBP
 Approximate inference algorithm "Tree-Reweighted Belief Propagation" [WJW03]. More...

Detailed Description

Defines class TRWBP, which implements Tree-Reweighted Belief Propagation.

Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_113.png0000644000263000017630000000042611334764773015244 0ustar jorismkybPNG  IHDRe0PLTEppp```PPP@@@000 4tRNS@fIDATc` `l.a  PEf= #40|b#Gh( V(200 @rI<rV17;o# Q9 I_Kd0ý ! IENDB`libDAI-0.2.4/doc/html/form_75.png0000644000263000017630000000067411334764773015200 0ustar jorismkybPNG  IHDRP>D0PLTEppp```PPP@@@000 4tRNS@f:IDAT(c` > @`W D6#Y@a$QBPSU@g4EB R7ɢ(՗SP1xބ.~d̙3Aj.@u` 6x2>{A.cH``xCП=gem@RL00|1*elpI )9A3:0\)e`ZʶY &F @  !puL@s(GO`9 s'10 9$Q ` &JHUIENDB`libDAI-0.2.4/doc/html/form_17.png0000644000263000017630000000027411334764773015170 0ustar jorismkybPNG  IHDR [A0PLTEppp```PPP@@@000 4tRNS@f:IDATc` j ɣf2>~S;b#0č7 T^!IENDB`libDAI-0.2.4/doc/html/classdai_1_1VarSet-members.html0000644000263000017630000003137611334764773021105 0ustar jorismkyb libDAI: Member List

dai::VarSet Member List

This is the complete list of members for dai::VarSet, including all inherited members.

begin()dai::SmallSet< T > [inline]
begin() const dai::SmallSet< T > [inline]
const_iterator typedefdai::SmallSet< T >
const_reverse_iterator typedefdai::SmallSet< T >
contains(const T &t) const dai::SmallSet< T > [inline]
elements()dai::SmallSet< T > [inline]
elements() const dai::SmallSet< T > [inline]
empty() const dai::SmallSet< T > [inline]
end()dai::SmallSet< T > [inline]
end() const dai::SmallSet< T > [inline]
front()dai::SmallSet< T > [inline]
front() const dai::SmallSet< T > [inline]
intersects(const SmallSet &x) const dai::SmallSet< T > [inline]
iterator typedefdai::SmallSet< T >
nrStates() const dai::VarSet [inline]
operator &(const SmallSet &x) const dai::SmallSet< T > [inline]
operator &=(const SmallSet &x)dai::SmallSet< T > [inline]
operator!=(const SmallSet &a, const SmallSet &b)dai::SmallSet< T > [friend]
operator/(const SmallSet &x) const dai::SmallSet< T > [inline]
operator/=(const SmallSet &x)dai::SmallSet< T > [inline]
operator/=(const T &t)dai::SmallSet< T > [inline]
operator<(const SmallSet &a, const SmallSet &b)dai::SmallSet< T > [friend]
operator<<(std::ostream &os, const VarSet &vs)dai::VarSet [friend]
dai::SmallSet::operator<<(const SmallSet &x) const dai::SmallSet< T > [inline]
operator==(const SmallSet &a, const SmallSet &b)dai::SmallSet< T > [friend]
operator>>(const SmallSet &x) const dai::SmallSet< T > [inline]
operator|(const SmallSet &x) const dai::SmallSet< T > [inline]
operator|=(const SmallSet &x)dai::SmallSet< T > [inline]
operator|=(const T &t)dai::SmallSet< T > [inline]
rbegin()dai::SmallSet< T > [inline]
rbegin() const dai::SmallSet< T > [inline]
rend()dai::SmallSet< T > [inline]
rend() const dai::SmallSet< T > [inline]
reverse_iterator typedefdai::SmallSet< T >
size() const dai::SmallSet< T > [inline]
SmallSet()dai::SmallSet< T > [inline]
SmallSet(const T &t)dai::SmallSet< T > [inline]
SmallSet(const T &t1, const T &t2)dai::SmallSet< T > [inline]
SmallSet(TIterator begin, TIterator end, size_t sizeHint=0)dai::SmallSet< T > [inline]
VarSet()dai::VarSet [inline]
VarSet(const SmallSet< Var > &x)dai::VarSet [inline]
VarSet(const Var &v)dai::VarSet [inline]
VarSet(const Var &v1, const Var &v2)dai::VarSet [inline]
VarSet(VarIterator begin, VarIterator end, size_t sizeHint=0)dai::VarSet [inline]

Generated on Thu Feb 11 12:26:08 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1BP__dual_1_1beliefs-members.html0000644000263000017630000000504511334764773023551 0ustar jorismkyb libDAI: Member List

dai::BP_dual::beliefs Member List

This is the complete list of members for dai::BP_dual::beliefs, including all inherited members.

b1dai::BP_dual::beliefs
b2dai::BP_dual::beliefs
Zb1dai::BP_dual::beliefs
Zb2dai::BP_dual::beliefs

Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1JTree_1_1Properties.html0000644000263000017630000003076211334764773022214 0ustar jorismkyb libDAI: dai::JTree::Properties Struct Reference

dai::JTree::Properties Struct Reference

Parameters for JTree. More...

#include <dai/jtree.h>

List of all members.

Public Member Functions

 DAI_ENUM (UpdateType, HUGIN, SHSH)
 Enumeration of possible JTree updates.
 DAI_ENUM (InfType, SUMPROD, MAXPROD)
 Enumeration of inference variants.
 DAI_ENUM (HeuristicType, MINNEIGHBORS, MINWEIGHT, MINFILL, WEIGHTEDMINFILL)
 Enumeration of elimination cost functions used for constructing the junction tree.

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr).
UpdateType updates
 Type of updates.
InfType inference
 Type of inference.
HeuristicType heuristic
 Heuristic to use for constructing the junction tree.

Detailed Description

Parameters for JTree.

Member Function Documentation

dai::JTree::Properties::DAI_ENUM ( UpdateType  ,
HUGIN  ,
SHSH   
)

Enumeration of possible JTree updates.

There are two types of updates:

  • HUGIN similar to those in HUGIN
  • SHSH Shafer-Shenoy type

dai::JTree::Properties::DAI_ENUM ( InfType  ,
SUMPROD  ,
MAXPROD   
)

Enumeration of inference variants.

There are two inference variants:

  • SUMPROD Sum-Product
  • MAXPROD Max-Product (equivalent to Min-Sum)

dai::JTree::Properties::DAI_ENUM ( HeuristicType  ,
MINNEIGHBORS  ,
MINWEIGHT  ,
MINFILL  ,
WEIGHTEDMINFILL   
)

Enumeration of elimination cost functions used for constructing the junction tree.

The cost of eliminating a variable can be (

See also:
[KoF09], page 314)):
  • MINNEIGHBORS the number of neighbors it has in the current adjacency graph;
  • MINWEIGHT the product of the number of states of all neighbors in the current adjacency graph;
  • MINFILL the number of edges that need to be added to the adjacency graph due to the elimination;
  • WEIGHTEDMINFILL the sum of weights of the edges that need to be added to the adjacency graph due to the elimination, where a weight of an edge is the produt of weights of its constituent vertices. The elimination sequence is chosen greedily in order to minimize the cost.

Member Data Documentation

size_t dai::JTree::Properties::verbose

Verbosity (amount of output sent to stderr).

UpdateType dai::JTree::Properties::updates

Type of updates.

InfType dai::JTree::Properties::inference

Type of inference.

HeuristicType dai::JTree::Properties::heuristic

Heuristic to use for constructing the junction tree.

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_81.png0000644000263000017630000000203711334764773015170 0ustar jorismkybPNG  IHDR" 0PLTEppp```PPP@@@000 4tRNS@fIDATXMh@d7iږ^Ư!R=XЦՊ" *zѵUChFRE4VP zx^\ :G ?sYe<߳8>a7:gx_A~aŷT|} *2BL hKɃ4X/ O# 戮cX*S̽I w'YXy<\"EbΐrC+m; l'Z{qH6ZSd7._m<6e"xWNqY4zNQKs=1$9HTG6v Ϭ0AF}thk2h5Z@InzfP+'9ku5կ{kެ^H5N}N>uB ڟp?OE6~m{'6jo&:;('5'D.GgLmVjW3[pW|VO3pmcm2kV7n)OIENDB`libDAI-0.2.4/doc/html/evidence_8h-source.html0000644000263000017630000002422211334764773017554 0ustar jorismkyb libDAI: include/dai/evidence.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1VarSet.html0000644000263000017630000004104311334764773017445 0ustar jorismkyb libDAI: dai::VarSet Class Reference

dai::VarSet Class Reference

Represents a set of variables. More...

#include <dai/varset.h>

Inheritance diagram for dai::VarSet:

dai::SmallSet< T > dai::Region

List of all members.

Public Member Functions

Constructors and destructors
 VarSet ()
 Default constructor (constructs an empty set).
 VarSet (const SmallSet< Var > &x)
 Construct from SmallSet<Var> x.
 VarSet (const Var &v)
 Construct a VarSet with one element, v.
 VarSet (const Var &v1, const Var &v2)
 Construct a VarSet with two elements, v1 and v2.
template<typename VarIterator>
 VarSet (VarIterator begin, VarIterator end, size_t sizeHint=0)
 Construct a VarSet from the range between begin and end.
Queries
size_t nrStates () const
 Calculates the number of states of this VarSet, which is simply the number of possible joint states of the variables in *this.

Friends

Input and output
std::ostream & operator<< (std::ostream &os, const VarSet &vs)
 Writes a VarSet to an output stream.

Detailed Description

Represents a set of variables.

Note:
A VarSet is implemented using a SmallSet<Var> instead of the more natural std::set<Var> because of efficiency reasons. That is, internally, the variables in the set are sorted ascendingly according to their labels.
Examples:

example_permute.cpp, example_sprinkler.cpp, and example_varset.cpp.

Constructor & Destructor Documentation

dai::VarSet::VarSet (  )  [inline]

Default constructor (constructs an empty set).

dai::VarSet::VarSet ( const SmallSet< Var > &  x  )  [inline]

Construct from SmallSet<Var> x.

dai::VarSet::VarSet ( const Var &  v  )  [inline]

Construct a VarSet with one element, v.

dai::VarSet::VarSet ( const Var &  v1,
const Var &  v2 
) [inline]

Construct a VarSet with two elements, v1 and v2.

template<typename VarIterator>
dai::VarSet::VarSet ( VarIterator  begin,
VarIterator  end,
size_t  sizeHint = 0 
) [inline]

Construct a VarSet from the range between begin and end.

Template Parameters:
VarIterator Iterates over instances of type Var.
Parameters:
begin Points to first Var to be added.
end Points just beyond last Var to be added.
sizeHint For efficiency, the number of elements can be speficied by sizeHint.

Member Function Documentation

size_t dai::VarSet::nrStates (  )  const [inline]

Calculates the number of states of this VarSet, which is simply the number of possible joint states of the variables in *this.

The number of states of the Cartesian product of the variables in this VarSet is simply the product of the number of states of each variable in this VarSet. If *this corresponds with the set $\{x_l\}_{l\in L}$, where variable $x_l$ has label $l$, and denoting by $S_l$ the number of possible values ("states") of variable $x_l$, the number of joint configurations of the variables in $\{x_l\}_{l\in L}$ is given by $\prod_{l\in L} S_l$.

Examples:
example_permute.cpp, and example_varset.cpp.

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os,
const VarSet &  vs 
) [friend]

Writes a VarSet to an output stream.

The documentation for this class was generated from the following file:
Generated on Thu Feb 11 12:26:08 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/cbp_8h.html0000644000263000017630000000615311334764773015243 0ustar jorismkyb libDAI: include/dai/cbp.h File Reference

include/dai/cbp.h File Reference

Defines class CBP, which implements Conditioned Belief Propagation. More...

#include <fstream>
#include <boost/shared_ptr.hpp>
#include <dai/daialg.h>
#include <dai/bbp.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::CBP
 Class for CBP (Conditioned Belief Propagation) [EaG09]. More...
struct  dai::CBP::Properties
 Parameters for CBP. More...

Detailed Description

Defines class CBP, which implements Conditioned Belief Propagation.

Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1TProb-members.html0000644000263000017630000005625511334764773020732 0ustar jorismkyb libDAI: Member List

dai::TProb< T > Member List

This is the complete list of members for dai::TProb< T >, including all inherited members.

_pdai::TProb< T > [private]
abs() const dai::TProb< T > [inline]
accumulate(T init, binOp op1, unOp op2) const dai::TProb< T > [inline]
argmax() const dai::TProb< T > [inline]
begin()dai::TProb< T > [inline]
begin() const dai::TProb< T > [inline]
const_iterator typedefdai::TProb< T >
const_reverse_iterator typedefdai::TProb< T >
dist(const TProb< T > &p, const TProb< T > &q, typename TProb< T >::DistType dt)dai::TProb< T > [related]
DISTHEL enum value (defined in dai::TProb< T >)dai::TProb< T >
DISTKL enum value (defined in dai::TProb< T >)dai::TProb< T >
DISTL1 enum value (defined in dai::TProb< T >)dai::TProb< T >
DISTLINF enum value (defined in dai::TProb< T >)dai::TProb< T >
DISTTV enum value (defined in dai::TProb< T >)dai::TProb< T >
DistType enum namedai::TProb< T >
divide(const TProb< T > &q)dai::TProb< T > [inline]
divided_by(const TProb< T > &q) const dai::TProb< T > [inline]
draw()dai::TProb< T > [inline]
end()dai::TProb< T > [inline]
end() const dai::TProb< T > [inline]
entropy() const dai::TProb< T > [inline]
exp() const dai::TProb< T > [inline]
fill(T x)dai::TProb< T > [inline]
hasNaNs() const dai::TProb< T > [inline]
hasNegatives() const dai::TProb< T > [inline]
innerProduct(const TProb< T > &q, T init, binOp1 binaryOp1, binOp2 binaryOp2) const dai::TProb< T > [inline]
inverse(bool zero=true) const dai::TProb< T > [inline]
iterator typedefdai::TProb< T >
log(bool zero=false) const dai::TProb< T > [inline]
max() const dai::TProb< T > [inline]
max(const TProb< T > &a, const TProb< T > &b)dai::TProb< T > [related]
maxAbs() const dai::TProb< T > [inline]
min() const dai::TProb< T > [inline]
min(const TProb< T > &a, const TProb< T > &b)dai::TProb< T > [related]
normalize(NormType norm=NORMPROB)dai::TProb< T > [inline]
normalized(NormType norm=NORMPROB) const dai::TProb< T > [inline]
NORMLINF enum value (defined in dai::TProb< T >)dai::TProb< T >
NORMPROB enum value (defined in dai::TProb< T >)dai::TProb< T >
NormType enum namedai::TProb< T >
operator*(T x) const dai::TProb< T > [inline]
operator*(const TProb< T > &q) const dai::TProb< T > [inline]
operator*=(T x)dai::TProb< T > [inline]
operator*=(const TProb< T > &q)dai::TProb< T > [inline]
operator+(T x) const dai::TProb< T > [inline]
operator+(const TProb< T > &q) const dai::TProb< T > [inline]
operator+=(T x)dai::TProb< T > [inline]
operator+=(const TProb< T > &q)dai::TProb< T > [inline]
operator-() const dai::TProb< T > [inline]
operator-(T x) const dai::TProb< T > [inline]
operator-(const TProb< T > &q) const dai::TProb< T > [inline]
operator-=(T x)dai::TProb< T > [inline]
operator-=(const TProb< T > &q)dai::TProb< T > [inline]
operator/(T x) const dai::TProb< T > [inline]
operator/(const TProb< T > &q) const dai::TProb< T > [inline]
operator/=(T x)dai::TProb< T > [inline]
operator/=(const TProb< T > &q)dai::TProb< T > [inline]
operator<<(std::ostream &os, const TProb< T > &p)dai::TProb< T > [related]
operator<=(const TProb< T > &q) const dai::TProb< T > [inline]
operator[](size_t i) const dai::TProb< T > [inline]
operator[](size_t i)dai::TProb< T > [inline]
operator^(T x) const dai::TProb< T > [inline]
operator^(const TProb< T > &q) const dai::TProb< T > [inline]
operator^=(T x)dai::TProb< T > [inline]
operator^=(const TProb< T > &q)dai::TProb< T > [inline]
p() const dai::TProb< T > [inline]
p()dai::TProb< T > [inline]
pwBinaryOp(const TProb< T > &q, binaryOp op)dai::TProb< T > [inline]
pwBinaryTr(const TProb< T > &q, binaryOp op) const dai::TProb< T > [inline]
pwUnaryOp(unaryOp op)dai::TProb< T > [inline]
pwUnaryTr(unaryOp op) const dai::TProb< T > [inline]
randomize()dai::TProb< T > [inline]
rbegin()dai::TProb< T > [inline]
rbegin() const dai::TProb< T > [inline]
rend()dai::TProb< T > [inline]
rend() const dai::TProb< T > [inline]
reverse_iterator typedefdai::TProb< T >
setUniform()dai::TProb< T > [inline]
size() const dai::TProb< T > [inline]
sum() const dai::TProb< T > [inline]
sumAbs() const dai::TProb< T > [inline]
takeAbs()dai::TProb< T > [inline]
takeExp()dai::TProb< T > [inline]
takeLog(bool zero=false)dai::TProb< T > [inline]
TProb()dai::TProb< T > [inline]
TProb(size_t n)dai::TProb< T > [inline, explicit]
TProb(size_t n, T p)dai::TProb< T > [inline, explicit]
TProb(TIterator begin, TIterator end, size_t sizeHint=0)dai::TProb< T > [inline]
TProb(const std::vector< S > &v)dai::TProb< T > [inline]

Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1LC-members.html0000644000263000017630000002741111334764773020172 0ustar jorismkyb libDAI: Member List

dai::LC Member List

This is the complete list of members for dai::LC, including all inherited members.

_beliefsdai::LC [private]
_cavitydistsdai::LC [private]
_itersdai::LC [private]
_maxdiffdai::LC [private]
_pancakesdai::LC [private]
_phisdai::LC [private]
backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
belief(const Var &v) const dai::LC [inline, virtual]
belief(const VarSet &) const dai::LC [inline, virtual]
beliefF(size_t I) const dai::InfAlg [inline, virtual]
beliefs() const dai::LC [inline, virtual]
beliefV(size_t i) const dai::LC [inline, virtual]
CalcBelief(size_t i)dai::LC
CalcCavityDist(size_t i, const std::string &name, const PropertySet &opts)dai::LC
cavitydist(size_t i) const dai::LC [inline]
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clone() const dai::LC [inline, virtual]
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
getProperties() const dai::LC [virtual]
identify() const dai::LC [virtual]
init()dai::LC [virtual]
init(const VarSet &)dai::LC [inline, virtual]
InitCavityDists(const std::string &name, const PropertySet &opts)dai::LC
Iterations() const dai::LC [inline, virtual]
LC()dai::LC [inline]
LC(const FactorGraph &fg, const PropertySet &opts)dai::LC
logZ() const dai::LC [inline, virtual]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
maxDiff() const dai::LC [inline, virtual]
Namedai::LC [static]
NewPancake(size_t i, size_t _I, bool &hasNaNs)dai::LC
pancake(size_t i) const dai::LC [inline]
printProperties() const dai::LC [virtual]
props (defined in dai::LC)dai::LC
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
run()dai::LC [virtual]
SetCavityDists(std::vector< Factor > &Q)dai::LC
setProperties(const PropertySet &opts)dai::LC [virtual]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_26.png0000644000263000017630000000050211334764773015162 0ustar jorismkybPNG  IHDR2u10PLTEppp```PPP@@@000 4tRNS@fIDATc` 05( *f2l:^$0910b`0}XhW!Ct6 wC4CJ.猯Ba{$&B]n_~9uXpOH;~;Iݏe.YߪhVuO libDAI: Class Members
 

- _ -

  • _normal_rnd() : dai
  • _rnd_gen() : dai
  • _uni_dist() : dai
  • _uni_rnd() : dai

- a -

- c -

  • calcLinearState() : dai
  • calcMarginal() : dai
  • calcPairBeliefs() : dai
  • calcState() : dai
  • complement() : dai
  • concat() : dai
  • createFactorDelta() : dai
  • createFactorExpGauss() : dai
  • createFactorIsing() : dai
  • createFactorPotts() : dai
  • createGraphFull() : dai
  • createGraphGrid() : dai
  • createGraphGrid3D() : dai
  • createGraphLoop() : dai
  • createGraphRegular() : dai
  • createGraphTree() : dai

- d -

  • DAI_ENUM() : dai
  • dist() : dai

- e -

  • eliminationCost_MinFill() : dai
  • eliminationCost_MinNeighbors() : dai
  • eliminationCost_MinWeight() : dai
  • eliminationCost_WeightedMinFill() : dai
  • exp() : dai

- f -

  • Factors2mx() : dai

- g -

  • getFactorEntryForState() : dai

- l -

- m -

  • makePositive() : dai
  • makeZero() : dai
  • max() : dai
  • MaxSpanningTreePrims() : dai
  • MinSpanningTreePrims() : dai
  • mixBeliefs() : dai
  • mx2Factor() : dai
  • mx2Factors() : dai

- n -

  • newInfAlg() : dai
  • newInfAlgFromString() : dai

- o -

  • operator<<() : dai
  • operator>>() : dai

- p -

  • parseNameProperties() : dai

- r -

  • RandomDRegularGraph() : dai
  • readAliasesFile() : dai
  • rnd() : dai
  • rnd_int() : dai
  • rnd_seed() : dai
  • rnd_stdnormal() : dai
  • rnd_uniform() : dai

- t -

  • toc() : dai
  • tokenizeString() : dai

- u -

  • unSoftMax() : dai
Generated on Thu Feb 11 12:26:08 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1fo__min-members.html0000644000263000017630000000360011334764773021513 0ustar jorismkyb libDAI: Member List

dai::fo_min< T > Member List

This is the complete list of members for dai::fo_min< T >, including all inherited members.

operator()(const T &x, const T &y) const dai::fo_min< T > [inline]

Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_func_0x68.html0000644000263000017630000001167411334764773017714 0ustar jorismkyb libDAI: Class Members - Functions
 

- h -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1CBP_1_1Properties-members.html0000644000263000017630000001531011334764773023227 0ustar jorismkyb libDAI: Member List

dai::CBP::Properties Member List

This is the complete list of members for dai::CBP::Properties, including all inherited members.

bbp_cfndai::CBP::Properties
bbp_propsdai::CBP::Properties
choosedai::CBP::Properties
clampdai::CBP::Properties
clamp_outfiledai::CBP::Properties
DAI_ENUM(RecurseType, REC_FIXED, REC_LOGZ, REC_BDIFF)dai::CBP::Properties
DAI_ENUM(ChooseMethodType, CHOOSE_RANDOM, CHOOSE_MAXENT, CHOOSE_BBP, CHOOSE_BP_L1, CHOOSE_BP_CFN)dai::CBP::Properties
DAI_ENUM(ClampType, CLAMP_VAR, CLAMP_FACTOR)dai::CBP::Properties
get() const dai::CBP::Properties
max_levelsdai::CBP::Properties
maxiterdai::CBP::Properties
min_max_adjdai::CBP::Properties
rand_seeddai::CBP::Properties
rec_toldai::CBP::Properties
recursiondai::CBP::Properties
set(const PropertySet &opts)dai::CBP::Properties
toldai::CBP::Properties
toString() const dai::CBP::Properties
updatesdai::CBP::Properties
UpdateType typedefdai::CBP::Properties
verbosedai::CBP::Properties

Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1JTree-members.html0000644000263000017630000003101611334764773020701 0ustar jorismkyb libDAI: Member List

dai::JTree Member List

This is the complete list of members for dai::JTree, including all inherited members.

_logZdai::JTree [private]
_mesdai::JTree [private]
backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
belief(const VarSet &vs) const dai::JTree [virtual]
dai::DAIAlg::belief(const Var &v) const dai::InfAlg [inline, virtual]
beliefF(size_t I) const dai::InfAlg [inline, virtual]
beliefs() const dai::JTree [virtual]
beliefV(size_t i) const dai::InfAlg [inline, virtual]
boundTreewidth(const FactorGraph &fg, greedyVariableElimination::eliminationCostFunction fn)dai::JTree [related]
calcMarginal(const VarSet &vs)dai::JTree
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clone() const dai::JTree [inline, virtual]
construct(const std::vector< VarSet > &cl, bool verify=false)dai::JTree
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
findEfficientTree(const VarSet &vs, RootedTree &Tree, size_t PreviousRoot=(size_t)-1) const dai::JTree
findMaximum() const dai::JTree
GenerateJT(const std::vector< VarSet > &cl)dai::JTree
getProperties() const dai::JTree [virtual]
identify() const dai::JTree [virtual]
init()dai::JTree [inline, virtual]
init(const VarSet &)dai::JTree [inline, virtual]
Iterations() const dai::JTree [inline, virtual]
JTree()dai::JTree [inline]
JTree(const FactorGraph &fg, const PropertySet &opts, bool automatic=true)dai::JTree
logZ() const dai::JTree [virtual]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
maxDiff() const dai::JTree [inline, virtual]
message(size_t alpha, size_t _beta) const dai::JTree [inline]
message(size_t alpha, size_t _beta)dai::JTree [inline]
Namedai::JTree [static]
printProperties() const dai::JTree [virtual]
props (defined in dai::JTree)dai::JTree
Qadai::JTree
Qbdai::JTree
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
RTreedai::JTree
run()dai::JTree [virtual]
runHUGIN()dai::JTree
runShaferShenoy()dai::JTree
setProperties(const PropertySet &opts)dai::JTree [virtual]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_74.png0000644000263000017630000000047511334764773015176 0ustar jorismkybPNG  IHDR2뽐0PLTEppp```PPP@@@000 4tRNS@fIDATc` dtA6O"34G{$ +0L!`]o#v Xe2@l%@b/% S؁bP! d}f93eBG`U`/=4M "?l8ٕ 1•́و̽CĒQ0PKIENDB`libDAI-0.2.4/doc/html/functions_func_0x65.html0000644000263000017630000001761511334764773017712 0ustar jorismkyb libDAI: Class Members - Functions
 

- e -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1BP_1_1EdgeProp.html0000644000263000017630000001465011334764773021053 0ustar jorismkyb libDAI: dai::BP::EdgeProp Struct Reference

dai::BP::EdgeProp Struct Reference

Type used for storing edge properties. More...

#include <dai/bp.h>

List of all members.

Public Attributes

ind_t index
 Index cached for this edge.
Prob message
 Old message living on this edge.
Prob newMessage
 New message living on this edge.
Real residual
 Residual for this edge.

Detailed Description

Type used for storing edge properties.

Member Data Documentation

ind_t dai::BP::EdgeProp::index

Index cached for this edge.

Prob dai::BP::EdgeProp::message

Old message living on this edge.

Prob dai::BP::EdgeProp::newMessage

New message living on this edge.

Real dai::BP::EdgeProp::residual

Residual for this edge.

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1BipartiteGraph_1_1levelType-members.html0000644000263000017630000000423111334764773025345 0ustar jorismkyb libDAI: Member List

dai::BipartiteGraph::levelType Member List

This is the complete list of members for dai::BipartiteGraph::levelType, including all inherited members.

ind1dai::BipartiteGraph::levelType
ind2dai::BipartiteGraph::levelType

Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_0x6c.html0000644000263000017630000001513711334764773016752 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- l -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_func_0x72.html0000644000263000017630000002321411334764773017700 0ustar jorismkyb libDAI: Class Members - Functions
 

- r -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/inline_dotgraph_3.dot.png0000644000263000017630000000140511334764773020070 0ustar jorismkybPNG  IHDRRi"!!PLTE___ߟ???*XtRNS@fIDATXKN0# k!X 9ظvjO $vR Mʏz}ʣIcdZ.[05d v&&)h;KOo\}#roˈ|ĺ҄ND(cI%Hd$0H%7oMo ;Q,ϐ4F5M r &Q~2$9j,sL3jd4HHdݦ'a]U%\kTu'>%>Ryu+)3I#Cr^&f8K:C &&ٓ6#I{$ }bё:n!ɓKC2m,I$[U("ɪɂ\vܦ&OJeUU-g [=OsF]rݷB XY- ^ȋ0eGMk(E$Vj2$ ͻ<*uU&T^R_ajJ)&70_C(:T1ծ>8[ňπDG-x`ܟxLW'/cuvu a[$>|?hb} $8RI4'43݋xIENDB`libDAI-0.2.4/doc/html/structdai_1_1GraphAL_1_1Neighbor-members.html0000644000263000017630000000623011334764773023503 0ustar jorismkyb libDAI: Member List

dai::GraphAL::Neighbor Member List

This is the complete list of members for dai::GraphAL::Neighbor, including all inherited members.

dualdai::GraphAL::Neighbor
iterdai::GraphAL::Neighbor
Neighbor()dai::GraphAL::Neighbor [inline]
Neighbor(size_t iter, size_t node, size_t dual)dai::GraphAL::Neighbor [inline]
nodedai::GraphAL::Neighbor
operator size_t() const dai::GraphAL::Neighbor [inline]

Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1Gibbs_1_1Properties.html0000644000263000017630000001255411334764773022230 0ustar jorismkyb libDAI: dai::Gibbs::Properties Struct Reference

dai::Gibbs::Properties Struct Reference

Parameters for Gibbs. More...

#include <dai/gibbs.h>

List of all members.

Public Attributes

size_t iters
 Total number of iterations.
size_t burnin
 Number of "burn-in" iterations.
size_t verbose
 Verbosity (amount of output sent to stderr).

Detailed Description

Parameters for Gibbs.

Member Data Documentation

size_t dai::Gibbs::Properties::iters

Total number of iterations.

size_t dai::Gibbs::Properties::burnin

Number of "burn-in" iterations.

size_t dai::Gibbs::Properties::verbose

Verbosity (amount of output sent to stderr).

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_14.png0000644000263000017630000000136611334764773015170 0ustar jorismkybPNG  IHDR"ϗ0PLTEppp```PPP@@@000 4tRNS@ftIDATHkAǿlvAH BVEB{&уlX`1`DP>in$+oJb܆86!5$/Mz? PGx8pUOjSVo=u88 D1y,^Һ26F&oaQ]!/J!7 p\Pgy=G%G`Hs&3u}$HK͑"%yzJ82i."SX+,Z3Zb ×h= (k<1cgh, aI %kdت<C92̯בM CKuf<]ηA_gCb %Tw3HlwH5%P]_S9-?n=6Xo]{B#(C <ԃS!WK.αk\ en΀ libDAI: libDAI file formats

libDAI file formats

Factor graph (.fg) file format

This section describes the .fg file format used in libDAI to store factor graphs. Markov Random Fields are special cases of factor graphs, as are Bayesian networks. A factor graph can be specified as follows: for each factor, one has to specify which variables occur in the factor, what their respective cardinalities (i.e., number of possible values) are, and a table listing all the values of that factor for all possible configurations of these variables.

A .fg file is not much more than that. It starts with a line containing the number of factors in that graph, followed by an empty line. Then all factors are specified, using one block for each factor, where the blocks are seperated by empty lines. Each variable occurring in the factor graph has a unique identifier, its label (which should be a nonnegative integer). Comment lines which start with # are ignored.

Factor block format

Each block describing a factor starts with a line containing the number of variables in that factor. The second line contains the labels of these variables, seperated by spaces (labels are nonnegative integers and to avoid confusion, it is suggested to start counting at 0). The third line contains the number of possible values of each of these variables, also seperated by spaces. Note that there is some redundancy here, since if a variable appears in more than one factor, the cardinality of that variable appears several times in the .fg file; obviously, these cardinalities should be consistent. The fourth line contains the number of nonzero entries in the factor table. The rest of the lines contain these nonzero entries; each line consists of a table index, followed by white-space, followed by the value corresponding to that table index. The most difficult part is getting the indexing right. The convention that is used is that the left-most variables cycle through their values the fastest (similar to MatLab indexing of multidimensional arrays).

Example

An example block describing one factor is:

  3
  4 8 7
  3 2 2
  11
  0 0.1
  1 3.5
  2 2.8
  3 6.3
  4 8.4
  6 7.4
  7 2.4
  8 8.9
  9 1.3
  10 1.6
  12 6.4
  11 2.6

which corresponds to the following factor:

\[ \begin{array}{ccc|c} x_4 & x_8 & x_7 & \mbox{value}\\ \hline 0 & 0 & 0 & 0.1\\ 1 & 0 & 0 & 3.5\\ 2 & 0 & 0 & 2.8\\ 0 & 1 & 0 & 6.3\\ 1 & 1 & 0 & 8.4\\ 2 & 1 & 0 & 0.0\\ 0 & 0 & 1 & 7.4\\ 1 & 0 & 1 & 2.4\\ 2 & 0 & 1 & 8.9\\ 0 & 1 & 1 & 1.3\\ 1 & 1 & 1 & 1.6\\ 2 & 1 & 1 & 2.6 \end{array} \]

Note that the value of $x_4$ changes fastest, followed by that of $x_8$, and $x_7$ varies the slowest, corresponding to the second line of the block ("4 8 7"). Further, $x_4$ can take on three values, and $x_8$ and $x_7$ each have two possible values, as described in the third line of the block ("3 2 2"). The table contains 11 non-zero entries (all except for the fifth entry). Note that the eleventh and twelveth entries are interchanged.

A final note: the internal representation in libDAI of the factor above is different, because the variables are ordered according to their indices (i.e., the ordering would be $x_4 x_7 x_8$) and the values of the table are stored accordingly, with the variable having the smallest index changing fastest:

\[ \begin{array}{ccc|c} x_4 & x_7 & x_8 & \mbox{value}\\ \hline 0 & 0 & 0 & 0.1\\ 1 & 0 & 0 & 3.5\\ 2 & 0 & 0 & 2.8\\ 0 & 1 & 0 & 7.4\\ 1 & 1 & 0 & 2.4\\ 2 & 1 & 0 & 8.9\\ 0 & 0 & 1 & 6.3\\ 1 & 0 & 1 & 8.4\\ 2 & 0 & 1 & 0.0\\ 0 & 1 & 1 & 1.3\\ 1 & 1 & 1 & 1.6\\ 2 & 1 & 1 & 2.6 \end{array} \]

Evidence (.tab) file format

This section describes the .tab fileformat used in libDAI to store "evidence", i.e., a data set consisting of multiple samples, where each sample is the observed joint state of some variables.

A .tab file is a tabular data file, consisting of a header line, followed by an empty line, followed by the data points, with one line for each data point. Each line (apart from the empty one) should have the same number of columns, where columns are separated by one tab character. Each column corresponds to a variable. The header line consists of the variable labels (corresponding to dai::Var::label()). The other lines are observed joint states of the variables, i.e., each line corresponds to a joint observation of the variables, and each column of a line contains the state of the variable associated with that column. Missing data is handled simply by having two consecutive tab characters, without any characters in between.

Example

  1       3       2

  0       0       1
  1       0       1
  1               1

This would correspond to a data set consisting of three observations concerning the variables with labels 1, 3 and 2; the first observation being $x_1 = 0, x_3 = 0, x_2 = 1$, the second observation being $x_1 = 1, x_3 = 0, x_2 = 1$, and the third observation being $x_1 = 1, x_2 = 1$ (where the state of $x_3$ is missing).

Expectation Maximization (.em) file format

This section describes the file format of .em files, which are used to specify a particular EM algorithm. The .em files are complementary to .fg files; in other words, an .em file without a corresponding .fg file is useless. Furthermore, one also needs a corresponding .tab file containing the data used for parameter learning.

An .em file starts with a line specifying the number of maximization steps, followed by an empty line. Then, each maximization step is described in a block, which should satisfy the format described in the next subsection.

Maximization Step block format

A maximization step block of an .em file starts with a single line describing the number of shared parameters blocks that will follow. Then, each shared parameters block follows, in the format described in the next subsection.

Shared parameters block format

A shared parameters block of an .em file starts with a single line consisting of the name of a ParameterEstimation subclass and its parameters in the format of a PropertySet. For example: 
  CondProbEstimation [target_dim=2,total_dim=4,pseudo_count=1]
The next line contains the number of factors that share their parameters. Then, each of these factors is specified on separate lines (possibly seperated by empty lines), where each line consists of several fields seperated by a space or a tab character. The first field contains the index of the factor in the factor graph. The following fields should contain the variable labels of the variables on which that factor depends, in a specific ordering. This ordering can be different from the canonical ordering of the variables used internally in libDAI (which would be sorted ascendingly according to the variable labels). The ordering of the variables specifies the implicit ordering of the shared parameters: when iterating over all shared parameters, the corresponding index of the first variable changes fastest (in the inner loop), and the corresponding index of the last variable changes slowest (in the outer loop). By choosing the right ordering, it is possible to let different factors (depending on different variables) share parameters in parameter learning using EM. This convention is similar to the convention used in factor blocks in a factor graph .fg file (see Factor block format).

Aliases file format

An aliases file is basically a list of "macros" and the strings that they should be substituted with.

Each line of the aliases file can be either empty, contain a comment (if the first character is a '#') or contain an alias. In the latter case, the line should contain a colon; the part before the colon contains the name of the alias, the part after the colon the string that it should be substituted with. Any whitespace before and after the colon is ignored.

For example, the following line would define the alias BP_SEQFIX as a shorthand for "BP[updates=SEQFIX,tol=1e-9,maxiter=10000,logdomain=0]": 

  BP_SEQFIX:  BP[updates=SEQFIX,tol=1e-9,maxiter=10000,logdomain=0]

Aliases files can be used to store default options for algorithms.

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/citations.html0000644000263000017630000000431111334764773016067 0ustar jorismkyb libDAI: Citing libDAI

Citing libDAI

Citing libDAI

If you write a scientific paper describing research that made substantive use of this program, please:
  • mention the fashion in which this software was used, including the version number, with a citation to the literature, to allow replication;
  • mention this software in the Acknowledgements section.

An appropriate citation would be:

Joris M. Mooij et al. (2010) "libDAI 0.2.4: A free/open source C++ library for Discrete Approximate Inference", http://www.libdai.org

or in BiBTeX format:

  @misc{mooij2010libdai,
    author = "Joris M. Mooij et al.",
    title = "lib{DAI} 0.2.4: A free/open source {C}++ library for {D}iscrete {A}pproximate {I}nference",
    howpublished = "http://www.libdai.org/",
    year = 2010
  }

Moreover, as a personal note, I would appreciate it if you would email (citations of) papers referencing this work to joris dot mooij at libdai dot org.

Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/varset_8h.html0000644000263000017630000000737711334764773016014 0ustar jorismkyb libDAI: include/dai/varset.h File Reference

include/dai/varset.h File Reference

Defines the VarSet class, which represents a set of random variables. More...

#include <vector>
#include <map>
#include <ostream>
#include <dai/var.h>
#include <dai/util.h>
#include <dai/smallset.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::VarSet
 Represents a set of variables. More...

Functions

size_t dai::calcLinearState (const VarSet &vs, const std::map< Var, size_t > &state)
 Calculates the linear index in the Cartesian product of the variables in vs that corresponds to a particular joint assignment of the variables, specified by state.
std::map< Var, size_t > dai::calcState (const VarSet &vs, size_t linearState)
 Calculates the joint assignment of the variables in vs corresponding to the linear index linearState.

Detailed Description

Defines the VarSet class, which represents a set of random variables.

Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1FRegion-members.html0000644000263000017630000004526211334764773021231 0ustar jorismkyb libDAI: Member List

dai::FRegion Member List

This is the complete list of members for dai::FRegion, including all inherited members.

_cdai::FRegion [private]
abs() const dai::TFactor< T > [inline]
binaryOp(const TFactor< T > &g, binOp op)dai::TFactor< T > [inline]
binaryTr(const TFactor< T > &g, binOp op) const dai::TFactor< T > [inline]
c() const dai::FRegion [inline]
c()dai::FRegion [inline]
dist(const TFactor< T > &f, const TFactor< T > &g, typename TProb< T >::DistType dt)dai::TFactor< T > [related]
embed(const VarSet &vars) const dai::TFactor< T > [inline]
entropy() const dai::TFactor< T > [inline]
exp() const dai::TFactor< T > [inline]
fill(T x)dai::TFactor< T > [inline]
FRegion()dai::FRegion [inline]
FRegion(const Factor &x, Real c)dai::FRegion [inline]
hasNaNs() const dai::TFactor< T > [inline]
hasNegatives() const dai::TFactor< T > [inline]
inverse(bool zero=true) const dai::TFactor< T > [inline]
log(bool zero=false) const dai::TFactor< T > [inline]
marginal(const VarSet &vars, bool normed=true) const dai::TFactor< T > [inline]
max() const dai::TFactor< T > [inline]
max(const TFactor< T > &f, const TFactor< T > &g)dai::TFactor< T > [related]
maxAbs() const dai::TFactor< T > [inline]
maxMarginal(const VarSet &vars, bool normed=true) const dai::TFactor< T > [inline]
min() const dai::TFactor< T > [inline]
min(const TFactor< T > &f, const TFactor< T > &g)dai::TFactor< T > [related]
MutualInfo(const TFactor< T > &f)dai::TFactor< T > [related]
normalize(typename TProb< T >::NormType norm=TProb< T >::NORMPROB)dai::TFactor< T > [inline]
normalized(typename TProb< T >::NormType norm=TProb< T >::NORMPROB) const dai::TFactor< T > [inline]
operator*(T x) const dai::TFactor< T > [inline]
operator*(const TFactor< T > &g) const dai::TFactor< T > [inline]
operator*=(T x)dai::TFactor< T > [inline]
operator*=(const TFactor< T > &g)dai::TFactor< T > [inline]
operator+(T x) const dai::TFactor< T > [inline]
operator+(const TFactor< T > &g) const dai::TFactor< T > [inline]
operator+=(T x)dai::TFactor< T > [inline]
operator+=(const TFactor< T > &g)dai::TFactor< T > [inline]
operator-(T x) const dai::TFactor< T > [inline]
operator-(const TFactor< T > &g) const dai::TFactor< T > [inline]
operator-=(T x)dai::TFactor< T > [inline]
operator-=(const TFactor< T > &g)dai::TFactor< T > [inline]
operator/(T x) const dai::TFactor< T > [inline]
operator/(const TFactor< T > &g) const dai::TFactor< T > [inline]
operator/=(T x)dai::TFactor< T > [inline]
operator/=(const TFactor< T > &g)dai::TFactor< T > [inline]
operator<<(std::ostream &os, const TFactor< T > &f)dai::TFactor< T > [related]
operator[](size_t i) const dai::TFactor< T > [inline]
operator[](size_t i)dai::TFactor< T > [inline]
operator^(T x) const dai::TFactor< T > [inline]
operator^=(T x)dai::TFactor< T > [inline]
p() const dai::TFactor< T > [inline]
p()dai::TFactor< T > [inline]
randomize()dai::TFactor< T > [inline]
setUniform()dai::TFactor< T > [inline]
slice(const VarSet &vars, size_t varsState) const dai::TFactor< T > [inline]
states() const dai::TFactor< T > [inline]
strength(const Var &i, const Var &j) const dai::TFactor< T > [inline]
sum() const dai::TFactor< T > [inline]
TFactor(T p=1)dai::TFactor< T > [inline]
TFactor(const Var &v)dai::TFactor< T > [inline]
TFactor(const VarSet &vars)dai::TFactor< T > [inline]
TFactor(const VarSet &vars, T p)dai::TFactor< T > [inline]
TFactor(const VarSet &vars, const std::vector< S > &x)dai::TFactor< T > [inline]
TFactor(const VarSet &vars, const T *p)dai::TFactor< T > [inline]
TFactor(const VarSet &vars, const TProb< T > &p)dai::TFactor< T > [inline]
TFactor(const std::vector< Var > &vars, const std::vector< T > &p)dai::TFactor< T > [inline]
vars() const dai::TFactor< T > [inline]
vars()dai::TFactor< T > [inline]

Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1BP__dual_1_1messages-members.html0000644000263000017630000000506011334764773023744 0ustar jorismkyb libDAI: Member List

dai::BP_dual::messages Member List

This is the complete list of members for dai::BP_dual::messages, including all inherited members.

mdai::BP_dual::messages
ndai::BP_dual::messages
Zmdai::BP_dual::messages
Zndai::BP_dual::messages

Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1ExactInf-members.html0000644000263000017630000002463611334764773021403 0ustar jorismkyb libDAI: Member List

dai::ExactInf Member List

This is the complete list of members for dai::ExactInf, including all inherited members.

_beliefsFdai::ExactInf [private]
_beliefsVdai::ExactInf [private]
_logZdai::ExactInf [private]
backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
belief(const Var &v) const dai::ExactInf [inline, virtual]
belief(const VarSet &vs) const dai::ExactInf [virtual]
beliefF(size_t I) const dai::ExactInf [inline, virtual]
beliefs() const dai::ExactInf [virtual]
beliefV(size_t i) const dai::ExactInf [inline, virtual]
calcMarginal(const VarSet &vs) const dai::ExactInf
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clone() const dai::ExactInf [inline, virtual]
construct()dai::ExactInf [private]
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
ExactInf()dai::ExactInf [inline]
ExactInf(const FactorGraph &fg, const PropertySet &opts)dai::ExactInf [inline]
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
getProperties() const dai::ExactInf [virtual]
identify() const dai::ExactInf [virtual]
init()dai::ExactInf [virtual]
init(const VarSet &)dai::ExactInf [inline, virtual]
Iterations() const dai::ExactInf [inline, virtual]
logZ() const dai::ExactInf [inline, virtual]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
maxDiff() const dai::ExactInf [inline, virtual]
Namedai::ExactInf [static]
printProperties() const dai::ExactInf [virtual]
props (defined in dai::ExactInf)dai::ExactInf
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
run()dai::ExactInf [virtual]
setProperties(const PropertySet &opts)dai::ExactInf [virtual]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Feb 11 12:26:04 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1fo__plog0p.html0000644000263000017630000000717611334764773020515 0ustar jorismkyb libDAI: dai::fo_plog0p< T > Struct Template Reference

dai::fo_plog0p< T > Struct Template Reference

Function object that returns p*log0(p). More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &p) const
 Returns p * log0(p).

Detailed Description

template<typename T>
struct dai::fo_plog0p< T >

Function object that returns p*log0(p).

Member Function Documentation

template<typename T>
T dai::fo_plog0p< T >::operator() ( const T &  p  )  const [inline]

Returns p * log0(p).

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_137.png0000644000263000017630000000030011334764773015241 0ustar jorismkybPNG  IHDR 0PLTEppp```PPP@@@000 4tRNS@f>IDATc``z&?b?20D1T)#?KD̜0 D(JIIENDB`libDAI-0.2.4/doc/html/form_141.png0000644000263000017630000000030311334764773015237 0ustar jorismkybPNG  IHDRM0PLTEppp```PPP@@@000 4tRNS@fAIDATc`,er libDAI: Member List

dai::BBP Member List

This is the complete list of members for dai::BBP, including all inherited members.

_adj_b_Fdai::BBP [private]
_adj_b_F_unnormdai::BBP [private]
_adj_b_Vdai::BBP [private]
_adj_b_V_unnormdai::BBP [private]
_adj_mdai::BBP [private]
_adj_m_unnormdai::BBP [private]
_adj_ndai::BBP [private]
_adj_n_unnormdai::BBP [private]
_adj_psi_Fdai::BBP [private]
_adj_psi_Vdai::BBP [private]
_bp_dualdai::BBP [private]
_fgdai::BBP [private]
_iadai::BBP [private]
_ind_t typedefdai::BBP [private]
_index(size_t i, size_t _I) const dai::BBP [inline, private]
_indicesdai::BBP [private]
_init_adj_psi_Fdai::BBP [private]
_init_adj_psi_Vdai::BBP [private]
_itersdai::BBP [private]
_new_adj_mdai::BBP [private]
_new_adj_ndai::BBP [private]
_Rmsgdai::BBP [private]
_Smsgdai::BBP [private]
_Tmsgdai::BBP [private]
_Umsgdai::BBP [private]
adj_b_F(size_t I)dai::BBP [inline]
adj_b_F(size_t I) const dai::BBP [inline]
adj_b_V(size_t i)dai::BBP [inline]
adj_b_V(size_t i) const dai::BBP [inline]
adj_m(size_t i, size_t _I)dai::BBP [inline, private]
adj_m(size_t i, size_t _I) const dai::BBP [inline, private]
adj_n(size_t i, size_t _I)dai::BBP [inline, private]
adj_n(size_t i, size_t _I) const dai::BBP [inline, private]
adj_psi_F(size_t I)dai::BBP [inline]
adj_psi_F(size_t I) const dai::BBP [inline]
adj_psi_V(size_t i)dai::BBP [inline]
adj_psi_V(size_t i) const dai::BBP [inline]
BBP(const InfAlg *ia, const PropertySet &opts)dai::BBP [inline]
calcNewM(size_t i, size_t _I)dai::BBP [private]
calcNewN(size_t i, size_t _I)dai::BBP [private]
calcUnnormMsgM(size_t i, size_t _I)dai::BBP [private]
calcUnnormMsgN(size_t i, size_t _I)dai::BBP [private]
doParUpdate()dai::BBP [private]
getArgmaxMsgM(size_t &i, size_t &_I, Real &mag)dai::BBP [private]
getMaxMsgM()dai::BBP [private]
getMsgMags(Real &s, Real &new_s)dai::BBP [private]
getTotalMsgM()dai::BBP [private]
getTotalMsgN()dai::BBP [private]
getTotalNewMsgM()dai::BBP [private]
getUnMsgMag()dai::BBP [private]
getZeroAdjF(const FactorGraph &fg)dai::BBP [private]
getZeroAdjV(const FactorGraph &fg)dai::BBP [private]
incrSeqMsgM(size_t i, size_t _I, const Prob &p)dai::BBP [private]
init(const std::vector< Prob > &adj_b_V, const std::vector< Prob > &adj_b_F, const std::vector< Prob > &adj_psi_V, const std::vector< Prob > &adj_psi_F)dai::BBP [inline]
init(const std::vector< Prob > &adj_b_V, const std::vector< Prob > &adj_b_F)dai::BBP [inline]
init_F(const std::vector< Prob > &adj_b_F)dai::BBP [inline]
init_V(const std::vector< Prob > &adj_b_V)dai::BBP [inline]
initCostFnAdj(const BBPCostFunction &cfn, const std::vector< size_t > *stateP)dai::BBP
Iterations()dai::BBP [inline]
numericBBPTest(const InfAlg &bp, const std::vector< size_t > *state, const PropertySet &bbp_props, const BBPCostFunction &cfn, Real h)dai::BBP [related]
props (defined in dai::BBP)dai::BBP
R(size_t I, size_t _i, size_t _J)dai::BBP [inline, private]
R(size_t I, size_t _i, size_t _J) const dai::BBP [inline, private]
Regenerate()dai::BBP [private]
RegenerateInds()dai::BBP [private]
RegenerateInputs()dai::BBP [private]
RegenerateParMessageAdjoints()dai::BBP [private]
RegeneratePsiAdjoints()dai::BBP [private]
RegenerateR()dai::BBP [private]
RegenerateS()dai::BBP [private]
RegenerateSeqMessageAdjoints()dai::BBP [private]
RegenerateT()dai::BBP [private]
RegenerateU()dai::BBP [private]
run()dai::BBP
S(size_t i, size_t _I, size_t _j)dai::BBP [inline, private]
S(size_t i, size_t _I, size_t _j) const dai::BBP [inline, private]
sendSeqMsgM(size_t i, size_t _I)dai::BBP [private]
sendSeqMsgN(size_t i, size_t _I, const Prob &f)dai::BBP [private]
setSeqMsgM(size_t i, size_t _I, const Prob &p)dai::BBP [private]
T(size_t i, size_t _I)dai::BBP [inline, private]
T(size_t i, size_t _I) const dai::BBP [inline, private]
U(size_t I, size_t _i)dai::BBP [inline, private]
U(size_t I, size_t _i) const dai::BBP [inline, private]
unnormAdjoint(const Prob &w, Real Z_w, const Prob &adj_w)dai::BBP [private]
upMsgM(size_t i, size_t _I)dai::BBP [private]
upMsgN(size_t i, size_t _I)dai::BBP [private]

Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_0x75.html0000644000263000017630000001316111334764773016670 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- u -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_vars_0x64.html0000644000263000017630000001113511334764773017720 0ustar jorismkyb libDAI: Class Members - Variables
 

- d -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/terminology.html0000644000263000017630000003367311334764773016457 0ustar jorismkyb libDAI: Terminology and conventions

Terminology and conventions

Graphical models

Commonly used graphical models are Bayesian networks and Markov random fields. In libDAI, both types of graphical models are represented by a slightly more general type of graphical model: a factor graph [KFL01].

An example of a Bayesian network is:

inline_dotgraph_2.dot
The probability distribution of a Bayesian network factorizes as:

\[ P(\mathbf{x}) = \prod_{i\in\mathcal{V}} P(x_i \,|\, x_{\mathrm{pa}(i)}) \]

where $\mathrm{pa}(i)$ are the parents of node i in a DAG.

The same probability distribution can be represented as a Markov random field:

inline_dotgraph_3.dot

The probability distribution of a Markov random field factorizes as:

\[ P(\mathbf{x}) = \frac{1}{Z} \prod_{C\in\mathcal{C}} \psi_C(x_C) \]

where $ \mathcal{C} $ are the cliques of an undirected graph, $ \psi_C(x_C) $ are "potentials" or "compatibility functions", and $ Z $ is the partition sum which properly normalizes the probability distribution.

Finally, the same probability distribution can be represented as a factor graph:

inline_dotgraph_4.dot

The probability distribution of a factor graph factorizes as:

\[ P(\mathbf{x}) = \frac{1}{Z} \prod_{I\in \mathcal{F}} f_I(x_I) \]

where $ \mathcal{F} $ are the factor nodes of a factor graph (a bipartite graph consisting of variable nodes and factor nodes), $ f_I(x_I) $ are the factors, and $ Z $ is the partition sum which properly normalizes the probability distribution.

Looking at the expressions for the joint probability distributions, it is obvious that Bayesian networks and Markov random fields can both be easily represented as factor graphs. Factor graphs most naturally express the factorization structure of a probability distribution, and hence are a convenient representation for approximate inference algorithms, which all try to exploit this factorization. This is why libDAI uses a factor graph as representation of a graphical model, implemented in the dai::FactorGraph class.

Inference tasks

Given a factor graph, specified by the variable nodes $\{x_i\}_{i\in\mathcal{V}}$ the factor nodes $ \mathcal{F} $, the graph structure, and the factors $\{f_I(x_I)\}_{I\in\mathcal{F}}$, the following tasks are important:

  • Calculating the partition sum:

    \[ Z = \sum_{\mathbf{x}_{\mathcal{V}}} \prod_{I \in \mathcal{F}} f_I(x_I) \]

  • Calculating the marginal distribution of a subset of variables $\{x_i\}_{i\in A}$:

    \[ P(\mathbf{x}_{A}) = \frac{1}{Z} \sum_{\mathbf{x}_{\mathcal{V}\setminus A}} \prod_{I \in \mathcal{F}} f_I(x_I) \]

  • Calculating the MAP state which has the maximum probability mass:

    \[ \mathrm{argmax}_{\mathbf{x}}\,\prod_{I\in\mathcal{F}} f_I(x_I) \]

libDAI offers several inference algorithms, which solve (a subset of) these tasks either approximately or exactly, for factor graphs with discrete variables. The following algorithms are implemented:

Exact inference:

Approximate inference:

Not all inference tasks are implemented by each method: calculating MAP states is only possible with dai::JTree and dai::BP, calculating partition sums is not possible with dai::MR, dai::LC and dai::Gibbs.

Parameter learning

In addition, libDAI supports parameter learning of conditional probability tables by Expectation Maximization (or Maximum Likelihood, if there is no missing data). This is implemented in dai::EMAlg.

Variables and states

Linear states are a concept that is used often in libDAI, for example for storing and accessing factors, which are functions mapping from states of a set of variables to the real numbers. Internally, a factor is stored as an array, and the array index of an entry corresponds with the linear state of the set of variables. Below we will define variables, states and linear states of (sets of) variables.

Variables

Each (random) variable has a unique identifier, its label (which has a non-negative integer value). If two variables have the same label, they are considered as identical. A variable can take on a finite number of different values or states.

We use the following notational conventions. The discrete random variable with label $l$ is denoted as $x_l$, and the number of possible values of this variable as $S_{x_l}$ or simply $S_l$. The set of possible values of variable $x_l$ is denoted $X_l := \{0,1,\dots,S_l-1\}$ and called its state space.

Sets of variables and the canonical ordering

Let $A := \{x_{l_1},x_{l_2},\dots,x_{l_n}\}$ be a set of variables.

The canonical ordering of the variables in A is induced by their labels. That is: if $l_1 < l_2$, then $x_{l_1}$ occurs before $x_{l_2}$ in the canonical ordering. Below, we will assume that $(l_i)_{i=1}^n$ is ordered according to the canonical ordering, i.e., $l_1 < l_2 < \dots < l_n$.

States and linear states of sets of variables

A state of the variables in A refers to a joint assignment of the variables, or in other words, to an element of the Cartesian product $ \prod_{i=1}^n X_{l_i}$ of the state spaces of the variables in A. Note that a state can also be interpreted as a mapping from variables (or variable labels) to the natural numbers, which assigns to a variable (or its label) the corresponding state of the variable.

A state of n variables can be represented as an n-tuple of non-negative integers: $(s_1,s_2,\dots,s_n)$ corresponds to the joint assignment $x_{l_1} = s_1, \dots, x_{l_n} = s_n$. Alternatively, a state can be represented compactly as one non-negative integer; this representation is called a linear state. The linear state s corresponding to the state $(s_1,s_2,\dots,s_n)$ would be:

\[ s := \sum_{i=1}^n s_i \prod_{j=1}^{i-1} S_{l_j} = s_1 + s_2 S_{l_1} + s_3 S_{l_1} S_{l_2} + \dots + s_n S_{l_1} \cdots S_{l_{n-1}}. \]

Vice versa, given a linear state s for the variables A, the corresponding state $s_i$ of the i 'th variable $x_{l_i}$ (according to the canonical ordering of the variables in A) is given by

\[ s_i = \left\lfloor\frac{s \mbox { mod } \prod_{j=1}^i S_{l_j}}{\prod_{j=1}^{i-1} S_{l_j}}\right\rfloor. \]

Finally, the number of states of the set of variables A is simply the number of different joint assignments of the variables, that is, $\prod_{i=1}^n S_{l_i}$.

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/example__sprinkler_8cpp-example.html0000644000263000017630000002272011334764773022344 0ustar jorismkyb libDAI: example_sprinkler.cpp

example_sprinkler.cpp

This example illustrates how to manually construct a factor graph and write it to a file.

/*  This file is part of libDAI - http://www.libdai.org/
 *
 *  libDAI is licensed under the terms of the GNU General Public License version
 *  2, or (at your option) any later version. libDAI is distributed without any
 *  warranty. See the file COPYING for more details.
 *
 *  Copyright (C) 2008-2010  Joris Mooij  [joris dot mooij at libdai dot org]
 */


#include <dai/factorgraph.h>
#include <iostream>
#include <fstream>

using namespace std;
using namespace dai;

int main() {
    // This example program illustrates how to construct a factorgraph
    // by means of the sprinkler network example discussed at
    // http://www.cs.ubc.ca/~murphyk/Bayes/bnintro.html

    Var C(0, 2);  // Define binary variable Cloudy (with label 0)
    Var S(1, 2);  // Define binary variable Sprinkler (with label 1)
    Var R(2, 2);  // Define binary variable Rain (with label 2)
    Var W(3, 2);  // Define binary variable Wetgrass (with label 3)

    // Define probability distribution for C
    Factor P_C( C );
    P_C[0] = 0.5;   // C = 0
    P_C[1] = 0.5;   // C = 1

    // Define conditional probability of S given C
    Factor P_S_given_C( VarSet( S, C ) );
    P_S_given_C[0] = 0.5;   // C = 0, S = 0
    P_S_given_C[1] = 0.9;   // C = 1, S = 0
    P_S_given_C[2] = 0.5;   // C = 0, S = 1
    P_S_given_C[3] = 0.1;   // C = 1, S = 1

    // Define conditional probability of R given C
    Factor P_R_given_C( VarSet( R, C ) );
    P_R_given_C[0] = 0.8;   // C = 0, R = 0
    P_R_given_C[1] = 0.2;   // C = 1, R = 0
    P_R_given_C[2] = 0.2;   // C = 0, R = 1
    P_R_given_C[3] = 0.8;   // C = 1, R = 1

    // Define conditional probability of W given S and R
    Factor P_W_given_S_R( VarSet( S, R ) | W );
    P_W_given_S_R[0] = 1.0;  // S = 0, R = 0, W = 0
    P_W_given_S_R[1] = 0.1;  // S = 1, R = 0, W = 0
    P_W_given_S_R[2] = 0.1;  // S = 0, R = 1, W = 0
    P_W_given_S_R[3] = 0.01; // S = 1, R = 1, W = 0
    P_W_given_S_R[4] = 0.0;  // S = 0, R = 0, W = 1
    P_W_given_S_R[5] = 0.9;  // S = 1, R = 0, W = 1
    P_W_given_S_R[6] = 0.9;  // S = 0, R = 1, W = 1
    P_W_given_S_R[7] = 0.99; // S = 1, R = 1, W = 1

    // Build factor graph consisting of those four factors
    vector<Factor> SprinklerFactors;
    SprinklerFactors.push_back( P_C );
    SprinklerFactors.push_back( P_R_given_C );
    SprinklerFactors.push_back( P_S_given_C );
    SprinklerFactors.push_back( P_W_given_S_R );
    FactorGraph SprinklerNetwork( SprinklerFactors );

    // Write factorgraph to a file
    SprinklerNetwork.WriteToFile( "sprinkler.fg" );
    cout << "Sprinkler network written to sprinkler.fg" << endl;

    // Output some information about the factorgraph
    cout << SprinklerNetwork.nrVars() << " variables" << endl;
    cout << SprinklerNetwork.nrFactors() << " factors" << endl;

    // Calculate joint probability of all four variables
    Factor P;
    for( size_t I = 0; I < SprinklerNetwork.nrFactors(); I++ )
        P *= SprinklerNetwork.factor( I );
    // P.normalize();  // Not necessary: a Bayesian network is already normalized by definition

    // Calculate some probabilities
    Real denom = P.marginal( W )[1];
    cout << "P(W=1) = " << denom << endl;
    cout << "P(S=1 | W=1) = " << P.marginal( VarSet( S, W ) )[3] / denom << endl;
    cout << "P(R=1 | W=1) = " << P.marginal( VarSet( R, W ) )[3] / denom << endl;

    return 0;
}
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1Evidence-members.html0000644000263000017630000001127111334764773021413 0ustar jorismkyb libDAI: Member List

dai::Evidence Member List

This is the complete list of members for dai::Evidence, including all inherited members.

_samplesdai::Evidence [private]
addEvidenceTabFile(std::istream &is, FactorGraph &fg)dai::Evidence
addEvidenceTabFile(std::istream &is, std::map< std::string, Var > &varMap)dai::Evidence [private]
begin()dai::Evidence [inline]
begin() const dai::Evidence [inline]
const_iterator typedefdai::Evidence
end()dai::Evidence [inline]
end() const dai::Evidence [inline]
Evidence()dai::Evidence [inline]
Evidence(std::vector< Observation > &samples)dai::Evidence [inline]
iterator typedefdai::Evidence
nrSamples() const dai::Evidence [inline]
Observation typedefdai::Evidence

Generated on Thu Feb 11 12:26:03 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_60.png0000644000263000017630000000043411334764773015164 0ustar jorismkybPNG  IHDR60PLTEppp```PPP@@@000 4tRNS@fIDATc` PhFdj1Nc#f#-p 2r . p9 99/LHr,?r g䘠rB`d9|},/$TS1 i2p~@$_p9!ќr8& IENDB`libDAI-0.2.4/doc/html/files.html0000644000263000017630000002437711334764773015212 0ustar jorismkyb libDAI: File Index

File List

Here is a list of all documented files with brief descriptions:
include/dai/alldai.h [code]Main libDAI header file. It #includes all other libDAI headers
include/dai/bbp.h [code]Defines class BBP, which implements Back-Belief-Propagation
include/dai/bipgraph.h [code]Defines the BipartiteGraph class, which represents a bipartite graph
include/dai/bp.h [code]Defines class BP, which implements (Loopy) Belief Propagation
include/dai/bp_dual.h [code]Defines class BP_dual, which is used primarily by BBP
include/dai/cbp.h [code]Defines class CBP, which implements Conditioned Belief Propagation
include/dai/clustergraph.h [code]Defines class ClusterGraph, which is used by JTree, TreeEP and HAK
include/dai/daialg.h [code]Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG)
include/dai/doc.h [code]Contains additional doxygen documentation
include/dai/emalg.h [code]Defines classes related to Expectation Maximization (EMAlg, ParameterEstimation, CondProbEstimation and SharedParameters)
include/dai/enum.h [code]Defines the DAI_ENUM macro, which can be used to define an enum with additional functionality
include/dai/evidence.h [code]Defines class Evidence, which stores multiple observations of joint states of variables
include/dai/exactinf.h [code]Defines ExactInf class, which can be used for exact inference on small factor graphs
include/dai/exceptions.h [code]Defines the Exception class and macros for throwing exceptions and doing assertions
include/dai/factor.h [code]Defines TFactor<> and Factor classes which represent factors in probability distributions
include/dai/factorgraph.h [code]Defines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov random fields)
include/dai/fbp.h [code]Defines class FBP, which implements Fractional Belief Propagation
include/dai/gibbs.h [code]Defines class Gibbs, which implements Gibbs sampling
include/dai/graph.h [code]Defines the GraphAL class, which represents an undirected graph as an adjacency list
include/dai/hak.h [code]Defines class HAK, which implements a variant of Generalized Belief Propagation
include/dai/index.h [code]Defines the IndexFor, multifor, Permute and State classes, which all deal with indexing multi-dimensional arrays
include/dai/jtree.h [code]Defines class JTree, which implements the junction tree algorithm
include/dai/lc.h [code]Defines class LC, which implements loop corrections for approximate inference
include/dai/mf.h [code]Defines class MF which implements the Mean Field algorithm
include/dai/mr.h [code]Defines class MR, which implements loop corrections as proposed by Montanari and Rizzo
include/dai/prob.h [code]Defines TProb<> and Prob classes which represent (probability) vectors (e.g., probability distributions of discrete random variables)
include/dai/properties.h [code]Defines the Property and PropertySet classes, which are mainly used for managing parameters of inference algorithms
include/dai/regiongraph.h [code]Defines classes Region, FRegion and RegionGraph, which implement a particular subclass of region graphs
include/dai/smallset.h [code]Defines the SmallSet<> class, which represents a set (optimized for a small number of elements)
include/dai/treeep.h [code]Defines class TreeEP, which implements Tree Expectation Propagation
include/dai/trwbp.h [code]Defines class TRWBP, which implements Tree-Reweighted Belief Propagation
include/dai/util.h [code]Defines general utility functions and adds an abstraction layer for platform-dependent functionality
include/dai/var.h [code]Defines class Var, which represents a discrete random variable
include/dai/varset.h [code]Defines the VarSet class, which represents a set of random variables
include/dai/weightedgraph.h [code]Defines some utility functions for (weighted) undirected graphs, trees and rooted trees
include/dai/matlab/matlab.h [code]Defines some utility functions for interfacing with MatLab
Generated on Thu Feb 11 12:26:08 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_109.png0000644000263000017630000000030711334764773015247 0ustar jorismkybPNG  IHDRf00PLTEppp```PPP@@@000 4tRNS@fEIDATc`fyBs4@h^8xe(>(,@@)>PB+m> pIENDB`libDAI-0.2.4/doc/html/functions_func_0x6c.html0000644000263000017630000001372211334764773017763 0ustar jorismkyb libDAI: Class Members - Functions
 

- l -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_84.png0000644000263000017630000000025411334764773015172 0ustar jorismkybPNG  IHDR Ҏ0PLTEppp```PPP@@@000 4tRNS@f*IDATc`@*@5`! ll 3 y$ S  IENDB`libDAI-0.2.4/doc/html/prob_8h.html0000644000263000017630000002241011334764773015433 0ustar jorismkyb libDAI: include/dai/prob.h File Reference

include/dai/prob.h File Reference

Defines TProb<> and Prob classes which represent (probability) vectors (e.g., probability distributions of discrete random variables). More...

#include <cmath>
#include <vector>
#include <ostream>
#include <algorithm>
#include <numeric>
#include <functional>
#include <dai/util.h>
#include <dai/exceptions.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

struct  dai::fo_id< T >
 Function object that returns the value itself. More...
struct  dai::fo_abs< T >
 Function object that takes the absolute value. More...
struct  dai::fo_exp< T >
 Function object that takes the exponent. More...
struct  dai::fo_log< T >
 Function object that takes the logarithm. More...
struct  dai::fo_log0< T >
 Function object that takes the logarithm, except that log(0) is defined to be 0. More...
struct  dai::fo_inv< T >
 Function object that takes the inverse. More...
struct  dai::fo_inv0< T >
 Function object that takes the inverse, except that 1/0 is defined to be 0. More...
struct  dai::fo_plog0p< T >
 Function object that returns p*log0(p). More...
struct  dai::fo_divides0< T >
 Function object similar to std::divides(), but different in that dividing by zero results in zero. More...
struct  dai::fo_KL< T >
 Function object useful for calculating the KL distance. More...
struct  dai::fo_Hellinger< T >
 Function object useful for calculating the Hellinger distance. More...
struct  dai::fo_pow< T >
 Function object that returns x to the power y. More...
struct  dai::fo_max< T >
 Function object that returns the maximum of two values. More...
struct  dai::fo_min< T >
 Function object that returns the minimum of two values. More...
struct  dai::fo_absdiff< T >
 Function object that returns the absolute difference of x and y. More...
class  dai::TProb< T >
 Represents a vector with entries of type T. More...

Typedefs

typedef TProb< Real > dai::Prob
 Represents a vector with entries of type dai::Real.

Detailed Description

Defines TProb<> and Prob classes which represent (probability) vectors (e.g., probability distributions of discrete random variables).

Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1TreeEP.html0000644000263000017630000010467411334764773017377 0ustar jorismkyb libDAI: dai::TreeEP Class Reference

dai::TreeEP Class Reference

Approximate inference algorithm "Tree Expectation Propagation" [MiQ04]. More...

#include <dai/treeep.h>

Inheritance diagram for dai::TreeEP:

dai::JTree dai::DAIAlg< GRM > dai::InfAlg

List of all members.

Public Member Functions

 TreeEP ()
 Default constructor.
 TreeEP (const TreeEP &x)
 Copy constructor.
TreeEP & operator= (const TreeEP &x)
 Assignment operator.
 TreeEP (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts.
General InfAlg interface
virtual TreeEP * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
virtual std::string identify () const
 Identifies itself for logging purposes.
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).
virtual void init ()
 Initializes all data structures of the approximate inference algorithm.
virtual void init (const VarSet &)
 Initializes all data structures corresponding to some set of variables.
virtual Real run ()
 Runs the approximate inference algorithm.
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration.
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph).
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm.
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet.
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Public Attributes

struct dai::TreeEP::Properties props

Static Public Attributes

static const char * Name = "TREEEP"
 Name of this inference method.

Private Member Functions

void construct (const RootedTree &tree)
 Helper function for constructors.
bool offtree (size_t I) const
 Returns true if factor I is not part of the tree.

Private Attributes

Real _maxdiff
 Maximum difference encountered so far.
size_t _iters
 Number of iterations needed.
std::map< size_t, TreeEPSubTree > _Q
 Stores a TreeEPSubTree object for each off-tree factor.

Classes

struct  Properties
 Parameters for TreeEP. More...
class  TreeEPSubTree
 Stores the data structures needed to efficiently update the approximation of an off-tree factor. More...

Detailed Description

Approximate inference algorithm "Tree Expectation Propagation" [MiQ04].

Constructor & Destructor Documentation

dai::TreeEP::TreeEP (  )  [inline]

Default constructor.

dai::TreeEP::TreeEP ( const TreeEP &  x  )  [inline]

Copy constructor.

dai::TreeEP::TreeEP ( const FactorGraph &  fg,
const PropertySet &  opts 
)

Construct from FactorGraph fg and PropertySet opts.

Parameters:
opts Parameters
See also:
Properties
Note:
The factor graph has to be connected.
Exceptions:
FACTORGRAPH_NOT_CONNECTED if fg is not connected

Member Function Documentation

TreeEP& dai::TreeEP::operator= ( const TreeEP &  x  )  [inline]

Assignment operator.

virtual TreeEP* dai::TreeEP::clone (  )  const [inline, virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Reimplemented from dai::JTree.

string dai::TreeEP::identify (  )  const [virtual]

Identifies itself for logging purposes.

Reimplemented from dai::JTree.

Real dai::TreeEP::logZ (  )  const [virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::JTree.

void dai::TreeEP::init (  )  [virtual]

Initializes all data structures of the approximate inference algorithm.

Note:
This method should be called at least once before run() is called.

Reimplemented from dai::JTree.

virtual void dai::TreeEP::init ( const VarSet &  vs  )  [inline, virtual]

Initializes all data structures corresponding to some set of variables.

This method can be used to do a partial initialization after a part of the factor graph has changed. Instead of initializing all data structures, it only initializes those involving the variables in vs.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::JTree.

Real dai::TreeEP::run (  )  [virtual]

Runs the approximate inference algorithm.

Note:
Before run() is called the first time, init() should have been called.

Reimplemented from dai::JTree.

virtual Real dai::TreeEP::maxDiff (  )  const [inline, virtual]

Returns maximum difference between single variable beliefs in the last iteration.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::JTree.

virtual size_t dai::TreeEP::Iterations (  )  const [inline, virtual]

Returns number of iterations done (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::JTree.

void dai::TreeEP::setProperties ( const PropertySet &  opts  )  [virtual]

Set parameters of this inference algorithm.

The parameters are set according to the PropertySet opts. The values can be stored either as std::string or as the type of the corresponding MF::props member.

Reimplemented from dai::JTree.

PropertySet dai::TreeEP::getProperties (  )  const [virtual]

Returns parameters of this inference algorithm converted into a PropertySet.

Reimplemented from dai::JTree.

string dai::TreeEP::printProperties (  )  const [virtual]

Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Reimplemented from dai::JTree.

void dai::TreeEP::construct ( const RootedTree &  tree  )  [private]

Helper function for constructors.

bool dai::TreeEP::offtree ( size_t  I  )  const [inline, private]

Returns true if factor I is not part of the tree.

Member Data Documentation

Real dai::TreeEP::_maxdiff [private]

Maximum difference encountered so far.

size_t dai::TreeEP::_iters [private]

Number of iterations needed.

const char * dai::TreeEP::Name = "TREEEP" [static]

Name of this inference method.

Reimplemented from dai::JTree.

std::map<size_t, TreeEPSubTree> dai::TreeEP::_Q [private]

Stores a TreeEPSubTree object for each off-tree factor.

The documentation for this class was generated from the following files:
Generated on Thu Feb 11 12:26:07 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1sequentialVariableElimination-members.html0000644000263000017630000000561511334764773025707 0ustar jorismkyb libDAI: Member List

dai::sequentialVariableElimination Member List

This is the complete list of members for dai::sequentialVariableElimination, including all inherited members.

idai::sequentialVariableElimination [private]
operator()(const ClusterGraph &cl, const std::set< size_t > &)dai::sequentialVariableElimination
seqdai::sequentialVariableElimination [private]
sequentialVariableElimination(const std::vector< Var > s)dai::sequentialVariableElimination [inline]

Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/bp_8h.html0000644000263000017630000000674711334764773015111 0ustar jorismkyb libDAI: include/dai/bp.h File Reference

include/dai/bp.h File Reference

Defines class BP, which implements (Loopy) Belief Propagation. More...

#include <string>
#include <dai/daialg.h>
#include <dai/factorgraph.h>
#include <dai/properties.h>
#include <dai/enum.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::BP
 Approximate inference algorithm "(Loopy) Belief Propagation". More...
struct  dai::BP::EdgeProp
 Type used for storing edge properties. More...
struct  dai::BP::Properties
 Parameters for BP. More...

Detailed Description

Defines class BP, which implements (Loopy) Belief Propagation.

Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1fo__divides0-members.html0000644000263000017630000000363611334764773022450 0ustar jorismkyb libDAI: Member List

dai::fo_divides0< T > Member List

This is the complete list of members for dai::fo_divides0< T >, including all inherited members.

operator()(const T &x, const T &y) const dai::fo_divides0< T > [inline]

Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_140.png0000644000263000017630000000136011334764773015242 0ustar jorismkybPNG  IHDR)u0PLTEppp```PPP@@@000 4tRNS@fnIDAT8MhAQvSl5?BA<4 B/R=ljSR%^Cx= xGm+K&1&=؝}ͼ}3$ \pmH F鍠aό>6͹ tG #NA~ PF㿂qtΥqa)c`>> =f@y4C3xv@f Z¾To3^mHnSlNM3xsvӴ&ژ kSSkߴmB2 : DQRr>F ]sTeMb>:j ×U3x+&/fӂʊaaLdslI,CCj ?ګyҗcy>pky:Ō`Oj c,# 9[5Z ;g^y*! [m <8qVV+7\u=XJN$;WJR3Z48g'^E)'\teLXp9dEQV32C|ʶrʊ (BؒIENDB`libDAI-0.2.4/doc/html/functions_func_0x62.html0000644000263000017630000002352011334764773017677 0ustar jorismkyb libDAI: Class Members - Functions
 

- b -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1fo__divides0.html0000644000263000017630000001011411334764773021005 0ustar jorismkyb libDAI: dai::fo_divides0< T > Struct Template Reference

dai::fo_divides0< T > Struct Template Reference

Function object similar to std::divides(), but different in that dividing by zero results in zero. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &x, const T &y) const
 Returns (y == 0 ? 0 : (x / y)).

Detailed Description

template<typename T>
struct dai::fo_divides0< T >

Function object similar to std::divides(), but different in that dividing by zero results in zero.

Member Function Documentation

template<typename T>
T dai::fo_divides0< T >::operator() ( const T &  x,
const T &  y 
) const [inline]

Returns (y == 0 ? 0 : (x / y)).

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1BBPCostFunction.html0000644000263000017630000002220411334764773021201 0ustar jorismkyb libDAI: dai::BBPCostFunction Class Reference

dai::BBPCostFunction Class Reference

Predefined cost functions that can be used with BBP. More...

#include <dai/bbp.h>

List of all members.

Public Member Functions

 BBPCostFunction ()
 Default constructor.
 BBPCostFunction (const BBPCostFunctionBase &x)
 Construct from BBPCostFunctionBase x.
bool needGibbsState () const
 Returns whether this cost function depends on having a Gibbs state.
Real evaluate (const InfAlg &ia, const std::vector< size_t > *stateP) const
 Evaluates cost function in state stateP using the information in inference algorithm ia.
BBPCostFunction & operator= (const BBPCostFunctionBase &x)
 Assignment operator.

Detailed Description

Predefined cost functions that can be used with BBP.

Constructor & Destructor Documentation

dai::BBPCostFunction::BBPCostFunction (  )  [inline]

Default constructor.

dai::BBPCostFunction::BBPCostFunction ( const BBPCostFunctionBase &  x  )  [inline]

Construct from BBPCostFunctionBase x.

Member Function Documentation

bool dai::BBPCostFunction::needGibbsState (  )  const

Returns whether this cost function depends on having a Gibbs state.

Real dai::BBPCostFunction::evaluate ( const InfAlg &  ia,
const std::vector< size_t > *  stateP 
) const

Evaluates cost function in state stateP using the information in inference algorithm ia.

BBPCostFunction& dai::BBPCostFunction::operator= ( const BBPCostFunctionBase &  x  )  [inline]

Assignment operator.

The documentation for this class was generated from the following files:
  • include/dai/bbp.h
  • src/bbp.cpp
Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_100.png0000644000263000017630000000062611334764773015242 0ustar jorismkybPNG  IHDR7@\0PLTEppp```PPP@@@000 4tRNS@fIDATc` 0 ecaCac"sdvKl/Zr4$Y I/F.@ddJ>IENDB`libDAI-0.2.4/doc/html/classdai_1_1hash__map.html0000644000263000017630000000526711334764773020170 0ustar jorismkyb libDAI: dai::hash_map< T, U, H > Class Template Reference

dai::hash_map< T, U, H > Class Template Reference

hash_map is an alias for std::tr1::unordered_map. More...

#include <dai/util.h>

Detailed Description

template<typename T, typename U, typename H = boost::hash<T>>
class dai::hash_map< T, U, H >

hash_map is an alias for std::tr1::unordered_map.

We use the (experimental) TR1 unordered_map implementation included in modern GCC distributions or in boost versions 1.37 and higher.

The documentation for this class was generated from the following file:
Generated on Thu Feb 11 12:26:08 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_101.png0000644000263000017630000000030111334764773015231 0ustar jorismkybPNG  IHDR Rio0PLTEppp```PPP@@@000 4tRNS@f?IDATc`R 4Q&c cCcW b|d`d9b,fh,1\@@ 9.IENDB`libDAI-0.2.4/doc/html/form_94.png0000644000263000017630000000032611334764773015173 0ustar jorismkybPNG  IHDR <0PLTEppp```PPP@@@000 4tRNS@fTIDATc`@ M G~5`V O`VAˏ`[bq*+ eddw.xIENDB`libDAI-0.2.4/doc/html/form_80.png0000644000263000017630000000206611334764773015171 0ustar jorismkybPNG  IHDR"{0PLTEppp```PPP@@@000 4tRNS@fIDATXWϋIttYCKv<=hV, EtYۃ7AQ<-qw<8M̀#U֎26^{}u&{A\.O=H[G5Se&)ZOT́ϒ#]{࠷Yr OA/޶>!4YrPjd㌎\ g{)뱶 C9xS8*Wh0Glʉkg7"=D>A6r(RM}BϞP.(R7 -=qz<4} vގ&puX_؅U3 #:ZzB"zxط ZTh@3,R\C9hް2E X (HQ+5pηmۂ9,ӄZA)t,@mPq libDAI: dai::BP::Properties Struct Reference

dai::BP::Properties Struct Reference

Parameters for BP. More...

#include <dai/bp.h>

List of all members.

Public Member Functions

 DAI_ENUM (UpdateType, SEQFIX, SEQRND, SEQMAX, PARALL)
 Enumeration of possible update schedules.
 DAI_ENUM (InfType, SUMPROD, MAXPROD)
 Enumeration of inference variants.

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr).
size_t maxiter
 Maximum number of iterations.
Real tol
 Tolerance for convergence test.
bool logdomain
 Whether updates should be done in logarithmic domain or not.
Real damping
 Damping constant (0.0 means no damping, 1.0 is maximum damping).
UpdateType updates
 Message update schedule.
InfType inference
 Inference variant.

Detailed Description

Parameters for BP.

Member Function Documentation

dai::BP::Properties::DAI_ENUM ( UpdateType  ,
SEQFIX  ,
SEQRND  ,
SEQMAX  ,
PARALL   
)

Enumeration of possible update schedules.

The following update schedules have been defined:

  • PARALL parallel updates
  • SEQFIX sequential updates using a fixed sequence
  • SEQRND sequential updates using a random sequence
  • SEQMAX maximum-residual updates [EMK06]

dai::BP::Properties::DAI_ENUM ( InfType  ,
SUMPROD  ,
MAXPROD   
)

Enumeration of inference variants.

There are two inference variants:

  • SUMPROD Sum-Product
  • MAXPROD Max-Product (equivalent to Min-Sum)

Member Data Documentation

size_t dai::BP::Properties::verbose

Verbosity (amount of output sent to stderr).

size_t dai::BP::Properties::maxiter

Maximum number of iterations.

Real dai::BP::Properties::tol

Tolerance for convergence test.

bool dai::BP::Properties::logdomain

Whether updates should be done in logarithmic domain or not.

Real dai::BP::Properties::damping

Damping constant (0.0 means no damping, 1.0 is maximum damping).

UpdateType dai::BP::Properties::updates

Message update schedule.

InfType dai::BP::Properties::inference

Inference variant.

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1TreeEP-members.html0000644000263000017630000003437011334764773021022 0ustar jorismkyb libDAI: Member List

dai::TreeEP Member List

This is the complete list of members for dai::TreeEP, including all inherited members.

_itersdai::TreeEP [private]
_maxdiffdai::TreeEP [private]
_Qdai::TreeEP [private]
backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
belief(const VarSet &vs) const dai::JTree [virtual]
dai::DAIAlg::belief(const Var &v) const dai::InfAlg [inline, virtual]
beliefF(size_t I) const dai::InfAlg [inline, virtual]
beliefs() const dai::JTree [virtual]
beliefV(size_t i) const dai::InfAlg [inline, virtual]
boundTreewidth(const FactorGraph &fg, greedyVariableElimination::eliminationCostFunction fn)dai::JTree [related]
calcMarginal(const VarSet &vs)dai::JTree
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clone() const dai::TreeEP [inline, virtual]
construct(const RootedTree &tree)dai::TreeEP [private]
dai::JTree::construct(const std::vector< VarSet > &cl, bool verify=false)dai::JTree
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
findEfficientTree(const VarSet &vs, RootedTree &Tree, size_t PreviousRoot=(size_t)-1) const dai::JTree
findMaximum() const dai::JTree
GenerateJT(const std::vector< VarSet > &cl)dai::JTree
getProperties() const dai::TreeEP [virtual]
identify() const dai::TreeEP [virtual]
init()dai::TreeEP [virtual]
init(const VarSet &)dai::TreeEP [inline, virtual]
Iterations() const dai::TreeEP [inline, virtual]
JTree()dai::JTree [inline]
JTree(const FactorGraph &fg, const PropertySet &opts, bool automatic=true)dai::JTree
logZ() const dai::TreeEP [virtual]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
maxDiff() const dai::TreeEP [inline, virtual]
message(size_t alpha, size_t _beta) const dai::JTree [inline]
message(size_t alpha, size_t _beta)dai::JTree [inline]
Namedai::TreeEP [static]
offtree(size_t I) const dai::TreeEP [inline, private]
operator=(const TreeEP &x)dai::TreeEP [inline]
printProperties() const dai::TreeEP [virtual]
props (defined in dai::TreeEP)dai::TreeEP
Qadai::JTree
Qbdai::JTree
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
RTreedai::JTree
run()dai::TreeEP [virtual]
runHUGIN()dai::JTree
runShaferShenoy()dai::JTree
setProperties(const PropertySet &opts)dai::TreeEP [virtual]
TreeEP()dai::TreeEP [inline]
TreeEP(const TreeEP &x)dai::TreeEP [inline]
TreeEP(const FactorGraph &fg, const PropertySet &opts)dai::TreeEP
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Feb 11 12:26:07 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_0x65.html0000644000263000017630000002066411334764773016675 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- e -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1VarSet.png0000644000263000017630000000104311334764773017261 0ustar jorismkybPNG  IHDRr1PLTE`{tRNS@fIDATX]n0 =Ǿlγ'%vZ"`A%qg}9|/.q}KĴ!HLBMdEr Jlʐ2ɚ$Vbq,QcbOR2(k!P`;rL$r8&we.n*Nms#>\^NKm4H#|d>$ԋwu,2{2W?$` _;{H)QL+D*鼗h`}m5d1 jmA*Pf9O͑'5H#4rg+$(Mipmda`krH;HR%TI_MiI*]*dQZHD{ȅ^]+앖ڎ->cɀ[I+''?҆A*pIENDB`libDAI-0.2.4/doc/html/namespacemembers_vars.html0000644000263000017630000000365311334764773020444 0ustar jorismkyb libDAI: Class Members
 

  • _normal_dist : dai
  • DAINames : dai
Generated on Thu Feb 11 12:26:08 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1InfAlg-members.html0000644000263000017630000001725111334764773021035 0ustar jorismkyb libDAI: Member List

dai::InfAlg Member List

This is the complete list of members for dai::InfAlg, including all inherited members.

backupFactor(size_t I)=0dai::InfAlg [pure virtual]
backupFactors(const VarSet &vs)=0dai::InfAlg [pure virtual]
belief(const Var &v) const dai::InfAlg [inline, virtual]
belief(const VarSet &vs) const =0dai::InfAlg [pure virtual]
beliefF(size_t I) const dai::InfAlg [inline, virtual]
beliefs() const =0dai::InfAlg [pure virtual]
beliefV(size_t i) const dai::InfAlg [inline, virtual]
clamp(size_t i, size_t x, bool backup=false)=0dai::InfAlg [pure virtual]
clone() const =0dai::InfAlg [pure virtual]
fg()=0dai::InfAlg [pure virtual]
fg() const =0dai::InfAlg [pure virtual]
getProperties() const =0dai::InfAlg [pure virtual]
identify() const =0dai::InfAlg [pure virtual]
init()=0dai::InfAlg [pure virtual]
init(const VarSet &vs)=0dai::InfAlg [pure virtual]
Iterations() const =0dai::InfAlg [pure virtual]
logZ() const =0dai::InfAlg [pure virtual]
makeCavity(size_t i, bool backup=false)=0dai::InfAlg [pure virtual]
maxDiff() const =0dai::InfAlg [pure virtual]
printProperties() const =0dai::InfAlg [pure virtual]
restoreFactor(size_t I)=0dai::InfAlg [pure virtual]
restoreFactors(const VarSet &vs)=0dai::InfAlg [pure virtual]
run()=0dai::InfAlg [pure virtual]
setProperties(const PropertySet &opts)=0dai::InfAlg [pure virtual]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Feb 11 12:26:03 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_88.png0000644000263000017630000000117111334764773015175 0ustar jorismkybPNG  IHDR+(0PLTEppp```PPP@@@000 4tRNS@fIDAT8c`eʙ3i9 WUV>;6mlgd# 0'08 (|j>9\."/@Uɜ Lwkos3;8f00$|?00k#0؄j2yb|&OW~h1\CtP  at@SoҀ0_^l{  @9/0%0xAdSc g9k/00x$.psl" : `Jf"Np8s;dSH81@$Ĝvpj 4 0!sCJ(5ؗ10S9|r$BNVaxr;j8t ;l?'G4 , ĜL2˪ ^ a|MejH0Y!B( @$ pȾIENDB`libDAI-0.2.4/doc/html/form_0.png0000644000263000017630000000101511334764773015072 0ustar jorismkybPNG  IHDRGO0PLTEppp```PPP@@@000 4tRNS@fIDAT(J@'6il[B**b!P[=Ѣ7+xSb)OPЂx>]J5?؝%| O ِC)1O|0*0 kF-CZ5C `>QLA {NJ+a<;ĈqQU~FźZf#h,"-^.9aWalP/+TjNg-.␐ e%g-J4 lܛI)ӺILzC=4lB{fwfNꒃ'Ȓ1+ٛ@pbJgu$Wj:oԖSC ĒlWWPg"&xٰ{Me5,~[؁Xg-Sf6IENDB`libDAI-0.2.4/doc/html/functions_vars_0x68.html0000644000263000017630000000761611334764773017735 0ustar jorismkyb libDAI: Class Members - Variables
 

- h -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1BP__dual.html0000644000263000017630000012545611334764773017721 0ustar jorismkyb libDAI: dai::BP_dual Class Reference

dai::BP_dual Class Reference

Calculates both types of BP messages and their normalizers from an InfAlg. More...

#include <dai/bp_dual.h>

List of all members.

Public Member Functions

 BP_dual (const InfAlg *ia)
 Construct BP_dual object from (converged) InfAlg object's beliefs and factors.
const FactorGraph & fg () const
 Returns the underlying FactorGraph.
Prob & msgM (size_t i, size_t _I)
 Returns reference to factor->variable message (I -> i).
const Prob & msgM (size_t i, size_t _I) const
 Returns constant reference to factor->variable message (I -> i).
Prob & msgN (size_t i, size_t _I)
 Returns reference to variable -> factor message (i -> I).
const Prob & msgN (size_t i, size_t _I) const
 Returns constant reference to variable -> factor message (i -> I).
Real & zM (size_t i, size_t _I)
 Returns reference to normalizer for factor->variable message (I -> i).
const Real & zM (size_t i, size_t _I) const
 Returns constant reference to normalizer for factor->variable message (I -> i).
Real & zN (size_t i, size_t _I)
 Returns reference to normalizer for variable -> factor message (i -> I).
const Real & zN (size_t i, size_t _I) const
 Returns constant reference to normalizer for variable -> factor message (i -> I).
Factor beliefV (size_t i) const
 Returns belief of variable i.
Factor beliefF (size_t I) const
 Returns belief of factor I.
Real beliefVZ (size_t i) const
 Returns normalizer for belief of variable i.
Real beliefFZ (size_t I) const
 Returns normalizer for belief of factor I.

Protected Member Functions

void init ()
 Does all necessary preprocessing.
void regenerateMessages ()
 Allocates space for _msgs.
void regenerateBeliefs ()
 Allocates space for _beliefs.
void calcMessages ()
 Calculate all messages from InfAlg beliefs.
void calcNewM (size_t i, size_t _I)
 Update factor->variable message (i -> I).
void calcNewN (size_t i, size_t _I)
 Update variable->factor message (I -> i).
void calcBeliefs ()
 Calculate all variable and factor beliefs from messages.
void calcBeliefV (size_t i)
 Calculate belief of variable i.
void calcBeliefF (size_t I)
 Calculate belief of factor I.

Protected Attributes

messages _msgs
 Stores all messages.
beliefs _beliefs
 Stores all beliefs.
const InfAlg * _ia
 Pointer to the InfAlg object.

Classes

struct  _edges_t
 Convenience label for storing edge properties. More...
struct  beliefs
 Groups together the data structures for storing the two types of beliefs and their normalizers. More...
struct  messages
 Groups together the data structures for storing the two types of messages and their normalizers. More...

Detailed Description

Calculates both types of BP messages and their normalizers from an InfAlg.

BP_dual calculates "dual" versions of BP messages (both messages from factors to variables and messages from variables to factors), and normalizers, given an InfAlg. These are computed from the variable and factor beliefs of the InfAlg. This class is used primarily by BBP.

Author:
Frederik Eaton

Constructor & Destructor Documentation

dai::BP_dual::BP_dual ( const InfAlg *  ia  )  [inline]

Construct BP_dual object from (converged) InfAlg object's beliefs and factors.

Warning:
A pointer to the the InfAlg object is stored, so the object must not be destroyed before the BP_dual is destroyed.

Member Function Documentation

void dai::BP_dual::init (  )  [protected]

Does all necessary preprocessing.

void dai::BP_dual::regenerateMessages (  )  [protected]

Allocates space for _msgs.

void dai::BP_dual::regenerateBeliefs (  )  [protected]

Allocates space for _beliefs.

void dai::BP_dual::calcMessages (  )  [protected]

Calculate all messages from InfAlg beliefs.

void dai::BP_dual::calcNewM ( size_t  i,
size_t  _I 
) [protected]

Update factor->variable message (i -> I).

void dai::BP_dual::calcNewN ( size_t  i,
size_t  _I 
) [protected]

Update variable->factor message (I -> i).

void dai::BP_dual::calcBeliefs (  )  [protected]

Calculate all variable and factor beliefs from messages.

void dai::BP_dual::calcBeliefV ( size_t  i  )  [protected]

Calculate belief of variable i.

void dai::BP_dual::calcBeliefF ( size_t  I  )  [protected]

Calculate belief of factor I.

const FactorGraph& dai::BP_dual::fg (  )  const [inline]

Returns the underlying FactorGraph.

Prob& dai::BP_dual::msgM ( size_t  i,
size_t  _I 
) [inline]

Returns reference to factor->variable message (I -> i).

const Prob& dai::BP_dual::msgM ( size_t  i,
size_t  _I 
) const [inline]

Returns constant reference to factor->variable message (I -> i).

Prob& dai::BP_dual::msgN ( size_t  i,
size_t  _I 
) [inline]

Returns reference to variable -> factor message (i -> I).

const Prob& dai::BP_dual::msgN ( size_t  i,
size_t  _I 
) const [inline]

Returns constant reference to variable -> factor message (i -> I).

Real& dai::BP_dual::zM ( size_t  i,
size_t  _I 
) [inline]

Returns reference to normalizer for factor->variable message (I -> i).

const Real& dai::BP_dual::zM ( size_t  i,
size_t  _I 
) const [inline]

Returns constant reference to normalizer for factor->variable message (I -> i).

Real& dai::BP_dual::zN ( size_t  i,
size_t  _I 
) [inline]

Returns reference to normalizer for variable -> factor message (i -> I).

const Real& dai::BP_dual::zN ( size_t  i,
size_t  _I 
) const [inline]

Returns constant reference to normalizer for variable -> factor message (i -> I).

Factor dai::BP_dual::beliefV ( size_t  i  )  const [inline]

Returns belief of variable i.

Factor dai::BP_dual::beliefF ( size_t  I  )  const [inline]

Returns belief of factor I.

Real dai::BP_dual::beliefVZ ( size_t  i  )  const [inline]

Returns normalizer for belief of variable i.

Real dai::BP_dual::beliefFZ ( size_t  I  )  const [inline]

Returns normalizer for belief of factor I.

Member Data Documentation

messages dai::BP_dual::_msgs [protected]

Stores all messages.

beliefs dai::BP_dual::_beliefs [protected]

Stores all beliefs.

const InfAlg* dai::BP_dual::_ia [protected]

Pointer to the InfAlg object.

The documentation for this class was generated from the following files:
Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1greedyVariableElimination.html0000644000263000017630000002300611334764773023356 0ustar jorismkyb libDAI: dai::greedyVariableElimination Class Reference

dai::greedyVariableElimination Class Reference

Helper object for dai::ClusterGraph::VarElim(). More...

#include <dai/clustergraph.h>

List of all members.

Public Types

typedef size_t(* eliminationCostFunction )(const ClusterGraph &, size_t)
 Type of cost functions to be used for greedy variable elimination.

Public Member Functions

 greedyVariableElimination (eliminationCostFunction h)
 Construct from cost function.
size_t operator() (const ClusterGraph &cl, const std::set< size_t > &remainingVars)
 Returns the best variable from remainingVars to eliminate in the cluster graph cl by greedily minimizing the cost function.

Private Attributes

eliminationCostFunction heuristic
 Pointer to the cost function used.

Detailed Description

Helper object for dai::ClusterGraph::VarElim().

Chooses the next variable to eliminate greedily by taking the one that minimizes a given heuristic cost function.

Member Typedef Documentation

typedef size_t(* dai::greedyVariableElimination::eliminationCostFunction)(const ClusterGraph &, size_t)

Type of cost functions to be used for greedy variable elimination.

Constructor & Destructor Documentation

dai::greedyVariableElimination::greedyVariableElimination ( eliminationCostFunction  h  )  [inline]

Construct from cost function.

Note:
Examples of cost functions are eliminationCost_MinFill() and eliminationCost_WeightedMinFill().

Member Function Documentation

size_t dai::greedyVariableElimination::operator() ( const ClusterGraph &  cl,
const std::set< size_t > &  remainingVars 
)

Returns the best variable from remainingVars to eliminate in the cluster graph cl by greedily minimizing the cost function.

This function calculates the cost for eliminating each variable in remaingVars and returns the variable which has lowest cost.

Member Data Documentation

eliminationCostFunction dai::greedyVariableElimination::heuristic [private]

Pointer to the cost function used.

The documentation for this class was generated from the following files:
Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_vars_0x6e.html0000644000263000017630000001314411334764773020003 0ustar jorismkyb libDAI: Class Members - Variables
 

- n -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1JTree.png0000644000263000017630000000126111334764773017070 0ustar jorismkybPNG  IHDRPLTE`{tRNS@fGIDAThR0 `gAfbdx,'baLuxZ/81 Y r," LeЮv libDAI: include/dai/bp_dual.h File Reference

include/dai/bp_dual.h File Reference

Defines class BP_dual, which is used primarily by BBP. More...

#include <dai/daialg.h>
#include <dai/factorgraph.h>
#include <dai/enum.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::BP_dual
 Calculates both types of BP messages and their normalizers from an InfAlg. More...
struct  dai::BP_dual::_edges_t< T >
 Convenience label for storing edge properties. More...
struct  dai::BP_dual::messages
 Groups together the data structures for storing the two types of messages and their normalizers. More...
struct  dai::BP_dual::beliefs
 Groups together the data structures for storing the two types of beliefs and their normalizers. More...

Detailed Description

Defines class BP_dual, which is used primarily by BBP.

Idea:
BP_dual replicates a large part of the functionality of BP; would it not be more efficient to adapt BP instead?
Author:
Frederik Eaton
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_func_0x73.html0000644000263000017630000002403411334764773017702 0ustar jorismkyb libDAI: Class Members - Functions
 

- s -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/matlab_8h.html0000644000263000017630000000645711334764773015746 0ustar jorismkyb libDAI: include/dai/matlab/matlab.h File Reference

include/dai/matlab/matlab.h File Reference

Defines some utility functions for interfacing with MatLab. More...

#include "mex.h"
#include <dai/factor.h>

Go to the source code of this file.

Namespaces

namespace  dai

Functions

mxArray * dai::Factors2mx (const std::vector< Factor > &Ps)
 Convert vector<Factor> structure to a cell vector of CPTAB-like structs.
vector< Factor > dai::mx2Factors (const mxArray *psi, long verbose)
 Convert cell vector of CPTAB-like structs to vector<Factor>.
Factor dai::mx2Factor (const mxArray *psi)
 Convert CPTAB-like struct to Factor.

Detailed Description

Defines some utility functions for interfacing with MatLab.

Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_vars_0x6f.html0000644000263000017630000000736311334764773020012 0ustar jorismkyb libDAI: Class Members - Variables
 

- o -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_func_0x6b.html0000644000263000017630000001016711334764773017762 0ustar jorismkyb libDAI: Class Members - Functions
 

- k -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1fo__abs.html0000644000263000017630000000711711334764773020054 0ustar jorismkyb libDAI: dai::fo_abs< T > Struct Template Reference

dai::fo_abs< T > Struct Template Reference

Function object that takes the absolute value. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &x) const
 Returns abs(x).

Detailed Description

template<typename T>
struct dai::fo_abs< T >

Function object that takes the absolute value.

Member Function Documentation

template<typename T>
T dai::fo_abs< T >::operator() ( const T &  x  )  const [inline]

Returns abs(x).

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1MaximizationStep.html0000644000263000017630000004766011334764773021561 0ustar jorismkyb libDAI: dai::MaximizationStep Class Reference

dai::MaximizationStep Class Reference

A MaximizationStep groups together several parameter estimation tasks (SharedParameters objects) into a single unit. More...

#include <dai/emalg.h>

List of all members.

Iterator interface

typedef std::vector
< SharedParameters >::iterator 		iterator
 Iterator over the parameter estimation tasks.
typedef std::vector
< SharedParameters >
::const_iterator 		const_iterator
 Constant iterator over the parameter estimation tasks.
iterator begin ()
 Returns iterator that points to the first parameter estimation task.
const_iterator begin () const
 Returns constant iterator that points to the first parameter estimation task.
iterator end ()
 Returns iterator that points beyond the last parameter estimation task.
const_iterator end () const
 Returns constant iterator that points beyond the last parameter estimation task.

Public Member Functions

 MaximizationStep ()
 Default constructor.
 MaximizationStep (std::vector< SharedParameters > &maximizations)
 Construct MaximizationStep from a vector of parameter estimation tasks.
 MaximizationStep (std::istream &is, const FactorGraph &fg_varlookup)
 Constructor from an input stream and a corresponding factor graph.
void addExpectations (InfAlg &alg)
 Collect the beliefs from this InfAlg as expectations for the next Maximization step.
void maximize (FactorGraph &fg)
 Using all of the currently added expectations, make new factors with maximized parameters and set them in the FactorGraph.

Private Attributes

std::vector< SharedParameters > _params
 Vector of parameter estimation tasks of which this maximization step consists.

Detailed Description

A MaximizationStep groups together several parameter estimation tasks (SharedParameters objects) into a single unit.

Author:
Charles Vaske

Member Typedef Documentation

typedef std::vector<SharedParameters>::iterator dai::MaximizationStep::iterator

Iterator over the parameter estimation tasks.

typedef std::vector<SharedParameters>::const_iterator dai::MaximizationStep::const_iterator

Constant iterator over the parameter estimation tasks.

Constructor & Destructor Documentation

dai::MaximizationStep::MaximizationStep (  )  [inline]

Default constructor.

dai::MaximizationStep::MaximizationStep ( std::vector< SharedParameters > &  maximizations  )  [inline]

Construct MaximizationStep from a vector of parameter estimation tasks.

dai::MaximizationStep::MaximizationStep ( std::istream &  is,
const FactorGraph &  fg_varlookup 
)

Constructor from an input stream and a corresponding factor graph.

See also:
Maximization Step block format

Member Function Documentation

void dai::MaximizationStep::addExpectations ( InfAlg &  alg  ) 

Collect the beliefs from this InfAlg as expectations for the next Maximization step.

void dai::MaximizationStep::maximize ( FactorGraph &  fg  ) 

Using all of the currently added expectations, make new factors with maximized parameters and set them in the FactorGraph.

iterator dai::MaximizationStep::begin (  )  [inline]

Returns iterator that points to the first parameter estimation task.

const_iterator dai::MaximizationStep::begin (  )  const [inline]

Returns constant iterator that points to the first parameter estimation task.

iterator dai::MaximizationStep::end (  )  [inline]

Returns iterator that points beyond the last parameter estimation task.

const_iterator dai::MaximizationStep::end (  )  const [inline]

Returns constant iterator that points beyond the last parameter estimation task.

Member Data Documentation

std::vector<SharedParameters> dai::MaximizationStep::_params [private]

Vector of parameter estimation tasks of which this maximization step consists.

The documentation for this class was generated from the following files:
Generated on Thu Feb 11 12:26:03 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/doc_8h-source.html0000644000263000017630000000414311334764773016537 0ustar jorismkyb libDAI: include/dai/doc.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_func_0x77.html0000644000263000017630000001101111334764773017675 0ustar jorismkyb libDAI: Class Members - Functions
 

- w -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/matlab_8h-source.html0000644000263000017630000001152311334764773017232 0ustar jorismkyb libDAI: include/dai/matlab/matlab.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_111.png0000644000263000017630000000046011334764773015240 0ustar jorismkybPNG  IHDR%M10PLTEppp```PPP@@@000 4tRNS@fIDATc`M H\GI :"_O"eW/z8SP\!A lrA$r@rw}oSϩ/edp$! ` @ݏ d|X`5\8vIENDB`libDAI-0.2.4/doc/html/classdai_1_1BBPCostFunction-members.html0000644000263000017630000000573611334764773022644 0ustar jorismkyb libDAI: Member List

dai::BBPCostFunction Member List

This is the complete list of members for dai::BBPCostFunction, including all inherited members.

BBPCostFunction()dai::BBPCostFunction [inline]
BBPCostFunction(const BBPCostFunctionBase &x)dai::BBPCostFunction [inline]
evaluate(const InfAlg &ia, const std::vector< size_t > *stateP) const dai::BBPCostFunction
needGibbsState() const dai::BBPCostFunction
operator=(const BBPCostFunctionBase &x)dai::BBPCostFunction [inline]

Generated on Thu Feb 11 12:26:02 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_0x61.html0000644000263000017630000001510711334764773016665 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- a -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/emalg_8h-source.html0000644000263000017630000013722511334764773017067 0ustar jorismkyb libDAI: include/dai/emalg.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1Gibbs_1_1Properties-members.html0000644000263000017630000000450711334764773023657 0ustar jorismkyb libDAI: Member List

dai::Gibbs::Properties Member List

This is the complete list of members for dai::Gibbs::Properties, including all inherited members.

burnindai::Gibbs::Properties
itersdai::Gibbs::Properties
verbosedai::Gibbs::Properties

Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_vars_0x76.html0000644000263000017630000001203111334764773017717 0ustar jorismkyb libDAI: Class Members - Variables
 

- v -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_0x7a.html0000644000263000017630000001125511334764774016747 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- z -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_83.png0000644000263000017630000000044311334764774015172 0ustar jorismkybPNG  IHDR. 90PLTEppp```PPP@@@000 4tRNS@fIDATc` 2$|0_!'9 ̙@kD\q :OЁ+>iI9P3 X?"x=.c8 13eQ # ;Al,&Y@d炂p& AtIENDB`libDAI-0.2.4/doc/html/bipgraph_8h.html0000644000263000017630000000741511334764774016276 0ustar jorismkyb libDAI: include/dai/bipgraph.h File Reference

include/dai/bipgraph.h File Reference

Defines the BipartiteGraph class, which represents a bipartite graph. More...

#include <ostream>
#include <vector>
#include <algorithm>
#include <dai/util.h>
#include <dai/exceptions.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::BipartiteGraph
 Represents the neighborhood structure of nodes in an undirected, bipartite graph. More...
struct  dai::BipartiteGraph::Neighbor
 Describes the neighbor relationship of two nodes in a BipartiteGraph. More...
struct  dai::BipartiteGraph::levelType
 Used internally by isTree(). More...

Detailed Description

Defines the BipartiteGraph class, which represents a bipartite graph.

Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/factor_8h-source.html0000644000263000017630000030155311334764774017256 0ustar jorismkyb libDAI: include/dai/factor.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_107.png0000644000263000017630000000075711334764774015257 0ustar jorismkybPNG  IHDRJ#0PLTEppp```PPP@@@000 4tRNS@fmIDAT8c`b((((a/)Y@XCLQo!7["@0O۞JQ0ZƱL1$1%$ 3" $12x&00||Ca&@$Y'@U&0 E1 w!c+؂aI8Ձʄy x4lCEYQ1lP P.\إ D0Z?ŧ9 "`4VQ xrF`0p(S!? O`>@?*F O`L'V%(>&b<6bMI2iIENDB`libDAI-0.2.4/doc/html/factorgraph_8h.html0000644000263000017630000000511511334764774016775 0ustar jorismkyb libDAI: include/dai/factorgraph.h File Reference

include/dai/factorgraph.h File Reference

Defines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov random fields). More...

#include <iostream>
#include <map>
#include <dai/bipgraph.h>
#include <dai/factor.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::FactorGraph
 Represents a factor graph. More...

Detailed Description

Defines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov random fields).

Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1DAIAlg.html0000644000263000017630000005200611334764774017264 0ustar jorismkyb libDAI: dai::DAIAlg< GRM > Class Template Reference

dai::DAIAlg< GRM > Class Template Reference

Combines the abstract base class InfAlg with a graphical model (e.g., a FactorGraph or RegionGraph). More...

#include <dai/daialg.h>

Inheritance diagram for dai::DAIAlg< GRM >:

dai::InfAlg dai::BP dai::CBP dai::ExactInf dai::Gibbs dai::HAK dai::JTree dai::LC dai::MF dai::MR

List of all members.

Public Member Functions

Constructors/destructors
 DAIAlg ()
 Default constructor.
 DAIAlg (const GRM &grm)
 Construct from GRM.
Queries
FactorGraph & fg ()
 Returns reference to underlying FactorGraph.
const FactorGraph & fg () const
 Returns constant reference to underlying FactorGraph.
Changing the factor graph
void clamp (size_t i, size_t x, bool backup=false)
 Clamp variable with index i to value x (i.e. multiply with a Kronecker delta $\delta_{x_i, x}$).
void makeCavity (size_t i, bool backup=false)
 Sets all factors interacting with variable with index i to one.
Backup/restore mechanism for factors
void backupFactor (size_t I)
 Make a backup copy of factor I.
void backupFactors (const VarSet &vs)
 Make backup copies of all factors involving the variables in vs.
void restoreFactor (size_t I)
 Restore factor I from its backup copy.
void restoreFactors (const VarSet &vs)
 Restore the factors involving the variables in vs from their backup copies.

Detailed Description

template<class GRM>
class dai::DAIAlg< GRM >

Combines the abstract base class InfAlg with a graphical model (e.g., a FactorGraph or RegionGraph).

Inference algorithms in libDAI directly inherit from a DAIAlg, currently either from a DAIAlg<FactorGraph> or from a DAIAlg<RegionGraph>.

Template Parameters:
GRM Should be castable to FactorGraph
Idea:
A DAIAlg should not inherit from a FactorGraph or RegionGraph, but should store a reference to the graphical model object. This prevents needless copying of (possibly large) data structures. Disadvantage: the caller must not change the graphical model between calls to the inference algorithm (maybe a smart_ptr or some locking mechanism would help here?).

Constructor & Destructor Documentation

template<class GRM>
dai::DAIAlg< GRM >::DAIAlg (  )  [inline]

Default constructor.

template<class GRM>
dai::DAIAlg< GRM >::DAIAlg ( const GRM &  grm  )  [inline]

Construct from GRM.

Member Function Documentation

template<class GRM>
FactorGraph& dai::DAIAlg< GRM >::fg (  )  [inline, virtual]

Returns reference to underlying FactorGraph.

Implements dai::InfAlg.

template<class GRM>
const FactorGraph& dai::DAIAlg< GRM >::fg (  )  const [inline, virtual]

Returns constant reference to underlying FactorGraph.

Implements dai::InfAlg.

template<class GRM>
void dai::DAIAlg< GRM >::clamp ( size_t  i,
size_t  x,
bool  backup = false 
) [inline, virtual]

Clamp variable with index i to value x (i.e. multiply with a Kronecker delta $\delta_{x_i, x}$).

If backup == true, make a backup of all factors that are changed.

Implements dai::InfAlg.

template<class GRM>
void dai::DAIAlg< GRM >::makeCavity ( size_t  i,
bool  backup = false 
) [inline, virtual]

Sets all factors interacting with variable with index i to one.

If backup == true, make a backup of all factors that are changed.

Implements dai::InfAlg.

template<class GRM>
void dai::DAIAlg< GRM >::backupFactor ( size_t  I  )  [inline, virtual]

Make a backup copy of factor I.

Implements dai::InfAlg.

template<class GRM>
void dai::DAIAlg< GRM >::backupFactors ( const VarSet &  vs  )  [inline, virtual]

Make backup copies of all factors involving the variables in vs.

Implements dai::InfAlg.

template<class GRM>
void dai::DAIAlg< GRM >::restoreFactor ( size_t  I  )  [inline, virtual]

Restore factor I from its backup copy.

Implements dai::InfAlg.

template<class GRM>
void dai::DAIAlg< GRM >::restoreFactors ( const VarSet &  vs  )  [inline, virtual]

Restore the factors involving the variables in vs from their backup copies.

Implements dai::InfAlg.

The documentation for this class was generated from the following file:
Generated on Thu Feb 11 12:26:03 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_func_0x6f.html0000644000263000017630000003323011334764774017763 0ustar jorismkyb libDAI: Class Members - Functions
 

- o -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1Region.html0000644000263000017630000002164211334764774017470 0ustar jorismkyb libDAI: dai::Region Class Reference

dai::Region Class Reference

A Region is a set of variables with a counting number. More...

#include <dai/regiongraph.h>

Inheritance diagram for dai::Region:

dai::VarSet dai::SmallSet< T >

List of all members.

Public Member Functions

 Region ()
 Default constructor.
 Region (const VarSet &x, Real c)
 Construct from a set of variables and a counting number.
const Real & c () const
 Returns constant reference to counting number.
Real & c ()
 Returns reference to counting number.

Private Attributes

Real _c
 Counting number.

Detailed Description

A Region is a set of variables with a counting number.

Constructor & Destructor Documentation

dai::Region::Region (  )  [inline]

Default constructor.

dai::Region::Region ( const VarSet &  x,
Real  c 
) [inline]

Construct from a set of variables and a counting number.

Member Function Documentation

const Real& dai::Region::c (  )  const [inline]

Returns constant reference to counting number.

Real& dai::Region::c (  )  [inline]

Returns reference to counting number.

Member Data Documentation

Real dai::Region::_c [private]

Counting number.

The documentation for this class was generated from the following file:
Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/deprecated.html0000644000263000017630000001660211334764774016201 0ustar jorismkyb libDAI: Deprecated List

Deprecated List

Member dai::BipartiteGraph::add1 ()
Please use dai::BipartiteGraph::addNode1() instead.

Member dai::BipartiteGraph::add2 ()
Please use dai::BipartiteGraph::addNode2() instead.

Member dai::BipartiteGraph::add1 (NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0)
Please use dai::BipartiteGraph::addNode1( NodeInputIterator, NodeInputIterator, size_t) instead.

Member dai::BipartiteGraph::add2 (NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0)
Please use dai::BipartiteGraph::addNode2( NodeInputIterator, NodeInputIterator, size_t) instead.

Member dai::BipartiteGraph::erase1 (size_t n1)
Please use dai::BipartiteGraph::eraseNode1(size_t) instead.

Member dai::BipartiteGraph::erase2 (size_t n2)
Please use dai::BipartiteGraph::eraseNode2(size_t) instead.

Member dai::BipartiteGraph::nr1 () const
Please use dai::BipartiteGraph::nrNodes1() instead.

Member dai::BipartiteGraph::nr2 () const
Please use dai::BipartiteGraph::nrNodes2() instead.

Member dai::ClusterGraph::eliminationCost (size_t i) const
Please use dai::eliminationCost_MinFill() instead.

Member dai::ClusterGraph::VarElim (const std::vector< Var > &ElimSeq) const
Please use dai::ClusterGraph::VarElim( sequentialVariableElimination( ElimSeq ) ) instead.

Member dai::ClusterGraph::VarElim_MinFill () const
Please use dai::ClusterGraph::VarElim( greedyVariableElimination( eliminationCost_MinFill ) ) instead.

Member dai::RegionGraph::RegionGraph (const FactorGraph &fg, const std::vector< Region > &ors, const std::vector< Region > &irs, const std::vector< std::pair< size_t, size_t > > &edges)
Please use dai::RegionGraph::RegionGraph( const FactorGraph &, const std::vector<VarSet> &, const std::vector<Region> &, const std::vector<std::pair<size_t,size_t> > & ) instead.

Member dai::Graph
Please use dai::GraphEL instead.
Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1fo__abs-members.html0000644000263000017630000000356011334764774021503 0ustar jorismkyb libDAI: Member List

dai::fo_abs< T > Member List

This is the complete list of members for dai::fo_abs< T >, including all inherited members.

operator()(const T &x) const dai::fo_abs< T > [inline]

Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/doc_8h.html0000644000263000017630000000715611334764774015251 0ustar jorismkyb libDAI: include/dai/doc.h File Reference

include/dai/doc.h File Reference

Contains additional doxygen documentation. More...

Go to the source code of this file.

Detailed Description

Contains additional doxygen documentation.

Idea:
Adapt (part of the) guidelines in http://www.boost.org/development/requirements.html#Design_and_Programming
Idea:
Use "gcc -MM" to generate dependencies for targets: http://make.paulandlesley.org/autodep.html
Idea:
Disentangle structures. In particular, ensure that graphical properties are not entangled with probabilistic properties. For example, a FactorGraph contains several components:
  • a BipartiteGraph
  • an array of variable labels
  • an array of variable state space sizes
  • an array of pointers to factor value vectors In this way, each factor could be implemented differently, e.g., we could have some sparse factors, some noisy-OR factors, some dense factors, some arbitrary precision factors, etcetera.
Idea:
Use boost::uBLAS framework to deal with matrices, especially, with 2D sparse matrices. See http://www.boost.org/libs/numeric/ublas/doc/matrix_sparse.htm However: I read somewhere that boost::uBLAS concentrates more on correct implementation than on performance.
Idea:
Introduce naming scheme:
  • all Vars should be named v_..., e.g. v_i instead of i
  • all VarSets should be named vs_..., e.g. v_i instead of i
  • all Factors should be named f_..., e.g. f_I instead of I
  • all indices should be named _..., e.g. _k instead of k
  • all iterators should be named i_, e.g. i_i is an iterator to i
  • all const_iterators should be named ci_, e.g. ci_i is an iterator to i
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_0x7e.html0000644000263000017630000001116111334764774016747 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- ~ -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/todo.html0000644000263000017630000001000611334764774015036 0ustar jorismkyb libDAI: Todo List

Todo List

Member dai::CBP::getInfAlg ()
At present, CBP::getInfAlg() only returns a BP instance; it should be possible to select other inference algorithms via a property

Class dai::FBP
Add nice way to set weights

Class dai::MR
Clean up code (use a BipartiteGraph-like implementation for the graph structure, and BBP for response propagation).

Class dai::TFactor< T >
Define a better fileformat for .fg files (maybe using XML)?

Class dai::TFactor< T >
Add support for sparse factors.

Class dai::TRWBP
Add nice way to set weights

Class dai::TRWBP
Merge code of FBP and TRWBP

File alldai.h
Replace VarSets by SmallSet<size_t> where appropriate, in order to minimize the use of FactorGraph::findVar().

File alldai.h
Implement routines for UAI probabilistic inference evaluation data

File alldai.h
Improve SWIG interfaces and merge their build process with the main build process

File bbp.h
Clean up code

File emalg.h
Implement parameter estimation for undirected models / factor graphs.

File treeep.h
Clean up the TreeEP code (exploiting that a large part of the code is just a special case of JTree).

File weightedgraph.h
Improve general support for graphs and trees.
Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_49.png0000644000263000017630000000031111334764774015166 0ustar jorismkybPNG  IHDR Rio0PLTEppp```PPP@@@000 4tRNS@fGIDATc`,)` #H| 20>  N?cct2JX\B`e0 2 ^IENDB`libDAI-0.2.4/doc/html/structdai_1_1fo__min.html0000644000263000017630000000762311334764774020075 0ustar jorismkyb libDAI: dai::fo_min< T > Struct Template Reference

dai::fo_min< T > Struct Template Reference

Function object that returns the minimum of two values. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &x, const T &y) const
 Returns (x > y ? y : x).

Detailed Description

template<typename T>
struct dai::fo_min< T >

Function object that returns the minimum of two values.

Member Function Documentation

template<typename T>
T dai::fo_min< T >::operator() ( const T &  x,
const T &  y 
) const [inline]

Returns (x > y ? y : x).

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_112.png0000644000263000017630000000047111334764774015244 0ustar jorismkybPNG  IHDR0PLTEppp```PPP@@@000 4tRNS@fIDATc`  09&sAy'd)9   0,54``e`Юs?Al"^y6 ǟ!n9w8q@N,X .&>``/qX60*80/ḳ^ lpa(snIENDB`libDAI-0.2.4/doc/html/structdai_1_1fo__KL-members.html0000644000263000017630000000357211334764774021247 0ustar jorismkyb libDAI: Member List

dai::fo_KL< T > Member List

This is the complete list of members for dai::fo_KL< T >, including all inherited members.

operator()(const T &p, const T &q) const dai::fo_KL< T > [inline]

Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/functions_func_0x6d.html0000644000263000017630000002054711334764774017770 0ustar jorismkyb libDAI: Class Members - Functions
 

- m -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_8.png0000644000263000017630000000206411334764774015110 0ustar jorismkybPNG  IHDR$uX0PLTEppp```PPP@@@000 4tRNS@fIDATXϋGǿ]5==n-A,b79Iu@ TÈE&!3у'[A z΂ =Jww<UjSիwk~{F̔Z+J^ۈɤHmXn$PڰҦU6=KJ4LD-4)}Ѹ4sdըYsNR(]m3qNH 5j?̀E=-U𦧦RUTDOS?uҝLXo LЪ/e|3 a+Fԅ6/]BkvEBtvQjyq`\qt 2\[AbDNXh<v=tKTʸ3;dT1.Χ^y!Hoj{iPNG=M(9, tޅ%Wuwit.U4y6 &(9P}MQ{1Ҿ^C̜jQ rթ@.U*U\R*b{ηiOzjN.':vB\WDVzCH]"<4OtAS)g088XU3rQӅ6P;*i~}ak""}Y,[M 7^{7=ZNk91T3<\Eu)_^B>(l/p8ɲ嵞{=`q8Ijwݤ,ovk%IENDB`libDAI-0.2.4/doc/html/structdai_1_1LC_1_1Properties.html0000644000263000017630000003771011334764774021502 0ustar jorismkyb libDAI: dai::LC::Properties Struct Reference

dai::LC::Properties Struct Reference

Parameters for LC. More...

#include <dai/lc.h>

List of all members.

Public Member Functions

 DAI_ENUM (CavityType, FULL, PAIR, PAIR2, UNIFORM)
 Enumeration of possible ways to initialize the cavities.
 DAI_ENUM (UpdateType, SEQFIX, SEQRND)
 Enumeration of different update schedules.

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr).
size_t maxiter
 Maximum number of iterations.
Real tol
 Tolerance for convergence test.
bool reinit
 Complete or partial reinitialization of cavity graphs?
Real damping
 Damping constant (0.0 means no damping, 1.0 is maximum damping).
CavityType cavity
 How to initialize the cavities.
UpdateType updates
 What update schedule to use.
std::string cavainame
 Name of the algorithm used to initialize the cavity distributions.
PropertySet cavaiopts
 Parameters for the algorithm used to initialize the cavity distributions.

Detailed Description

Parameters for LC.

Member Function Documentation

dai::LC::Properties::DAI_ENUM ( CavityType  ,
FULL  ,
PAIR  ,
PAIR2  ,
UNIFORM   
)

Enumeration of possible ways to initialize the cavities.

The following initialization methods are defined:

  • FULL calculates the marginal using calcMarginal()
  • PAIR calculates only second order interactions using calcPairBeliefs() with accurate == false
  • PAIR2 calculates only second order interactions using calcPairBeliefs() with accurate == true
  • UNIFORM uses a uniform distribution

dai::LC::Properties::DAI_ENUM ( UpdateType  ,
SEQFIX  ,
SEQRND   
)

Enumeration of different update schedules.

The following update schedules are defined:

  • SEQFIX sequential fixed schedule
  • SEQRND sequential random schedule

Member Data Documentation

size_t dai::LC::Properties::verbose

Verbosity (amount of output sent to stderr).

size_t dai::LC::Properties::maxiter

Maximum number of iterations.

Real dai::LC::Properties::tol

Tolerance for convergence test.

bool dai::LC::Properties::reinit

Complete or partial reinitialization of cavity graphs?

Real dai::LC::Properties::damping

Damping constant (0.0 means no damping, 1.0 is maximum damping).

CavityType dai::LC::Properties::cavity

How to initialize the cavities.

UpdateType dai::LC::Properties::updates

What update schedule to use.

std::string dai::LC::Properties::cavainame

Name of the algorithm used to initialize the cavity distributions.

PropertySet dai::LC::Properties::cavaiopts

Parameters for the algorithm used to initialize the cavity distributions.

The documentation for this struct was generated from the following file:
Generated on Thu Feb 11 12:26:05 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/classdai_1_1FactorGraph-members.html0000644000263000017630000004216411334764774022077 0ustar jorismkyb libDAI: Member List

dai::FactorGraph Member List

This is the complete list of members for dai::FactorGraph, including all inherited members.

_backupdai::FactorGraph [private]
_factorsdai::FactorGraph [private]
_varsdai::FactorGraph [private]
backupFactor(size_t I)dai::FactorGraph
backupFactors(const std::set< size_t > &facs)dai::FactorGraph [virtual]
backupFactors(const VarSet &ns)dai::FactorGraph
begin()dai::FactorGraph [inline]
begin() const dai::FactorGraph [inline]
clamp(size_t i, size_t x, bool backup=false)dai::FactorGraph [virtual]
clamped(size_t i, size_t x) const dai::FactorGraph
clampFactor(size_t I, const std::vector< size_t > &xIs, bool backup=false)dai::FactorGraph
clampVar(size_t i, const std::vector< size_t > &xis, bool backup=false)dai::FactorGraph
Cliques() const dai::FactorGraph
clone() const dai::FactorGraph [inline, virtual]
const_iterator typedefdai::FactorGraph
constructGraph(size_t nrEdges)dai::FactorGraph [private]
Delta(size_t i) const dai::FactorGraph
Delta(const VarSet &vs) const dai::FactorGraph
delta(size_t i) const dai::FactorGraph
delta(const VarSet &vs) const dai::FactorGraph [inline]
Edge typedefdai::FactorGraph
end()dai::FactorGraph [inline]
end() const dai::FactorGraph [inline]
factor(size_t I)dai::FactorGraph [inline]
factor(size_t I) const dai::FactorGraph [inline]
FactorGraph()dai::FactorGraph [inline]
FactorGraph(const std::vector< Factor > &P)dai::FactorGraph
FactorGraph(FactorInputIterator fact_begin, FactorInputIterator fact_end, VarInputIterator var_begin, VarInputIterator var_end, size_t nr_fact_hint=0, size_t nr_var_hint=0)dai::FactorGraph [inline]
factors() const dai::FactorGraph [inline]
findFactor(const VarSet &ns) const dai::FactorGraph [inline]
findVar(const Var &n) const dai::FactorGraph [inline]
findVars(VarSet &ns) const dai::FactorGraph [inline]
Gdai::FactorGraph
isBinary() const dai::FactorGraph
isConnected() const dai::FactorGraph [inline]
isPairwise() const dai::FactorGraph
isTree() const dai::FactorGraph [inline]
iterator typedefdai::FactorGraph
makeCavity(size_t i, bool backup=false)dai::FactorGraph [virtual]
maximalFactors() const dai::FactorGraph
nbF(size_t I) const dai::FactorGraph [inline]
nbF(size_t I, size_t _i) const dai::FactorGraph [inline]
nbV(size_t i) const dai::FactorGraph [inline]
nbV(size_t i, size_t _I) const dai::FactorGraph [inline]
Neighbor typedefdai::FactorGraph
Neighbors typedefdai::FactorGraph
nrEdges() const dai::FactorGraph [inline]
nrFactors() const dai::FactorGraph [inline]
nrVars() const dai::FactorGraph [inline]
operator<<(std::ostream &os, const FactorGraph &fg)dai::FactorGraph [friend]
operator>>(std::istream &is, FactorGraph &fg)dai::FactorGraph [friend]
printDot(std::ostream &os) const dai::FactorGraph
ReadFromFile(const char *filename)dai::FactorGraph
restoreFactor(size_t I)dai::FactorGraph
restoreFactors()dai::FactorGraph [virtual]
restoreFactors(const VarSet &ns)dai::FactorGraph
setFactor(size_t I, const Factor &newFactor, bool backup=false)dai::FactorGraph [inline, virtual]
setFactors(const std::map< size_t, Factor > &facs, bool backup=false)dai::FactorGraph [inline, virtual]
var(size_t i) const dai::FactorGraph [inline]
vars() const dai::FactorGraph [inline]
WriteToFile(const char *filename, size_t precision=15) const dai::FactorGraph
~FactorGraph()dai::FactorGraph [inline, virtual]

Generated on Thu Feb 11 12:26:04 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_114.png0000644000263000017630000000061711334764774015250 0ustar jorismkybPNG  IHDR^mA0PLTEppp```PPP@@@000 4tRNS@f IDAT(c`0D!,FT P7$я LdDSUU=3|E=L NIM H P]H_5Y=#ԝ3# X P7›$; Iy $d!a5`R@qP=mAPr~y268bF _z{t] 4zO@2UEHWbPτ Sr@W XEaAO 6dPIENDB`libDAI-0.2.4/doc/html/form_73.png0000644000263000017630000000067111334764774015174 0ustar jorismkybPNG  IHDRJ#U0PLTEppp```PPP@@@000 4tRNS@f7IDAT(c``&*Wg``ha"ʁj0Peqi>a m < g10أ9'T"s$#n o| lPUY-검a.P-* 1U1}@@?`x@5 /"e Ļ ?3`+/aB% 3C(V*2\S݁! 8Amchd` 0օR/9eo@"SVa`hdaQ`1bPbY @% U7Ef$sIENDB`libDAI-0.2.4/doc/html/form_29.png0000644000263000017630000000026011334764774015167 0ustar jorismkybPNG  IHDR 0PLTEppp```PPP@@@000 4tRNS@f.IDATc` @$x?HDtc@c(h@7uIENDB`libDAI-0.2.4/doc/html/form_118.png0000644000263000017630000000030211334764774015243 0ustar jorismkybPNG  IHDRf00PLTEppp```PPP@@@000 4tRNS@f@IDATc`F$)ͣ7c`z @چDgAi.V0Og<8IENDB`libDAI-0.2.4/doc/html/classdai_1_1TreeEP.png0000644000263000017630000000123511334764774017205 0ustar jorismkybPNG  IHDRPLTE`{tRNS@f3IDAThKr ͦkt u YX~$xҸ| sJ `/ ) 7D=BLcHHe*PTpI#J0th%YRgր.$w4x?~ހ.?O|\.O`8opxQ- *gL\Hd)BZ@)5aR#O?,-- (8E08) 0U,|G&L4SIT `U,F,@vd8 `" 0nن3 =M1nF8p\7PElԧZbW 7ިULd rX[o 0 n%z#'^}.t^׍p1C<QNZN>29׀㠻'Pb#s ^['L hA {e"'a A `s]5¸]@9EGPՏchdIENDB`libDAI-0.2.4/doc/html/treeep_8h.html0000644000263000017630000001063511334764774015764 0ustar jorismkyb libDAI: include/dai/treeep.h File Reference

include/dai/treeep.h File Reference

Defines class TreeEP, which implements Tree Expectation Propagation. More...

#include <vector>
#include <string>
#include <dai/daialg.h>
#include <dai/varset.h>
#include <dai/regiongraph.h>
#include <dai/factorgraph.h>
#include <dai/clustergraph.h>
#include <dai/weightedgraph.h>
#include <dai/jtree.h>
#include <dai/properties.h>
#include <dai/enum.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::TreeEP
 Approximate inference algorithm "Tree Expectation Propagation" [MiQ04]. More...
struct  dai::TreeEP::Properties
 Parameters for TreeEP. More...
class  dai::TreeEP::TreeEPSubTree
 Stores the data structures needed to efficiently update the approximation of an off-tree factor. More...

Detailed Description

Defines class TreeEP, which implements Tree Expectation Propagation.

Todo:
Clean up the TreeEP code (exploiting that a large part of the code is just a special case of JTree).
Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/factor_8h.html0000644000263000017630000001365011334764774015756 0ustar jorismkyb libDAI: include/dai/factor.h File Reference

include/dai/factor.h File Reference

Defines TFactor<> and Factor classes which represent factors in probability distributions. More...

#include <iostream>
#include <functional>
#include <cmath>
#include <dai/prob.h>
#include <dai/varset.h>
#include <dai/index.h>
#include <dai/util.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::TFactor< T >
 Represents a (probability) factor. More...

Typedefs

typedef TFactor< Real > dai::Factor
 Represents a factor with values of type dai::Real.

Functions

Factor dai::createFactorIsing (const Var &x, Real h)
 Returns a binary single-variable factor $ \exp(hx) $ where $ x = \pm 1 $.
Factor dai::createFactorIsing (const Var &x1, const Var &x2, Real J)
 Returns a binary pairwise factor $ \exp(J x_1 x_2) $ where $ x_1, x_2 = \pm 1 $.
Factor dai::createFactorExpGauss (const VarSet &vs, Real beta)
 Returns a random factor on the variables vs with strength beta.
Factor dai::createFactorPotts (const Var &x1, const Var &x2, Real J)
 Returns a pairwise Potts factor $ \exp( J \delta_{x_1, x_2} ) $.
Factor dai::createFactorDelta (const Var &v, size_t state)
 Returns a Kronecker delta point mass.

Detailed Description

Defines TFactor<> and Factor classes which represent factors in probability distributions.

Generated on Thu Feb 11 12:26:00 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/pages.html0000644000263000017630000000364511334764774015203 0ustar jorismkyb libDAI: Page Index

Related Pages

Here is a list of all related documentation pages:
Generated on Thu Feb 11 12:25:58 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/structdai_1_1fo__id-members.html0000644000263000017630000000355211334764774021333 0ustar jorismkyb libDAI: Member List

dai::fo_id< T > Member List

This is the complete list of members for dai::fo_id< T >, including all inherited members.

operator()(const T &x) const dai::fo_id< T > [inline]

Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_62.png0000644000263000017630000000116111334764774015165 0ustar jorismkybPNG  IHDR~?)0PLTEppp```PPP@@@000 4tRNS@fIDAT81k@\v"#! EY! Thh &Ćdrik(dp1 8U'2[~d N%\j>НI%kj3{lSeZʔb|Uu9z9_(79mnhq/͕T2'sAPt yev#Sd޴pw+:n.] ~~>UK;2ۑIX}_zw7GĞwYG libDAI: Class Members - Variables
 

- k -

Generated on Thu Feb 11 12:26:01 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/cbp_8h-source.html0000644000263000017630000010356111334764774016543 0ustar jorismkyb libDAI: include/dai/cbp.h Source File
Generated on Thu Feb 11 12:25:59 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_32.png0000644000263000017630000000031611334764774015163 0ustar jorismkybPNG  IHDR0PLTEppp```PPP@@@000 4tRNS@fLIDATc`@PZl.AL3``3~@`?p)Q| ~kX۞N CL0Lc9. S2IENDB`libDAI-0.2.4/doc/html/classdai_1_1MF-members.html0000644000263000017630000002366211334764774020203 0ustar jorismkyb libDAI: Member List

dai::MF Member List

This is the complete list of members for dai::MF, including all inherited members.

_beliefsdai::MF [private]
_itersdai::MF [private]
_maxdiffdai::MF [private]
backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
belief(const Var &v) const dai::MF [inline, virtual]
belief(const VarSet &vs) const dai::MF [virtual]
beliefF(size_t I) const dai::InfAlg [inline, virtual]
beliefs() const dai::MF [virtual]
beliefV(size_t i) const dai::MF [virtual]
calcNewBelief(size_t i)dai::MF [private]
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clone() const dai::MF [inline, virtual]
construct()dai::MF [private]
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
getProperties() const dai::MF [virtual]
identify() const dai::MF [virtual]
init()dai::MF [virtual]
init(const VarSet &ns)dai::MF [virtual]
Iterations() const dai::MF [inline, virtual]
logZ() const dai::MF [virtual]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
maxDiff() const dai::MF [inline, virtual]
MF()dai::MF [inline]
MF(const FactorGraph &fg, const PropertySet &opts)dai::MF [inline]
Namedai::MF [static]
printProperties() const dai::MF [virtual]
props (defined in dai::MF)dai::MF
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
run()dai::MF [virtual]
setProperties(const PropertySet &opts)dai::MF [virtual]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Feb 11 12:26:06 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.4/doc/html/form_4.png0000644000263000017630000000025511334764774015104 0ustar jorismkybPNG  IHDR E10PLTEppp```PPP@@@000 4tRNS@f+IDATc`0X @dDEAd14Oy,IENDB`libDAI-0.2.4/README0000644000263000017630000002616011334764774012362 0ustar jorismkyblibDAI - A free/open source C++ library for Discrete Approximate Inference ------------------------------------------------------------------------------- Version: 0.2.4 Date: February 11, 2010 See also: http://www.libdai.org ------------------------------------------------------------------------------- License libDAI is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. libDAI is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with libDAI in the file COPYING. If not, see http://www.gnu.org/licenses/ ------------------------------------------------------------------------------- Citing libDAI If you write a scientific paper describing research that made substantive use of this program, please: * mention the fashion in which this software was used, including the version number, with a citation to the literature, to allow replication; * mention this software in the Acknowledgements section. An appropriate citation would be: Joris M. Mooij et al. (2010) "libDAI 0.2.4: A free/open source C++ library for Discrete Approximate Inference", http://www.libdai.org or in BiBTeX format: @misc{mooij2010libdai, author = "Joris M. Mooij et al.", title = "lib{DAI} 0.2.4: A free/open source {C}++ library for {D}iscrete {A}pproximate {I}nference", howpublished = "http://www.libdai.org/", year = 2010 } Moreover, as a personal note, I would appreciate it if you would email (citations of) papers referencing this work to joris dot mooij at libdai dot org. ------------------------------------------------------------------------------- About libDAI libDAI is a free/open source C++ library (licensed under GPL 2+) that provides implementations of various (approximate) inference methods for discrete graphical models. libDAI supports arbitrary factor graphs with discrete variables; this includes discrete Markov Random Fields and Bayesian Networks. The library is targeted at researchers. To be able to use the library, a good understanding of graphical models is needed. The best way to use libDAI is by writing C++ code that invokes the library; in addition, part of the functionality is accessibly by using the * command line interface * (limited) MatLab interface * (experimental) python interface * (experimental) octave interface. libDAI can be used to implement novel (approximate) inference algorithms and to easily compare the accuracy and performance with existing algorithms that have been implemented already. Features Currently, libDAI supports the following (approximate) inference methods: * Exact inference by brute force enumeration; * Exact inference by junction-tree methods; * Mean Field; * Loopy Belief Propagation [KFL01]; * Fractional Belief Propagation [WiH03]; * Tree-Reweighted Belief Propagation [WJW03]; * Tree Expectation Propagation [MiQ04]; * Generalized Belief Propagation [YFW05]; * Double-loop GBP [HAK03]; * Various variants of Loop Corrected Belief Propagation [MoK07, MoR05]; * Gibbs sampler; * Conditioned Belief Propagation [EaG09]. These inference methods can be used to calculate partition sums, marginals over subsets of variables, and MAP states (the joint state of variables that has maximum probability). In addition, libDAI supports parameter learning of conditional probability tables by Expectation Maximization. Limitations libDAI is not intended to be a complete package for approximate inference. Instead, it should be considered as an "inference engine", providing various inference methods. In particular, it contains no GUI, currently only supports its own file format for input and output (although support for standard file formats may be added later), and provides very limited visualization functionalities. The only learning method supported currently is Expectation Maximization (or Maximum Likelihood if no data is missing) for learning factor parameters. Rationale In my opinion, the lack of open source "reference" implementations hampers progress in research on approximate inference. Methods differ widely in terms of quality and performance characteristics, which also depend in different ways on various properties of the graphical models. Finding the best approximate inference method for a particular application therefore often requires empirical comparisons. However, implementing and debugging these methods takes a lot of time which could otherwise be spent on research. I hope that this code will aid researchers to be able to easily compare various (existing as well as new) approximate inference methods, in this way accelerating research and stimulating real-world applications of approximate inference. Language Because libDAI is implemented in C++, it is very fast compared with implementations in MatLab (a factor 1000 faster is not uncommon). libDAI does provide a (limited) MatLab interface for easy integration with MatLab. It also provides a command line interface and experimental python and octave interfaces (thanks to Patrick Pletscher). Compatibility The code has been developed under Debian GNU/Linux with the GCC compiler suite. libDAI compiles successfully with g++ versions 3.4, 4.1, 4.2 and 4.3. libDAI has also been successfully compiled with MS Visual Studio 2008 under Windows (but not all build targets are supported yet) and with Cygwin under Windows. Finally, libDAI has been compiled successfully on MacOS X. Downloading libDAI The libDAI sources and documentation can be downloaded from the libDAI website: http://www.libdai.org. Mailing list The Google group "libDAI" (http://groups.google.com/group/libdai) can be used for getting support and discussing development issues. ------------------------------------------------------------------------------- Building libDAI under UNIX variants (Linux / Cygwin / Mac OS X) Preparations You need: * a recent version of gcc (at least version 3.4) * GNU make * doxygen * graphviz * recent boost C++ libraries (at least version 1.34 if you have a recent version of GCC, otherwise at least version 1.37; however, version 1.37 shipped with Ubuntu 9.04 is known not to work) On Debian/Ubuntu, you can easily install all these packages with a single command: apt-get install g++ make doxygen graphviz libboost-dev libboost-graph-dev libboost-program-options-dev (root permissions needed). On Mac OS X (10.4 is known to work), these packages can be installed easily via MacPorts. If MacPorts is not already installed, install it according to the instructions at http://www.macports.org/. Then, a simple sudo port install gmake boost doxygen graphviz should be enough to install everything that is needed. On Cygwin, the prebuilt Cygwin package boost-1.33.1-x is known not to work. You can however obtain the latest boost version (you need at least 1.37.0) from http://www.boost.org/ and compile/install it with: ./configure make make install Building libDAI To build the libDAI source, first copy a template Makefile.* to Makefile.conf (for example, copy Makefile.LINUX to Makefile.conf if you use GNU/Linux). Then, edit the Makefile.conf template to adapt it to your local setup. Especially directories may differ from system to system. Platform independent build options can be set in Makefile.ALL. Finally, run make The build includes a regression test, which may take a while to complete. If the build is successful, you can test the example program: examples/example tests/alarm.fg or the more extensive test program: tests/testdai --aliases tests/aliases.conf --filename tests/alarm.fg --methods JTREE_HUGIN BP_SEQMAX ------------------------------------------------------------------------------- Building libDAI under Windows Preparations You need: * A recent version of MicroSoft Visual Studio (2008 is known to work) * recent boost C++ libraries (version 1.37 or higher) * GNU make (can be obtained from http://gnuwin32.sourceforge.net) For the regression test, you need: * GNU diff, GNU sed (can be obtained from http://gnuwin32.sourceforge.net) Building libDAI To build the source, copy Makefile.WINDOWS to Makefile.conf. Then, edit Makefile.conf to adapt it to your local setup. Platform independent build options can be set in Makefile.ALL. Finally, run (from the command line) make The build includes a regression test, which may take a while to complete. If the build is successful, you can test the example program: examples\example tests\alarm.fg or the more extensive test program: tests\testdai --aliases tests\aliases.conf --filename tests\alarm.fg --methods JTREE_HUGIN BP_SEQMAX ------------------------------------------------------------------------------- Building the libDAI MatLab interface You need: * MatLab * The platform-dependent requirements described above First, you need to build the libDAI source as described above for your platform. By default, the MatLab interface is disabled, so before compiling the source, you have to enable it in Makefile.ALL by setting WITH_MATLAB=true Also, you have to configure the MatLab-specific parts of Makefile.conf to match your system (in particular, the Makefile variables ME, MATLABDIR and MEX). The MEX file extension depends on your platform; for a 64-bit linux x86_64 system this would be "ME=.mexa64", for a 32-bit linux x86 system "ME=.mexglx". If you are unsure about your MEX file extension: it needs to be the same as what the MatLab command "mexext" returns. The required MEX files are built by issuing make from the command line. The MatLab interface is much less powerful than using libDAI from C++. There are two reasons for this: (i) it is boring to write MEX files; (ii) the large performance penalty paid when large data structures (like factor graphs) have to be converted between their native C++ data structure to something that MatLab understands. A simple example of how to use the MatLab interface is the following (entered at the MatLab prompt), which performs exact inference by the junction tree algorithm and approximate inference by belief propagation on the ALARM network: cd path_to_libdai/matlab [psi] = dai_readfg ('../examples/alarm.fg'); [logZ,q,md,qv,qf] = dai (psi, 'JTREE', '[updates=HUGIN,verbose=0]') [logZ,q,md,qv,qf] = dai (psi, 'BP', '[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0]') where "path_to_libdai" has to be replaced with the directory in which libDAI was installed. For other algorithms and some default parameters, see the file tests/aliases.conf. ------------------------------------------------------------------------------- Building the documentation Install doxygen, graphviz and a TeX distribution and use make doc to build the documentation. If the documentation is not clear enough, feel free to send me an email (or even better, to improve the documentation and send a patch!). The documentation can also be browsed online at http://www.libdai.org. libDAI-0.2.4/COPYING0000644000263000017630000004313311334764774012534 0ustar jorismkyb GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. libDAI-0.2.4/tests/0000755000263000017630000000000011334764774012637 5ustar jorismkyblibDAI-0.2.4/tests/testem/0000755000263000017630000000000011334764774014140 5ustar jorismkyblibDAI-0.2.4/tests/testem/2var.em0000644000263000017630000000011211334764774015327 0ustar jorismkyb1 1 CondProbEstimation [target_dim=2,total_dim=4,pseudo_count=1] 1 0 1 0 libDAI-0.2.4/tests/testem/testem.cpp0000644000263000017630000000347011334764774016151 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Charles Vaske [cvaske at soe dot ucsc dot edu] * Copyright (C) 2009 University of California Santa Cruz */ #include #include #include #include #include #include using namespace std; using namespace dai; void usage( const string &msg ) { cerr << msg << endl; cerr << "Usage:" << endl; cerr << " testem factorgraph.fg evidence.tab emconfig.em" << endl; exit( 1 ); } int main( int argc, char** argv ) { if( argc != 4 ) usage("Incorrect number of arguments."); FactorGraph fg; fg.ReadFromFile( argv[1] ); PropertySet infprops; infprops.Set( "verbose", (size_t)1 ); infprops.Set( "updates", string("HUGIN") ); InfAlg* inf = newInfAlg( "JTREE", fg, infprops ); inf->init(); Evidence e; ifstream estream( argv[2] ); e.addEvidenceTabFile( estream, fg ); cout << "Number of samples: " << e.nrSamples() << endl; for( Evidence::iterator ps = e.begin(); ps != e.end(); ps++ ) cout << "Sample #" << (ps - e.begin()) << " has " << ps->size() << " observations." << endl; ifstream emstream( argv[3] ); EMAlg em(e, *inf, emstream); while( !em.hasSatisfiedTermConditions() ) { Real l = em.iterate(); cout << "Iteration " << em.Iterations() << " likelihood: " << l <fg(); delete inf; return 0; } libDAI-0.2.4/tests/testem/2var_data.tab0000644000263000017630000000012511334764774016471 0ustar jorismkyb0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 0 1 1 1 1 1 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 libDAI-0.2.4/tests/testem/testem.out0000644000263000017630000000663611334764774016205 0ustar jorismkybNumber of samples: 20 Sample #0 has 2 observations. Sample #1 has 2 observations. Sample #2 has 2 observations. Sample #3 has 2 observations. Sample #4 has 2 observations. Sample #5 has 2 observations. Sample #6 has 2 observations. Sample #7 has 2 observations. Sample #8 has 2 observations. Sample #9 has 2 observations. Sample #10 has 2 observations. Sample #11 has 2 observations. Sample #12 has 2 observations. Sample #13 has 2 observations. Sample #14 has 2 observations. Sample #15 has 2 observations. Sample #16 has 2 observations. Sample #17 has 2 observations. Sample #18 has 2 observations. Sample #19 has 2 observations. Iteration 1 likelihood: -27.7259 Iteration 2 likelihood: -23.4297 Iteration 3 likelihood: -23.4297 Inferred Factor Graph: ###################### 1 2 0 1 2 2 4 0 0.166666666667 1 0.666666666667 2 0.833333333333 3 0.333333333333 Number of samples: 20 Sample #0 has 2 observations. Sample #1 has 2 observations. Sample #2 has 2 observations. Sample #3 has 2 observations. Sample #4 has 2 observations. Sample #5 has 2 observations. Sample #6 has 2 observations. Sample #7 has 2 observations. Sample #8 has 2 observations. Sample #9 has 2 observations. Sample #10 has 2 observations. Sample #11 has 2 observations. Sample #12 has 2 observations. Sample #13 has 2 observations. Sample #14 has 2 observations. Sample #15 has 2 observations. Sample #16 has 2 observations. Sample #17 has 2 observations. Sample #18 has 2 observations. Sample #19 has 2 observations. Iteration 1 likelihood: -27.7259 Iteration 2 likelihood: -23.7555 Iteration 3 likelihood: -23.7555 Inferred Factor Graph: ###################### 1 3 0 1 2 2 2 2 8 0 0.214285714286 1 0.642857142857 2 0.785714285714 3 0.357142857143 4 0.214285714286 5 0.642857142857 6 0.785714285714 7 0.357142857143 Number of samples: 5 Sample #0 has 5 observations. Sample #1 has 4 observations. Sample #2 has 6 observations. Sample #3 has 6 observations. Sample #4 has 5 observations. Iteration 1 likelihood: -16.4893 Iteration 2 likelihood: -15.4406 Iteration 3 likelihood: -15.3299 Inferred Factor Graph: ###################### 3 3 2 6 7 2 2 2 8 0 0.396387112396 1 0.356649908835 2 0.603612887604 3 0.643350091165 4 0.805779039527 5 0.669278114097 6 0.194220960473 7 0.330721885903 3 0 1 6 2 2 2 8 0 1.03521336269 1 1.54747895212 2 2.31765218974 3 1.28041900719 4 4.922079813 5 2.52725575019 6 0.831279296316 7 0.262805630803 3 1 2 4 2 2 2 8 0 0.396387112396 1 0.603612887604 2 0.356649908835 3 0.643350091165 4 0.805779039527 5 0.194220960473 6 0.669278114097 7 0.330721885903 Number of samples: 5 Sample #0 has 5 observations. Sample #1 has 4 observations. Sample #2 has 6 observations. Sample #3 has 6 observations. Sample #4 has 5 observations. Iteration 1 likelihood: -16.4893 Iteration 2 likelihood: -17.6905 Iteration 3 likelihood: -17.6582 Inferred Factor Graph: ###################### 3 3 2 6 7 2 2 2 8 0 0.495312199726 1 0.499107942908 2 0.504687800274 3 0.500892057092 4 0.640416549958 5 0.495122293924 6 0.359583450042 7 0.504877706076 3 0 1 6 2 2 2 8 0 0.495312199726 1 0.504687800274 2 0.499107942908 3 0.500892057092 4 0.640416549958 5 0.359583450042 6 0.495122293924 7 0.504877706076 3 1 2 4 2 2 2 8 0 0.495312199726 1 0.504687800274 2 0.499107942908 3 0.500892057092 4 0.640416549958 5 0.359583450042 6 0.495122293924 7 0.504877706076 libDAI-0.2.4/tests/testem/runtests.bat0000755000263000017630000000046211334764774016524 0ustar jorismkybtestem 2var.fg 2var_data.tab 2var.em > testem.out.tmp testem 3var.fg 2var_data.tab 3var.em >> testem.out.tmp testem ..\hoi1.fg hoi1_data.tab hoi1_share_f0_f2.em >> testem.out.tmp testem ..\hoi1.fg hoi1_data.tab hoi1_share_f0_f1_f2.em >> testem.out.tmp diff -s testem.out.tmp testem.out del testem.out.tmp libDAI-0.2.4/tests/testem/hoi1_share_f0_f2.em0000644000263000017630000000012411334764774017456 0ustar jorismkyb1 1 CondProbEstimation [target_dim=2,total_dim=8,pseudo_count=1] 2 2 1 2 4 0 6 2 7 libDAI-0.2.4/tests/testem/3var.fg0000644000263000017630000000010211334764774015322 0ustar jorismkyb1 3 0 1 2 2 2 2 8 0 0.5 1 0.5 2 0.5 3 0.5 4 0.5 5 0.5 6 0.5 7 0.5libDAI-0.2.4/tests/testem/2var.fg0000644000263000017630000000004611334764774015330 0ustar jorismkyb1 2 0 1 2 2 4 0 0.5 1 0.5 2 0.5 3 0.5libDAI-0.2.4/tests/testem/runtests0000755000263000017630000000057411334764774015763 0ustar jorismkyb#!/bin/bash TMPFILE1=`mktemp /var/tmp/testem.XXXXXX` trap 'rm -f $TMPFILE1' 0 1 15 ./testem 2var.fg 2var_data.tab 2var.em > $TMPFILE1 ./testem 3var.fg 2var_data.tab 3var.em >> $TMPFILE1 ./testem ../hoi1.fg hoi1_data.tab hoi1_share_f0_f2.em >> $TMPFILE1 ./testem ../hoi1.fg hoi1_data.tab hoi1_share_f0_f1_f2.em >> $TMPFILE1 diff -s $TMPFILE1 testem.out || exit 1 rm -f $TMPFILE1 libDAI-0.2.4/tests/testem/3var.em0000644000263000017630000000011411334764774015332 0ustar jorismkyb1 1 CondProbEstimation [target_dim=2,total_dim=8,pseudo_count=1] 1 0 1 0 2 libDAI-0.2.4/tests/testem/hoi1_data.tab0000644000263000017630000000010511334764774016455 0ustar jorismkyb0 1 2 4 6 7 0 0 1 1 0 1 1 1 0 0 1 0 0 0 1 0 0 0 1 0 0 1 0 0 1 0 libDAI-0.2.4/tests/testem/hoi1_infer_f2.em0000644000263000017630000000011411334764774017071 0ustar jorismkyb1 1 CondProbEstimation [target_dim=2,total_dim=8,pseudo_count=1] 1 2 1 2 4 libDAI-0.2.4/tests/testem/hoi1_share_f0_f1_f2.em0000644000263000017630000000013411334764774020045 0ustar jorismkyb1 1 CondProbEstimation [target_dim=2,total_dim=8,pseudo_count=1] 3 2 1 2 4 1 0 1 6 0 6 2 7 libDAI-0.2.4/tests/testall0000755000263000017630000000165711334764774014246 0ustar jorismkyb#!/bin/bash ./testdai --report-iters false --report-time false --marginals VAR --aliases aliases.conf --filename $1 --methods EXACT JTREE_HUGIN JTREE_SHSH BP_SEQFIX BP_SEQRND BP_SEQMAX BP_PARALL BP_SEQFIX_LOG BP_SEQRND_LOG BP_SEQMAX_LOG BP_PARALL_LOG FBP TRWBP MF_SEQRND TREEEP TREEEPWC GBP_MIN GBP_BETHE GBP_DELTA GBP_LOOP3 GBP_LOOP4 GBP_LOOP5 GBP_LOOP6 GBP_LOOP7 HAK_MIN HAK_BETHE HAK_DELTA HAK_LOOP3 HAK_LOOP4 HAK_LOOP5 MR_RESPPROP_FULL MR_CLAMPING_FULL MR_EXACT_FULL MR_RESPPROP_LINEAR MR_CLAMPING_LINEAR MR_EXACT_LINEAR LCBP_FULLCAV_SEQFIX LCBP_FULLCAVin_SEQFIX LCBP_FULLCAV_SEQRND LCBP_FULLCAVin_SEQRND LCBP_FULLCAV_NONE LCBP_FULLCAVin_NONE LCBP_PAIRCAV_SEQFIX LCBP_PAIRCAVin_SEQFIX LCBP_PAIRCAV_SEQRND LCBP_PAIRCAVin_SEQRND LCBP_PAIRCAV_NONE LCBP_PAIRCAVin_NONE LCBP_PAIR2CAV_SEQFIX LCBP_PAIR2CAVin_SEQFIX LCBP_PAIR2CAV_SEQRND LCBP_PAIR2CAVin_SEQRND LCBP_PAIR2CAV_NONE LCBP_PAIR2CAVin_NONE LCBP_UNICAV_SEQFIX LCBP_UNICAV_SEQRND BBP CBP libDAI-0.2.4/tests/maxprodbug.fg0000644000263000017630000000013111334764774015320 0ustar jorismkyb3 2 1 2 2 2 4 0 1 1 0 2 0 3 1 2 1 3 2 2 4 0 1 1 1 2 1 3 1 2 2 3 2 2 4 0 0 1 1 2 1 3 0 libDAI-0.2.4/tests/hoi2.fg0000644000263000017630000000151111334764774014014 0ustar jorismkyb# Factor graph made by ../utils/createfg # type = hoi # N = 10 # M = 2 # k = 4 # beta = 1 # seed = 1234567 2 4 0 2 7 8 2 2 2 2 16 0 2.2435781084647 1 4.0907955014965 2 1.1211049952628 3 1.1924200451373 4 0.6827733720955 5 10.160805816224 6 0.67358126735639 7 0.11391058009404 8 0.48125062895484 9 0.72144061373552 10 0.42394324261549 11 1.8698790799175 12 0.751673014734 13 3.3944709353 14 3.0697466018763 15 1.3518859952286 4 1 2 6 7 2 2 2 2 16 0 0.73767149678205 1 1.0407773095719 2 3.128053583949 3 4.9605310970883 4 0.13720523936748 5 7.321038643904 6 0.32066394017723 7 1.4685064382197 8 0.17120387482343 9 0.98014607500624 10 0.10935224527934 11 0.67077127555589 12 1.1255976822923 13 2.0774604864366 14 0.36868871983683 15 0.8542593124821 libDAI-0.2.4/tests/testbbp.cpp0000644000263000017630000000767311334764774015023 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include using namespace dai; using namespace std; int main( int argc, char *argv[] ) { if ( argc != 2 ) { cout << "Usage: " << argv[0] << " " << endl << endl; cout << "Reads factor graph and verifies" << endl; cout << "whether BBP works correctly on it." << endl << endl; return 1; } else { // Read FactorGraph from the file specified by the first command line argument FactorGraph fg; fg.ReadFromFile(argv[1]); // Set some constants size_t verbose = 0; Real tol = 1.0e-9; size_t maxiter = 10000; Real damping = 0.0; BBP::Properties::UpdateType updates = BBP::Properties::UpdateType::PAR; // Store the constants in a PropertySet object PropertySet opts; opts.Set("verbose",verbose); // Verbosity (amount of output generated) opts.Set("tol",tol); // Tolerance for convergence opts.Set("maxiter",maxiter); // Maximum number of iterations opts.Set("damping",damping); // Amount of damping applied // Construct a BP (belief propagation) object from the FactorGraph fg BP bp(fg, opts("updates",string("SEQFIX"))("logdomain",false)); bp.recordSentMessages = true; bp.init(); bp.run(); vector state( fg.nrVars(), 0 ); for( size_t t = 0; t < 45; t++ ) { BBP::Properties::UpdateType updates; switch( t % 5 ) { case BBP::Properties::UpdateType::SEQ_FIX: updates = BBP::Properties::UpdateType::SEQ_FIX; break; case BBP::Properties::UpdateType::SEQ_MAX: updates = BBP::Properties::UpdateType::SEQ_MAX; break; case BBP::Properties::UpdateType::SEQ_BP_REV: updates = BBP::Properties::UpdateType::SEQ_BP_REV; break; case BBP::Properties::UpdateType::SEQ_BP_FWD: updates = BBP::Properties::UpdateType::SEQ_BP_FWD; break; case BBP::Properties::UpdateType::PAR: updates = BBP::Properties::UpdateType::PAR; break; } BBPCostFunction cfn; switch( (t / 5) % 9 ) { case 0: cfn = BBPCostFunction::CFN_GIBBS_B; break; case 1: cfn = BBPCostFunction::CFN_GIBBS_B2; break; case 2: cfn = BBPCostFunction::CFN_GIBBS_EXP; break; case 3: cfn = BBPCostFunction::CFN_GIBBS_B_FACTOR; break; case 4: cfn = BBPCostFunction::CFN_GIBBS_B2_FACTOR; break; case 5: cfn = BBPCostFunction::CFN_GIBBS_EXP_FACTOR; break; case 6: cfn = BBPCostFunction::CFN_VAR_ENT; break; case 7: cfn = BBPCostFunction::CFN_FACTOR_ENT; break; case 8: cfn = BBPCostFunction::CFN_BETHE_ENT; break; } Real h = 1e-4; Real result = numericBBPTest( bp, &state, opts("updates",updates), cfn, h ); cout << "result: " << result << ",\tupdates=" << updates << ", cfn=" << cfn << endl; } } return 0; } libDAI-0.2.4/tests/testdai.cpp0000644000263000017630000003634211334764774015010 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include #include #include #include #include #include #include using namespace std; using namespace dai; namespace po = boost::program_options; /// Wrapper class for DAI approximate inference algorithms class TestDAI { protected: /// Stores a pointer to an InfAlg object, managed by this class InfAlg *obj; /// Stores the name of the InfAlg algorithm string name; /// Stores the total variation distances of the variable marginals vector err; public: /// Stores the variable marginals vector varMarginals; /// Stores all marginals vector allMarginals; /// Stores the logarithm of the partition sum Real logZ; /// Stores the maximum difference in the last iteration Real maxdiff; /// Stores the computation time (in seconds) double time; /// Stores the number of iterations needed size_t iters; /// Does the InfAlg support logZ()? bool has_logZ; /// Does the InfAlg support maxDiff()? bool has_maxdiff; /// Does the InfAlg support Iterations()? bool has_iters; /// Construct from factor graph \a fg, name \a _name, and set of properties \a opts TestDAI( const FactorGraph &fg, const string &_name, const PropertySet &opts ) : obj(NULL), name(_name), err(), varMarginals(), allMarginals(), logZ(0.0), maxdiff(0.0), time(0), iters(0U), has_logZ(false), has_maxdiff(false), has_iters(false) { double tic = toc(); if( name == "LDPC" ) { // special case: simulating a Low Density Parity Check code Prob zero(2,0.0); zero[0] = 1.0; for( size_t i = 0; i < fg.nrVars(); i++ ) varMarginals.push_back( Factor(fg.var(i), zero) ); allMarginals = varMarginals; logZ = 0.0; maxdiff = 0.0; iters = 1; has_logZ = false; has_maxdiff = false; has_iters = false; } else // create a corresponding InfAlg object obj = newInfAlg( name, fg, opts ); // Add the time needed to create the object time += toc() - tic; } /// Destructor ~TestDAI() { if( obj != NULL ) delete obj; } /// Identify string identify() const { if( obj != NULL ) return obj->identify(); else return "NULL"; } /// Run the algorithm and store its results void doDAI() { double tic = toc(); if( obj != NULL ) { // Initialize obj->init(); // Run obj->run(); // Record the time time += toc() - tic; // Store logarithm of the partition sum (if supported) try { logZ = obj->logZ(); has_logZ = true; } catch( Exception &e ) { if( e.code() == Exception::NOT_IMPLEMENTED ) has_logZ = false; else throw; } // Store maximum difference encountered in last iteration (if supported) try { maxdiff = obj->maxDiff(); has_maxdiff = true; } catch( Exception &e ) { if( e.code() == Exception::NOT_IMPLEMENTED ) has_maxdiff = false; else throw; } // Store number of iterations needed (if supported) try { iters = obj->Iterations(); has_iters = true; } catch( Exception &e ) { if( e.code() == Exception::NOT_IMPLEMENTED ) has_iters = false; else throw; } // Store variable marginals varMarginals.clear(); for( size_t i = 0; i < obj->fg().nrVars(); i++ ) varMarginals.push_back( obj->beliefV( i ) ); // Store all marginals calculated by the method allMarginals = obj->beliefs(); }; } /// Calculate total variation distance of variable marginals with respect to those in \a x void calcErrs( const TestDAI &x ) { err.clear(); err.reserve( varMarginals.size() ); for( size_t i = 0; i < varMarginals.size(); i++ ) err.push_back( dist( varMarginals[i], x.varMarginals[i], Prob::DISTTV ) ); } /// Calculate total variation distance of variable marginals with respect to those in \a x void calcErrs( const vector &x ) { err.clear(); err.reserve( varMarginals.size() ); for( size_t i = 0; i < varMarginals.size(); i++ ) err.push_back( dist( varMarginals[i], x[i], Prob::DISTTV ) ); } /// Return maximum error Real maxErr() { return( *max_element( err.begin(), err.end() ) ); } /// Return average error Real avgErr() { return( accumulate( err.begin(), err.end(), 0.0 ) / err.size() ); } }; /// Clips a real number: if the absolute value of \a x is less than \a minabs, return \a minabs, else return \a x Real clipReal( Real x, Real minabs ) { if( abs(x) < minabs ) return minabs; else return x; } /// Whether to output no marginals, only variable marginals, or all calculated marginals DAI_ENUM(MarginalsOutputType,NONE,VAR,ALL); /// Main function int main( int argc, char *argv[] ) { // Variables to store command line options // Filename of factor graph string filename; // Filename for aliases string aliases; // Approximate Inference methods to use vector methods; // Which marginals to output MarginalsOutputType marginals; // Output number of iterations? bool report_iters = true; // Output calculation time? bool report_time = true; // Define required command line options po::options_description opts_required("Required options"); opts_required.add_options() ("filename", po::value< string >(&filename), "Filename of factor graph") ("methods", po::value< vector >(&methods)->multitoken(), "DAI methods to perform") ; // Define allowed command line options po::options_description opts_optional("Allowed options"); opts_optional.add_options() ("help", "Produce help message") ("aliases", po::value< string >(&aliases), "Filename for aliases") ("marginals", po::value< MarginalsOutputType >(&marginals), "Output marginals? (NONE/VAR/ALL, default=NONE)") ("report-time", po::value< bool >(&report_time), "Output calculation time (default==1)?") ("report-iters", po::value< bool >(&report_iters), "Output iterations needed (default==1)?") ; // Define all command line options po::options_description cmdline_options; cmdline_options.add(opts_required).add(opts_optional); // Parse command line po::variables_map vm; po::store(po::parse_command_line(argc, argv, cmdline_options), vm); po::notify(vm); // Display help message if necessary if( vm.count("help") || !(vm.count("filename") && vm.count("methods")) ) { cout << "This program is part of libDAI - http://www.libdai.org/" << endl << endl; cout << "Usage: ./testdai --filename --methods [ ...]" << endl << endl; cout << "Reads factor graph and performs the approximate inference algorithms" << endl; cout << ", reporting for each method:" << endl; cout << " o the calculation time needed, in seconds (if report-time == 1);" << endl; cout << " o the number of iterations needed (if report-iters == 1);" << endl; cout << " o the maximum (over all variables) total variation error in the variable marginals;" << endl; cout << " o the average (over all variables) total variation error in the variable marginals;" << endl; cout << " o the error (difference) of the logarithm of the partition sums;" << endl << endl; cout << "All errors are calculated by comparing the results of the current method with" << endl; cout << "the results of the first method (the base method). If marginals==VAR, additional" << endl; cout << "output consists of the variable marginals, and if marginals==ALL, all marginals" << endl; cout << "calculated by the method are reported." << endl << endl; cout << " should be a list of one or more methods, seperated by spaces, in the format:" << endl << endl; cout << " name[key1=val1,key2=val2,key3=val3,...,keyn=valn]" << endl << endl; cout << "where name should be the name of an algorithm in libDAI (or an alias, if an alias" << endl; cout << "filename is provided), followed by a list of properties (surrounded by rectangular" << endl; cout << "brackets), where each property consists of a key=value pair and the properties are" << endl; cout << "seperated by commas. If an alias file is specified, alias substitution is performed." << endl; cout << "This is done by looking up the name in the alias file and substituting the alias" << endl; cout << "by its corresponding method as defined in the alias file. Properties are parsed from" << endl; cout << "left to right, so if a property occurs repeatedly, the right-most value is used." << endl << endl; cout << opts_required << opts_optional << endl; #ifdef DAI_DEBUG cout << "Note: this is a debugging build of libDAI." << endl << endl; #endif cout << "Example: ./testdai --filename testfast.fg --aliases aliases.conf --methods JTREE_HUGIN BP_SEQFIX BP_PARALL[maxiter=5]" << endl; return 1; } try { // Read aliases map Aliases; if( !aliases.empty() ) Aliases = readAliasesFile( aliases ); // Read factor graph FactorGraph fg; fg.ReadFromFile( filename.c_str() ); // Declare variables used for storing variable marginals and log partition sum of base method vector varMarginals0; Real logZ0 = 0.0; // Output header cout.setf( ios_base::scientific ); cout.precision( 3 ); cout << "# " << filename << endl; cout.width( 39 ); cout << left << "# METHOD" << "\t"; if( report_time ) cout << right << "SECONDS " << "\t"; if( report_iters ) cout << "ITERS" << "\t"; cout << "MAX ERROR" << "\t"; cout << "AVG ERROR" << "\t"; cout << "LOGZ ERROR" << "\t"; cout << "MAXDIFF" << "\t"; cout << endl; // For each method... for( size_t m = 0; m < methods.size(); m++ ) { // Parse method pair meth = parseNameProperties( methods[m], Aliases ); // Check whether name is valid size_t n = 0; for( ; strlen( DAINames[n] ) != 0; n++ ) if( meth.first == DAINames[n] ) break; if( strlen( DAINames[n] ) == 0 ) DAI_THROWE(UNKNOWN_DAI_ALGORITHM,string("Unknown DAI algorithm \"") + meth.first + string("\" in \"") + methods[m] + string("\"")); // Construct object for running the method TestDAI testdai(fg, meth.first, meth.second ); // Run the method testdai.doDAI(); // For the base method, store its variable marginals and logarithm of the partition sum if( m == 0 ) { varMarginals0 = testdai.varMarginals; logZ0 = testdai.logZ; } // Calculate errors relative to base method testdai.calcErrs( varMarginals0 ); // Output method name cout.width( 39 ); cout << left << methods[m] << "\t"; // Output calculation time, if requested if( report_time ) cout << right << testdai.time << "\t"; // Output number of iterations, if requested if( report_iters ) { if( testdai.has_iters ) { cout << testdai.iters << "\t"; } else { cout << "N/A \t"; } } // If this is not the base method if( m > 0 ) { cout.setf( ios_base::scientific ); cout.precision( 3 ); // Output maximum error in variable marginals Real me = clipReal( testdai.maxErr(), 1e-9 ); cout << me << "\t"; // Output average error in variable marginals Real ae = clipReal( testdai.avgErr(), 1e-9 ); cout << ae << "\t"; // Output error in log partition sum if( testdai.has_logZ ) { cout.setf( ios::showpos ); Real le = clipReal( testdai.logZ - logZ0, 1e-9 ); cout << le << "\t"; cout.unsetf( ios::showpos ); } else cout << "N/A \t"; // Output maximum difference in last iteration if( testdai.has_maxdiff ) { Real md = clipReal( testdai.maxdiff, 1e-9 ); if( isnan( me ) ) md = me; if( isnan( ae ) ) md = ae; if( md == INFINITY ) md = 1.0; cout << md << "\t"; } else cout << "N/A \t"; } cout << endl; // Output marginals, if requested if( marginals == MarginalsOutputType::VAR ) { for( size_t i = 0; i < testdai.varMarginals.size(); i++ ) cout << "# " << testdai.varMarginals[i] << endl; } else if( marginals == MarginalsOutputType::ALL ) { for( size_t I = 0; I < testdai.allMarginals.size(); I++ ) cout << "# " << testdai.allMarginals[I] << endl; } } return 0; } catch( string &s ) { // Abort with error message cerr << "Exception: " << s << endl; return 2; } } libDAI-0.2.4/tests/hoi4.fg0000644000263000017630000000123511334764774014021 0ustar jorismkyb# Factor graph made by ../utils/createfg # type = hoi # N = 10 # M = 3 # k = 3 # beta = 1 # seed = 123456 3 3 5 7 9 2 2 2 8 0 0.34695110012176 1 5.2445568426086 2 0.40353951923864 3 0.87337008674168 4 1.8484229288021 5 1.3558019751326 6 0.18957537662536 7 1.0106086348982 3 7 8 9 2 2 2 8 0 1.4346630217766 1 1.7381665310949 2 1.4305082973985 3 0.93926886261587 4 0.37893660692703 5 0.82593511761888 6 0.24322233722175 7 0.30679804692782 3 0 6 7 2 2 2 8 0 0.5061849993673 1 1.6117048972906 2 2.0693735419645 3 0.5455720871037 4 2.0160537987371 5 0.30172846959351 6 1.8962849316602 7 3.5838027075412 libDAI-0.2.4/tests/aliases.conf0000644000263000017630000002535211334764774015136 0ustar jorismkyb# This file contains reasonable default settings for various inference # algorithms in libDAI. Each non-empty line should either be a comment # (starting with #) or contain an alias definition in the format # # alias: name[key1=val1,key2=val2,...,keyn=valn] # # where name should be a valid libDAI algorithm name, and the list of # its properties (between rectangular brackets) consists of key=value # pairs, seperated by spaces. This defines 'alias' as a shortcut for # the rest of the line (more precisely, the contents to the right of # the colon and possible whitespace). # --- EXACT ------------------- EXACT: EXACT[verbose=0] # --- BP ---------------------- BP: BP[updates=SEQFIX,tol=1e-9,maxiter=10000,logdomain=0] BP_SEQFIX: BP[updates=SEQFIX,tol=1e-9,maxiter=10000,logdomain=0] BP_SEQRND: BP[updates=SEQRND,tol=1e-9,maxiter=10000,logdomain=0] BP_SEQMAX: BP[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0] BP_PARALL: BP[updates=PARALL,tol=1e-9,maxiter=10000,logdomain=0] BP_SEQFIX_LOG: BP[updates=SEQFIX,tol=1e-9,maxiter=10000,logdomain=1] BP_SEQRND_LOG: BP[updates=SEQRND,tol=1e-9,maxiter=10000,logdomain=1] BP_SEQMAX_LOG: BP[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=1] BP_PARALL_LOG: BP[updates=PARALL,tol=1e-9,maxiter=10000,logdomain=1] MP_SEQFIX: BP[updates=SEQFIX,tol=1e-9,maxiter=10000,logdomain=0,inference=MAXPROD] MP_SEQRND: BP[updates=SEQRND,tol=1e-9,maxiter=10000,logdomain=0,inference=MAXPROD] MP_SEQMAX: BP[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0,inference=MAXPROD] MP_PARALL: BP[updates=PARALL,tol=1e-9,maxiter=10000,logdomain=0,inference=MAXPROD] MP_SEQFIX_LOG: BP[updates=SEQFIX,tol=1e-9,maxiter=10000,logdomain=1,inference=MAXPROD] MP_SEQRND_LOG: BP[updates=SEQRND,tol=1e-9,maxiter=10000,logdomain=1,inference=MAXPROD] MP_SEQMAX_LOG: BP[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=1,inference=MAXPROD] MP_PARALL_LOG: BP[updates=PARALL,tol=1e-9,maxiter=10000,logdomain=1,inference=MAXPROD] # --- FBP --------------------- FBP: FBP[updates=SEQFIX,tol=1e-9,maxiter=10000,logdomain=0] # --- TRWBP ------------------- TRWBP: TRWBP[updates=SEQFIX,tol=1e-9,maxiter=10000,logdomain=0] # --- JTREE ------------------- JTREE_HUGIN: JTREE[updates=HUGIN,verbose=0] JTREE_SHSH: JTREE[updates=SHSH,verbose=0] JTREE_HUGIN_MAP: JTREE[updates=HUGIN,verbose=0,inference=MAXPROD] JTREE_SHSH_MAP: JTREE[updates=SHSH,verbose=0,inference=MAXPROD] # --- MF ---------------------- MF_SEQRND: MF[tol=1e-9,maxiter=10000] # --- TREEEP ------------------ TREEEP: TREEEP[type=ORG,tol=1e-9,maxiter=10000,verbose=0] TREEEPWC: TREEEP[type=ALT,tol=1e-9,maxiter=10000,verbose=0] # --- MR ---------------------- MR_DEFAULT: MR[updates=FULL,inits=RESPPROP,verbose=0,tol=1e-9] MR_RESPPROP_FULL: MR[updates=FULL,inits=RESPPROP,verbose=0,tol=1e-9] MR_RESPPROP_LINEAR: MR[updates=LINEAR,inits=RESPPROP,verbose=0,tol=1e-9] MR_CLAMPING_FULL: MR[updates=FULL,inits=CLAMPING,verbose=0,tol=1e-9] MR_CLAMPING_LINEAR: MR[updates=LINEAR,inits=CLAMPING,verbose=0,tol=1e-9] MR_EXACT_FULL: MR[updates=FULL,inits=EXACT,verbose=0,tol=1e-9] MR_EXACT_LINEAR: MR[updates=LINEAR,inits=EXACT,verbose=0,tol=1e-9] # --- HAK --------------------- GBP_MIN: HAK[doubleloop=0,clusters=MIN,init=UNIFORM,tol=1e-9,maxiter=10000,verbose=0] GBP_BETHE: HAK[doubleloop=0,clusters=BETHE,init=UNIFORM,tol=1e-9,maxiter=10000,verbose=0] GBP_DELTA: HAK[doubleloop=0,clusters=DELTA,init=UNIFORM,tol=1e-9,maxiter=10000,verbose=0] GBP_LOOP3: HAK[doubleloop=0,clusters=LOOP,init=UNIFORM,loopdepth=3,tol=1e-9,maxiter=10000,verbose=0] GBP_LOOP4: HAK[doubleloop=0,clusters=LOOP,init=UNIFORM,loopdepth=4,tol=1e-9,maxiter=10000,verbose=0] GBP_LOOP5: HAK[doubleloop=0,clusters=LOOP,init=UNIFORM,loopdepth=5,tol=1e-9,maxiter=10000,verbose=0] GBP_LOOP6: HAK[doubleloop=0,clusters=LOOP,init=UNIFORM,loopdepth=6,tol=1e-9,maxiter=10000,verbose=0] GBP_LOOP7: HAK[doubleloop=0,clusters=LOOP,init=UNIFORM,loopdepth=7,tol=1e-9,maxiter=10000,verbose=0] GBP_LOOP8: HAK[doubleloop=0,clusters=LOOP,init=UNIFORM,loopdepth=8,tol=1e-9,maxiter=10000,verbose=0] HAK_MIN: HAK[doubleloop=1,clusters=MIN,init=UNIFORM,tol=1e-9,maxiter=10000,verbose=0] HAK_BETHE: HAK[doubleloop=1,clusters=BETHE,init=UNIFORM,tol=1e-9,maxiter=10000,verbose=0] HAK_DELTA: HAK[doubleloop=1,clusters=DELTA,init=UNIFORM,tol=1e-9,maxiter=10000,verbose=0] HAK_LOOP3: HAK[doubleloop=1,clusters=LOOP,init=UNIFORM,loopdepth=3,tol=1e-9,maxiter=10000,verbose=0] HAK_LOOP4: HAK[doubleloop=1,clusters=LOOP,init=UNIFORM,loopdepth=4,tol=1e-9,maxiter=10000,verbose=0] HAK_LOOP5: HAK[doubleloop=1,clusters=LOOP,init=UNIFORM,loopdepth=5,tol=1e-9,maxiter=10000,verbose=0] HAK_LOOP6: HAK[doubleloop=1,clusters=LOOP,init=UNIFORM,loopdepth=6,tol=1e-9,maxiter=10000,verbose=0] HAK_LOOP7: HAK[doubleloop=1,clusters=LOOP,init=UNIFORM,loopdepth=7,tol=1e-9,maxiter=10000,verbose=0] HAK_LOOP8: HAK[doubleloop=1,clusters=LOOP,init=UNIFORM,loopdepth=8,tol=1e-9,maxiter=10000,verbose=0] # --- LC ---------------------- LCBP_FULLCAVin_SEQFIX: LC[cavity=FULL,reinit=1,updates=SEQFIX,maxiter=10000,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9,verbose=0] LCBP_FULLCAVin_SEQRND: LC[cavity=FULL,reinit=1,updates=SEQRND,maxiter=10000,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9,verbose=0] LCBP_FULLCAVin_NONE: LC[cavity=FULL,reinit=1,updates=SEQFIX,maxiter=0,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9,verbose=0] LCBP_FULLCAV_SEQFIX: LC[cavity=FULL,reinit=0,updates=SEQFIX,maxiter=10000,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9,verbose=0] LCBP_FULLCAV_SEQRND: LC[cavity=FULL,reinit=0,updates=SEQRND,maxiter=10000,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9,verbose=0] LCBP_FULLCAV_NONE: LC[cavity=FULL,reinit=0,updates=SEQFIX,maxiter=0,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9,verbose=0] LCBP_PAIRCAVin_SEQFIX: LC[cavity=PAIR,reinit=1,updates=SEQFIX,maxiter=10000,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9,verbose=0] LCBP_PAIRCAVin_SEQRND: LC[cavity=PAIR,reinit=1,updates=SEQRND,maxiter=10000,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9,verbose=0] LCBP_PAIRCAVin_NONE: LC[cavity=PAIR,reinit=1,updates=SEQFIX,maxiter=0,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9,verbose=0] LCBP_PAIRCAV_SEQFIX: LC[cavity=PAIR,reinit=0,updates=SEQFIX,maxiter=10000,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9,verbose=0] LCBP_PAIRCAV_SEQRND: LC[cavity=PAIR,reinit=0,updates=SEQRND,maxiter=10000,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9,verbose=0] LCBP_PAIRCAV_NONE: LC[cavity=PAIR,reinit=0,updates=SEQFIX,maxiter=0,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9,verbose=0] LCBP_PAIR2CAVin_SEQFIX: LC[cavity=PAIR2,reinit=1,updates=SEQFIX,maxiter=10000,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9,verbose=0] LCBP_PAIR2CAVin_SEQRND: LC[cavity=PAIR2,reinit=1,updates=SEQRND,maxiter=10000,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9,verbose=0] LCBP_PAIR2CAVin_NONE: LC[cavity=PAIR2,reinit=1,updates=SEQFIX,maxiter=0,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9,verbose=0] LCBP_PAIR2CAV_SEQFIX: LC[cavity=PAIR2,reinit=0,updates=SEQFIX,maxiter=10000,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9,verbose=0] LCBP_PAIR2CAV_SEQRND: LC[cavity=PAIR2,reinit=0,updates=SEQRND,maxiter=10000,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9,verbose=0] LCBP_PAIR2CAV_NONE: LC[cavity=PAIR2,reinit=0,updates=SEQFIX,maxiter=0,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9,verbose=0] LCBP_UNICAV_SEQFIX: LC[cavity=UNIFORM,updates=SEQFIX,maxiter=10000,tol=1e-9,verbose=0,cavaiopts=[],cavainame=NONE] LCBP_UNICAV_SEQRND: LC[cavity=UNIFORM,updates=SEQRND,maxiter=10000,tol=1e-9,verbose=0,cavaiopts=[],cavainame=NONE] LCTREEEP: LC[cavity=FULL,reinit=1,updates=SEQFIX,maxiter=10000,cavainame=TREEEP,cavaiopts=[type=ORG,tol=1e-9,maxiter=10000,verbose=0],tol=1e-9,verbose=0] LCMF: LC[cavity=FULL,reinit=1,updates=SEQFIX,maxiter=10000,cavainame=MF,cavaiopts=[tol=1e-9,maxiter=10000,verbose=0],tol=1e-9,verbose=0] LCBP: LCBP_FULLCAVin_SEQRND # --- GIBBS ------------------- GIBBS: GIBBS[iters=1000,burnin=100,verbose=0] GIBBS_1e1: GIBBS[iters=10,burnin=1,verbose=0] GIBBS_1e2: GIBBS[iters=100,burnin=10,verbose=0] GIBBS_1e3: GIBBS[iters=1000,burnin=100,verbose=0] GIBBS_1e4: GIBBS[iters=10000,burnin=1000,verbose=0] GIBBS_1e5: GIBBS[iters=100000,burnin=10000,verbose=0] GIBBS_1e6: GIBBS[iters=1000000,burnin=100000,verbose=0] GIBBS_1e7: GIBBS[iters=10000000,burnin=100000,verbose=0] GIBBS_1e8: GIBBS[iters=100000000,burnin=100000,verbose=0] GIBBS_1e9: GIBBS[iters=1000000000,burnin=100000,verbose=0] # --- CBP --------------------- CBP: CBP[max_levels=12,updates=SEQMAX,tol=1e-9,rec_tol=1e-9,maxiter=500,choose=CHOOSE_RANDOM,recursion=REC_FIXED,clamp=CLAMP_VAR,min_max_adj=1.0e-9,bbp_cfn=CFN_FACTOR_ENT,verbose=0,rand_seed=0,bbp_props=[verbose=0,tol=1.0e-9,maxiter=10000,damping=0,updates=SEQ_BP_REV],clamp_outfile=] BBP: CBP[choose=CHOOSE_BBP] libDAI-0.2.4/tests/testregression.bat0000755000263000017630000000017411334764774016414 0ustar jorismkybtestall testfast.fg | sed "s/\(e[+-]\)0/\1/g" > testfast.out.tmp diff -s testfast.out.tmp testfast.out del testfast.out.tmp libDAI-0.2.4/tests/hoi1.fg0000644000263000017630000000123111334764774014012 0ustar jorismkyb# Factor graph made by utils/createfg # type = hoi # N = 10 # M = 3 # k = 3 # beta = 1 # seed = 12345 3 3 2 6 7 2 2 2 8 0 2.6190635748817 1 0.68885412652977 2 0.83464115122831 3 0.38475684223169 4 0.3255025197617 5 1.9692111887049 6 0.55208846715017 7 0.38595110280868 3 0 1 6 2 2 2 8 0 1.0352133626924 1 1.547478952122 2 2.3176521897449 3 1.2804190071868 4 4.9220798130027 5 2.5272557501946 6 0.83127929631575 7 0.26280563080263 3 1 2 4 2 2 2 8 0 0.2371680948972 1 3.7876163914702 2 5.3196087077347 3 0.96049191560722 4 4.8483648454236 5 0.45974506954001 6 2.1151447659773 7 0.57337737335857 libDAI-0.2.4/tests/testall.bat0000755000263000017630000000164211334764774015005 0ustar jorismkyb@testdai --report-iters false --report-time false --marginals VAR --aliases aliases.conf --filename %1 --methods EXACT JTREE_HUGIN JTREE_SHSH BP_SEQFIX BP_SEQRND BP_SEQMAX BP_PARALL BP_SEQFIX_LOG BP_SEQRND_LOG BP_SEQMAX_LOG BP_PARALL_LOG FBP TRWBP MF_SEQRND TREEEP TREEEPWC GBP_MIN GBP_BETHE GBP_DELTA GBP_LOOP3 GBP_LOOP4 GBP_LOOP5 GBP_LOOP6 GBP_LOOP7 HAK_MIN HAK_BETHE HAK_DELTA HAK_LOOP3 HAK_LOOP4 HAK_LOOP5 MR_RESPPROP_FULL MR_CLAMPING_FULL MR_EXACT_FULL MR_RESPPROP_LINEAR MR_CLAMPING_LINEAR MR_EXACT_LINEAR LCBP_FULLCAV_SEQFIX LCBP_FULLCAVin_SEQFIX LCBP_FULLCAV_SEQRND LCBP_FULLCAVin_SEQRND LCBP_FULLCAV_NONE LCBP_FULLCAVin_NONE LCBP_PAIRCAV_SEQFIX LCBP_PAIRCAVin_SEQFIX LCBP_PAIRCAV_SEQRND LCBP_PAIRCAVin_SEQRND LCBP_PAIRCAV_NONE LCBP_PAIRCAVin_NONE LCBP_PAIR2CAV_SEQFIX LCBP_PAIR2CAVin_SEQFIX LCBP_PAIR2CAV_SEQRND LCBP_PAIR2CAVin_SEQRND LCBP_PAIR2CAV_NONE LCBP_PAIR2CAVin_NONE LCBP_UNICAV_SEQFIX LCBP_UNICAV_SEQRND BBP CBP libDAI-0.2.4/tests/testregression0000755000263000017630000000026211334764774015645 0ustar jorismkyb#!/bin/bash TMPFILE1=`mktemp /var/tmp/testfast.XXXXXX` trap 'rm -f $TMP_FILE' 0 1 15 ./testall testfast.fg > $TMPFILE1 diff -s $TMPFILE1 testfast.out || exit 1 rm -f $TMPFILE1 libDAI-0.2.4/tests/testfast.fg0000644000263000017630000000772111334764774015021 0ustar jorismkyb48 2 0 1 2 2 4 0 0.50642682706079 1 1.974618931236 2 1.974618931236 3 0.50642682706079 2 0 3 2 2 4 0 1.2352015396046 1 0.80958448312827 2 0.80958448312827 3 1.2352015396046 2 0 4 2 2 4 0 0.56767940536294 1 1.7615576512956 2 1.7615576512956 3 0.56767940536294 2 0 12 2 2 4 0 0.55052656590526 1 1.8164427693978 2 1.8164427693978 3 0.55052656590526 2 1 2 2 2 4 0 0.43898294556867 1 2.2779928243103 2 2.2779928243103 3 0.43898294556867 2 1 5 2 2 4 0 1.831064078623 1 0.54613053233616 2 0.54613053233616 3 1.831064078623 2 1 13 2 2 4 0 1.3903485747176 1 0.7192440933045 2 0.7192440933045 3 1.3903485747176 2 2 3 2 2 4 0 0.58481531122247 1 1.7099415504523 2 1.7099415504523 3 0.58481531122247 2 2 6 2 2 4 0 1.5596330646909 1 0.64117645530823 2 0.64117645530823 3 1.5596330646909 2 2 14 2 2 4 0 0.89768153552837 1 1.1139808054662 2 1.1139808054662 3 0.89768153552837 2 3 7 2 2 4 0 1.0462432557883 1 0.95580066534961 2 0.95580066534961 3 1.0462432557883 2 3 15 2 2 4 0 0.77279470413231 1 1.2940047268088 2 1.2940047268088 3 0.77279470413231 2 4 5 2 2 4 0 1.3105292388585 1 0.76305050688605 2 0.76305050688605 3 1.3105292388585 2 4 7 2 2 4 0 0.97355416145559 1 1.0271642190968 2 1.0271642190968 3 0.97355416145559 2 4 8 2 2 4 0 0.4047606195496 1 2.4705960800059 2 2.4705960800059 3 0.4047606195496 2 5 6 2 2 4 0 0.43500831412106 1 2.2988066378007 2 2.2988066378007 3 0.43500831412106 2 5 9 2 2 4 0 0.76229363075105 1 1.3118304543811 2 1.3118304543811 3 0.76229363075105 2 6 7 2 2 4 0 0.64752760170748 1 1.544335712274 2 1.544335712274 3 0.64752760170748 2 6 10 2 2 4 0 2.0478590660831 1 0.48831485357665 2 0.48831485357665 3 2.0478590660831 2 7 11 2 2 4 0 0.80739864245046 1 1.2385455553467 2 1.2385455553467 3 0.80739864245046 2 8 9 2 2 4 0 2.6310917043359 1 0.38007037092324 2 0.38007037092324 3 2.6310917043359 2 8 11 2 2 4 0 1.6723443743364 1 0.59796296465362 2 0.59796296465362 3 1.6723443743364 2 8 12 2 2 4 0 2.0658398413315 1 0.48406463075835 2 0.48406463075835 3 2.0658398413315 2 9 10 2 2 4 0 0.54424622899323 1 1.8374036359422 2 1.8374036359422 3 0.54424622899323 2 9 13 2 2 4 0 1.9870315102311 1 0.5032632823642 2 0.5032632823642 3 1.9870315102311 2 10 11 2 2 4 0 1.2190979644608 1 0.82027862333633 2 0.82027862333633 3 1.2190979644608 2 10 14 2 2 4 0 2.0968141189151 1 0.47691399584689 2 0.47691399584689 3 2.0968141189151 2 11 15 2 2 4 0 2.1866755921376 1 0.45731520651513 2 0.45731520651513 3 2.1866755921376 2 12 13 2 2 4 0 0.3686715885806 1 2.7124411833579 2 2.7124411833579 3 0.3686715885806 2 12 15 2 2 4 0 1.7567863273152 1 0.56922118783123 2 0.56922118783123 3 1.7567863273152 2 13 14 2 2 4 0 0.97446683998919 1 1.0262021845824 2 1.0262021845824 3 0.97446683998919 2 14 15 2 2 4 0 0.50751730577226 1 1.9703761598402 2 1.9703761598402 3 0.50751730577226 1 0 2 2 0 0.79829293324787 1 1.2526729955274 1 1 2 2 0 1.5037120707519 1 0.66502093017047 1 2 2 2 0 0.75949272564564 1 1.316668305348 1 3 2 2 0 0.952586483626 1 1.0497734506934 1 4 2 2 0 1.0129167360496 1 0.98724797844692 1 5 2 2 0 0.3884658377108 1 2.5742289357873 1 6 2 2 0 1.5143199063099 1 0.66036244774516 1 7 2 2 0 0.58116800722508 1 1.7206728305206 1 8 2 2 0 0.94791545998362 1 1.0549463978753 1 9 2 2 0 0.58284868496538 1 1.715711171347 1 10 2 2 0 1.2208444069734 1 0.81910519824477 1 11 2 2 0 0.45700593414142 1 2.1881553942592 1 12 2 2 0 1.542447604411 1 0.64832023930034 1 13 2 2 0 1.3432382535607 1 0.74446956625093 1 14 2 2 0 0.54039818081703 1 1.8504873545061 1 15 2 2 0 0.43255190550874 1 2.3118612755245 libDAI-0.2.4/tests/testfast.out0000644000263000017630000010570511334764774015235 0ustar jorismkyb# testfast.fg # METHOD MAX ERROR AVG ERROR LOGZ ERROR MAXDIFF EXACT # ({x0}, (3.888e-01, 6.112e-01)) # ({x1}, (5.556e-01, 4.444e-01)) # ({x2}, (4.587e-01, 5.413e-01)) # ({x3}, (5.480e-01, 4.520e-01)) # ({x4}, (6.660e-01, 3.340e-01)) # ({x5}, (2.107e-01, 7.893e-01)) # ({x6}, (8.178e-01, 1.822e-01)) # ({x7}, (2.327e-01, 7.673e-01)) # ({x8}, (2.171e-01, 7.829e-01)) # ({x9}, (2.052e-01, 7.948e-01)) # ({x10}, (7.665e-01, 2.335e-01)) # ({x11}, (1.217e-01, 8.783e-01)) # ({x12}, (4.214e-01, 5.786e-01)) # ({x13}, (5.348e-01, 4.652e-01)) # ({x14}, (6.291e-01, 3.709e-01)) # ({x15}, (1.357e-01, 8.643e-01)) JTREE_HUGIN 1.000e-09 1.000e-09 +1.000e-09 1.000e-09 # ({x0}, (3.888e-01, 6.112e-01)) # ({x1}, (5.556e-01, 4.444e-01)) # ({x2}, (4.587e-01, 5.413e-01)) # ({x3}, (5.480e-01, 4.520e-01)) # ({x4}, (6.660e-01, 3.340e-01)) # ({x5}, (2.107e-01, 7.893e-01)) # ({x6}, (8.178e-01, 1.822e-01)) # ({x7}, (2.327e-01, 7.673e-01)) # ({x8}, (2.171e-01, 7.829e-01)) # ({x9}, (2.052e-01, 7.948e-01)) # ({x10}, (7.665e-01, 2.335e-01)) # ({x11}, (1.217e-01, 8.783e-01)) # ({x12}, (4.214e-01, 5.786e-01)) # ({x13}, (5.348e-01, 4.652e-01)) # ({x14}, (6.291e-01, 3.709e-01)) # ({x15}, (1.357e-01, 8.643e-01)) JTREE_SHSH 1.000e-09 1.000e-09 +1.000e-09 1.000e-09 # ({x0}, (3.888e-01, 6.112e-01)) # ({x1}, (5.556e-01, 4.444e-01)) # ({x2}, (4.587e-01, 5.413e-01)) # ({x3}, (5.480e-01, 4.520e-01)) # ({x4}, (6.660e-01, 3.340e-01)) # ({x5}, (2.107e-01, 7.893e-01)) # ({x6}, (8.178e-01, 1.822e-01)) # ({x7}, (2.327e-01, 7.673e-01)) # ({x8}, (2.171e-01, 7.829e-01)) # ({x9}, (2.052e-01, 7.948e-01)) # ({x10}, (7.665e-01, 2.335e-01)) # ({x11}, (1.217e-01, 8.783e-01)) # ({x12}, (4.214e-01, 5.786e-01)) # ({x13}, (5.348e-01, 4.652e-01)) # ({x14}, (6.291e-01, 3.709e-01)) # ({x15}, (1.357e-01, 8.643e-01)) BP_SEQFIX 9.483e-02 3.078e-02 +2.969e-01 1.000e-09 # ({x0}, (4.233e-01, 5.767e-01)) # ({x1}, (5.422e-01, 4.578e-01)) # ({x2}, (4.662e-01, 5.338e-01)) # ({x3}, (5.424e-01, 4.576e-01)) # ({x4}, (6.042e-01, 3.958e-01)) # ({x5}, (1.845e-01, 8.155e-01)) # ({x6}, (8.203e-01, 1.797e-01)) # ({x7}, (2.292e-01, 7.708e-01)) # ({x8}, (3.119e-01, 6.881e-01)) # ({x9}, (2.975e-01, 7.025e-01)) # ({x10}, (7.268e-01, 2.732e-01)) # ({x11}, (1.485e-01, 8.515e-01)) # ({x12}, (4.512e-01, 5.488e-01)) # ({x13}, (5.266e-01, 4.734e-01)) # ({x14}, (6.033e-01, 3.967e-01)) # ({x15}, (1.558e-01, 8.442e-01)) BP_SEQRND 9.483e-02 3.078e-02 +2.969e-01 1.000e-09 # ({x0}, (4.233e-01, 5.767e-01)) # ({x1}, (5.422e-01, 4.578e-01)) # ({x2}, (4.662e-01, 5.338e-01)) # ({x3}, (5.424e-01, 4.576e-01)) # ({x4}, (6.042e-01, 3.958e-01)) # ({x5}, (1.845e-01, 8.155e-01)) # ({x6}, (8.203e-01, 1.797e-01)) # ({x7}, (2.292e-01, 7.708e-01)) # ({x8}, (3.119e-01, 6.881e-01)) # ({x9}, (2.975e-01, 7.025e-01)) # ({x10}, (7.268e-01, 2.732e-01)) # ({x11}, (1.485e-01, 8.515e-01)) # ({x12}, (4.512e-01, 5.488e-01)) # ({x13}, (5.266e-01, 4.734e-01)) # ({x14}, (6.033e-01, 3.967e-01)) # ({x15}, (1.558e-01, 8.442e-01)) BP_SEQMAX 9.483e-02 3.078e-02 +2.969e-01 1.000e-09 # ({x0}, (4.233e-01, 5.767e-01)) # ({x1}, (5.422e-01, 4.578e-01)) # ({x2}, (4.662e-01, 5.338e-01)) # ({x3}, (5.424e-01, 4.576e-01)) # ({x4}, (6.042e-01, 3.958e-01)) # ({x5}, (1.845e-01, 8.155e-01)) # ({x6}, (8.203e-01, 1.797e-01)) # ({x7}, (2.292e-01, 7.708e-01)) # ({x8}, (3.119e-01, 6.881e-01)) # ({x9}, (2.975e-01, 7.025e-01)) # ({x10}, (7.268e-01, 2.732e-01)) # ({x11}, (1.485e-01, 8.515e-01)) # ({x12}, (4.512e-01, 5.488e-01)) # ({x13}, (5.266e-01, 4.734e-01)) # ({x14}, (6.033e-01, 3.967e-01)) # ({x15}, (1.558e-01, 8.442e-01)) BP_PARALL 9.483e-02 3.078e-02 +2.969e-01 1.000e-09 # ({x0}, (4.233e-01, 5.767e-01)) # ({x1}, (5.422e-01, 4.578e-01)) # ({x2}, (4.662e-01, 5.338e-01)) # ({x3}, (5.424e-01, 4.576e-01)) # ({x4}, (6.042e-01, 3.958e-01)) # ({x5}, (1.845e-01, 8.155e-01)) # ({x6}, (8.203e-01, 1.797e-01)) # ({x7}, (2.292e-01, 7.708e-01)) # ({x8}, (3.119e-01, 6.881e-01)) # ({x9}, (2.975e-01, 7.025e-01)) # ({x10}, (7.268e-01, 2.732e-01)) # ({x11}, (1.485e-01, 8.515e-01)) # ({x12}, (4.512e-01, 5.488e-01)) # ({x13}, (5.266e-01, 4.734e-01)) # ({x14}, (6.033e-01, 3.967e-01)) # ({x15}, (1.558e-01, 8.442e-01)) BP_SEQFIX_LOG 9.483e-02 3.078e-02 +2.969e-01 1.000e-09 # ({x0}, (4.233e-01, 5.767e-01)) # ({x1}, (5.422e-01, 4.578e-01)) # ({x2}, (4.662e-01, 5.338e-01)) # ({x3}, (5.424e-01, 4.576e-01)) # ({x4}, (6.042e-01, 3.958e-01)) # ({x5}, (1.845e-01, 8.155e-01)) # ({x6}, (8.203e-01, 1.797e-01)) # ({x7}, (2.292e-01, 7.708e-01)) # ({x8}, (3.119e-01, 6.881e-01)) # ({x9}, (2.975e-01, 7.025e-01)) # ({x10}, (7.268e-01, 2.732e-01)) # ({x11}, (1.485e-01, 8.515e-01)) # ({x12}, (4.512e-01, 5.488e-01)) # ({x13}, (5.266e-01, 4.734e-01)) # ({x14}, (6.033e-01, 3.967e-01)) # ({x15}, (1.558e-01, 8.442e-01)) BP_SEQRND_LOG 9.483e-02 3.078e-02 +2.969e-01 1.000e-09 # ({x0}, (4.233e-01, 5.767e-01)) # ({x1}, (5.422e-01, 4.578e-01)) # ({x2}, (4.662e-01, 5.338e-01)) # ({x3}, (5.424e-01, 4.576e-01)) # ({x4}, (6.042e-01, 3.958e-01)) # ({x5}, (1.845e-01, 8.155e-01)) # ({x6}, (8.203e-01, 1.797e-01)) # ({x7}, (2.292e-01, 7.708e-01)) # ({x8}, (3.119e-01, 6.881e-01)) # ({x9}, (2.975e-01, 7.025e-01)) # ({x10}, (7.268e-01, 2.732e-01)) # ({x11}, (1.485e-01, 8.515e-01)) # ({x12}, (4.512e-01, 5.488e-01)) # ({x13}, (5.266e-01, 4.734e-01)) # ({x14}, (6.033e-01, 3.967e-01)) # ({x15}, (1.558e-01, 8.442e-01)) BP_SEQMAX_LOG 9.483e-02 3.078e-02 +2.969e-01 1.000e-09 # ({x0}, (4.233e-01, 5.767e-01)) # ({x1}, (5.422e-01, 4.578e-01)) # ({x2}, (4.662e-01, 5.338e-01)) # ({x3}, (5.424e-01, 4.576e-01)) # ({x4}, (6.042e-01, 3.958e-01)) # ({x5}, (1.845e-01, 8.155e-01)) # ({x6}, (8.203e-01, 1.797e-01)) # ({x7}, (2.292e-01, 7.708e-01)) # ({x8}, (3.119e-01, 6.881e-01)) # ({x9}, (2.975e-01, 7.025e-01)) # ({x10}, (7.268e-01, 2.732e-01)) # ({x11}, (1.485e-01, 8.515e-01)) # ({x12}, (4.512e-01, 5.488e-01)) # ({x13}, (5.266e-01, 4.734e-01)) # ({x14}, (6.033e-01, 3.967e-01)) # ({x15}, (1.558e-01, 8.442e-01)) BP_PARALL_LOG 9.483e-02 3.078e-02 +2.969e-01 1.000e-09 # ({x0}, (4.233e-01, 5.767e-01)) # ({x1}, (5.422e-01, 4.578e-01)) # ({x2}, (4.662e-01, 5.338e-01)) # ({x3}, (5.424e-01, 4.576e-01)) # ({x4}, (6.042e-01, 3.958e-01)) # ({x5}, (1.845e-01, 8.155e-01)) # ({x6}, (8.203e-01, 1.797e-01)) # ({x7}, (2.292e-01, 7.708e-01)) # ({x8}, (3.119e-01, 6.881e-01)) # ({x9}, (2.975e-01, 7.025e-01)) # ({x10}, (7.268e-01, 2.732e-01)) # ({x11}, (1.485e-01, 8.515e-01)) # ({x12}, (4.512e-01, 5.488e-01)) # ({x13}, (5.266e-01, 4.734e-01)) # ({x14}, (6.033e-01, 3.967e-01)) # ({x15}, (1.558e-01, 8.442e-01)) FBP 9.483e-02 3.078e-02 +2.969e-01 1.000e-09 # ({x0}, (4.233e-01, 5.767e-01)) # ({x1}, (5.422e-01, 4.578e-01)) # ({x2}, (4.662e-01, 5.338e-01)) # ({x3}, (5.424e-01, 4.576e-01)) # ({x4}, (6.042e-01, 3.958e-01)) # ({x5}, (1.845e-01, 8.155e-01)) # ({x6}, (8.203e-01, 1.797e-01)) # ({x7}, (2.292e-01, 7.708e-01)) # ({x8}, (3.119e-01, 6.881e-01)) # ({x9}, (2.975e-01, 7.025e-01)) # ({x10}, (7.268e-01, 2.732e-01)) # ({x11}, (1.485e-01, 8.515e-01)) # ({x12}, (4.512e-01, 5.488e-01)) # ({x13}, (5.266e-01, 4.734e-01)) # ({x14}, (6.033e-01, 3.967e-01)) # ({x15}, (1.558e-01, 8.442e-01)) TRWBP 9.483e-02 3.078e-02 +2.969e-01 1.000e-09 # ({x0}, (4.233e-01, 5.767e-01)) # ({x1}, (5.422e-01, 4.578e-01)) # ({x2}, (4.662e-01, 5.338e-01)) # ({x3}, (5.424e-01, 4.576e-01)) # ({x4}, (6.042e-01, 3.958e-01)) # ({x5}, (1.845e-01, 8.155e-01)) # ({x6}, (8.203e-01, 1.797e-01)) # ({x7}, (2.292e-01, 7.708e-01)) # ({x8}, (3.119e-01, 6.881e-01)) # ({x9}, (2.975e-01, 7.025e-01)) # ({x10}, (7.268e-01, 2.732e-01)) # ({x11}, (1.485e-01, 8.515e-01)) # ({x12}, (4.512e-01, 5.488e-01)) # ({x13}, (5.266e-01, 4.734e-01)) # ({x14}, (6.033e-01, 3.967e-01)) # ({x15}, (1.558e-01, 8.442e-01)) MF_SEQRND 3.607e-01 1.904e-01 -1.608e+00 1.000e-09 # ({x0}, (2.053e-01, 7.947e-01)) # ({x1}, (9.163e-01, 8.373e-02)) # ({x2}, (1.579e-01, 8.421e-01)) # ({x3}, (6.986e-01, 3.014e-01)) # ({x4}, (8.982e-01, 1.018e-01)) # ({x5}, (1.830e-01, 8.170e-01)) # ({x6}, (9.597e-01, 4.033e-02)) # ({x7}, (1.841e-01, 8.159e-01)) # ({x8}, (4.385e-03, 9.956e-01)) # ({x9}, (5.075e-02, 9.492e-01)) # ({x10}, (9.685e-01, 3.149e-02)) # ({x11}, (2.957e-02, 9.704e-01)) # ({x12}, (9.632e-02, 9.037e-01)) # ({x13}, (8.148e-01, 1.852e-01)) # ({x14}, (8.338e-01, 1.662e-01)) # ({x15}, (5.661e-03, 9.943e-01)) TREEEP 3.268e-02 8.023e-03 +1.084e-02 1.000e-09 # ({x0}, (3.980e-01, 6.020e-01)) # ({x1}, (5.520e-01, 4.480e-01)) # ({x2}, (4.620e-01, 5.380e-01)) # ({x3}, (5.472e-01, 4.528e-01)) # ({x4}, (6.643e-01, 3.357e-01)) # ({x5}, (1.781e-01, 8.219e-01)) # ({x6}, (8.442e-01, 1.558e-01)) # ({x7}, (2.224e-01, 7.776e-01)) # ({x8}, (2.154e-01, 7.846e-01)) # ({x9}, (2.067e-01, 7.933e-01)) # ({x10}, (7.742e-01, 2.258e-01)) # ({x11}, (1.207e-01, 8.793e-01)) # ({x12}, (4.318e-01, 5.682e-01)) # ({x13}, (5.293e-01, 4.707e-01)) # ({x14}, (6.409e-01, 3.591e-01)) # ({x15}, (1.364e-01, 8.636e-01)) TREEEPWC 2.356e-02 1.026e-02 +8.334e-02 1.000e-09 # ({x0}, (4.091e-01, 5.909e-01)) # ({x1}, (5.429e-01, 4.571e-01)) # ({x2}, (4.697e-01, 5.303e-01)) # ({x3}, (5.451e-01, 4.549e-01)) # ({x4}, (6.509e-01, 3.491e-01)) # ({x5}, (1.890e-01, 8.110e-01)) # ({x6}, (8.298e-01, 1.702e-01)) # ({x7}, (2.273e-01, 7.727e-01)) # ({x8}, (2.407e-01, 7.593e-01)) # ({x9}, (2.153e-01, 7.847e-01)) # ({x10}, (7.660e-01, 2.340e-01)) # ({x11}, (1.252e-01, 8.748e-01)) # ({x12}, (4.383e-01, 5.617e-01)) # ({x13}, (5.298e-01, 4.702e-01)) # ({x14}, (6.299e-01, 3.701e-01)) # ({x15}, (1.384e-01, 8.616e-01)) GBP_MIN 9.483e-02 3.078e-02 +2.969e-01 1.000e-09 # ({x0}, (4.233e-01, 5.767e-01)) # ({x1}, (5.422e-01, 4.578e-01)) # ({x2}, (4.662e-01, 5.338e-01)) # ({x3}, (5.424e-01, 4.576e-01)) # ({x4}, (6.042e-01, 3.958e-01)) # ({x5}, (1.845e-01, 8.155e-01)) # ({x6}, (8.203e-01, 1.797e-01)) # ({x7}, (2.292e-01, 7.708e-01)) # ({x8}, (3.119e-01, 6.881e-01)) # ({x9}, (2.975e-01, 7.025e-01)) # ({x10}, (7.268e-01, 2.732e-01)) # ({x11}, (1.485e-01, 8.515e-01)) # ({x12}, (4.512e-01, 5.488e-01)) # ({x13}, (5.266e-01, 4.734e-01)) # ({x14}, (6.033e-01, 3.967e-01)) # ({x15}, (1.558e-01, 8.442e-01)) GBP_BETHE 9.483e-02 3.078e-02 +2.969e-01 1.000e-09 # ({x0}, (4.233e-01, 5.767e-01)) # ({x1}, (5.422e-01, 4.578e-01)) # ({x2}, (4.662e-01, 5.338e-01)) # ({x3}, (5.424e-01, 4.576e-01)) # ({x4}, (6.042e-01, 3.958e-01)) # ({x5}, (1.845e-01, 8.155e-01)) # ({x6}, (8.203e-01, 1.797e-01)) # ({x7}, (2.292e-01, 7.708e-01)) # ({x8}, (3.119e-01, 6.881e-01)) # ({x9}, (2.975e-01, 7.025e-01)) # ({x10}, (7.268e-01, 2.732e-01)) # ({x11}, (1.485e-01, 8.515e-01)) # ({x12}, (4.512e-01, 5.488e-01)) # ({x13}, (5.266e-01, 4.734e-01)) # ({x14}, (6.033e-01, 3.967e-01)) # ({x15}, (1.558e-01, 8.442e-01)) GBP_DELTA 6.291e-01 3.350e-01 -5.645e+00 1.000e-09 # ({x0}, (0.000e+00, 1.000e+00)) # ({x1}, (1.000e+00, 0.000e+00)) # ({x2}, (0.000e+00, 1.000e+00)) # ({x3}, (1.000e+00, 0.000e+00)) # ({x4}, (1.000e+00, 0.000e+00)) # ({x5}, (0.000e+00, 1.000e+00)) # ({x6}, (1.000e+00, 0.000e+00)) # ({x7}, (0.000e+00, 1.000e+00)) # ({x8}, (0.000e+00, 1.000e+00)) # ({x9}, (0.000e+00, 1.000e+00)) # ({x10}, (1.000e+00, 0.000e+00)) # ({x11}, (0.000e+00, 1.000e+00)) # ({x12}, (1.000e+00, 0.000e+00)) # ({x13}, (0.000e+00, 1.000e+00)) # ({x14}, (0.000e+00, 1.000e+00)) # ({x15}, (0.000e+00, 1.000e+00)) GBP_LOOP3 9.483e-02 3.078e-02 +2.969e-01 1.000e-09 # ({x0}, (4.233e-01, 5.767e-01)) # ({x1}, (5.422e-01, 4.578e-01)) # ({x2}, (4.662e-01, 5.338e-01)) # ({x3}, (5.424e-01, 4.576e-01)) # ({x4}, (6.042e-01, 3.958e-01)) # ({x5}, (1.845e-01, 8.155e-01)) # ({x6}, (8.203e-01, 1.797e-01)) # ({x7}, (2.292e-01, 7.708e-01)) # ({x8}, (3.119e-01, 6.881e-01)) # ({x9}, (2.975e-01, 7.025e-01)) # ({x10}, (7.268e-01, 2.732e-01)) # ({x11}, (1.485e-01, 8.515e-01)) # ({x12}, (4.512e-01, 5.488e-01)) # ({x13}, (5.266e-01, 4.734e-01)) # ({x14}, (6.033e-01, 3.967e-01)) # ({x15}, (1.558e-01, 8.442e-01)) GBP_LOOP4 7.893e-01 3.728e-01 -9.954e+00 1.000e-09 # ({x0}, (0.000e+00, 1.000e+00)) # ({x1}, (1.000e+00, 0.000e+00)) # ({x2}, (0.000e+00, 1.000e+00)) # ({x3}, (0.000e+00, 1.000e+00)) # ({x4}, (1.000e+00, 0.000e+00)) # ({x5}, (1.000e+00, 0.000e+00)) # ({x6}, (1.000e+00, 0.000e+00)) # ({x7}, (0.000e+00, 1.000e+00)) # ({x8}, (0.000e+00, 1.000e+00)) # ({x9}, (0.000e+00, 1.000e+00)) # ({x10}, (1.000e+00, 0.000e+00)) # ({x11}, (0.000e+00, 1.000e+00)) # ({x12}, (1.000e+00, 0.000e+00)) # ({x13}, (1.000e+00, 0.000e+00)) # ({x14}, (0.000e+00, 1.000e+00)) # ({x15}, (0.000e+00, 1.000e+00)) GBP_LOOP5 7.893e-01 3.728e-01 -9.954e+00 1.000e-09 # ({x0}, (0.000e+00, 1.000e+00)) # ({x1}, (1.000e+00, 0.000e+00)) # ({x2}, (0.000e+00, 1.000e+00)) # ({x3}, (0.000e+00, 1.000e+00)) # ({x4}, (1.000e+00, 0.000e+00)) # ({x5}, (1.000e+00, 0.000e+00)) # ({x6}, (1.000e+00, 0.000e+00)) # ({x7}, (0.000e+00, 1.000e+00)) # ({x8}, (0.000e+00, 1.000e+00)) # ({x9}, (0.000e+00, 1.000e+00)) # ({x10}, (1.000e+00, 0.000e+00)) # ({x11}, (0.000e+00, 1.000e+00)) # ({x12}, (1.000e+00, 0.000e+00)) # ({x13}, (1.000e+00, 0.000e+00)) # ({x14}, (0.000e+00, 1.000e+00)) # ({x15}, (0.000e+00, 1.000e+00)) GBP_LOOP6 7.948e-01 4.458e-01 -7.000e+00 1.000e-09 # ({x0}, (1.000e+00, 0.000e+00)) # ({x1}, (0.000e+00, 1.000e+00)) # ({x2}, (1.000e+00, 0.000e+00)) # ({x3}, (0.000e+00, 1.000e+00)) # ({x4}, (0.000e+00, 1.000e+00)) # ({x5}, (0.000e+00, 1.000e+00)) # ({x6}, (1.000e+00, 0.000e+00)) # ({x7}, (0.000e+00, 1.000e+00)) # ({x8}, (1.000e+00, 0.000e+00)) # ({x9}, (1.000e+00, 0.000e+00)) # ({x10}, (1.000e+00, 0.000e+00)) # ({x11}, (0.000e+00, 1.000e+00)) # ({x12}, (0.000e+00, 1.000e+00)) # ({x13}, (1.000e+00, 0.000e+00)) # ({x14}, (0.000e+00, 1.000e+00)) # ({x15}, (0.000e+00, 1.000e+00)) GBP_LOOP7 7.948e-01 4.458e-01 -7.000e+00 1.000e-09 # ({x0}, (1.000e+00, 0.000e+00)) # ({x1}, (0.000e+00, 1.000e+00)) # ({x2}, (1.000e+00, 0.000e+00)) # ({x3}, (0.000e+00, 1.000e+00)) # ({x4}, (0.000e+00, 1.000e+00)) # ({x5}, (0.000e+00, 1.000e+00)) # ({x6}, (1.000e+00, 0.000e+00)) # ({x7}, (0.000e+00, 1.000e+00)) # ({x8}, (1.000e+00, 0.000e+00)) # ({x9}, (1.000e+00, 0.000e+00)) # ({x10}, (1.000e+00, 0.000e+00)) # ({x11}, (0.000e+00, 1.000e+00)) # ({x12}, (0.000e+00, 1.000e+00)) # ({x13}, (1.000e+00, 0.000e+00)) # ({x14}, (0.000e+00, 1.000e+00)) # ({x15}, (0.000e+00, 1.000e+00)) HAK_MIN 9.483e-02 3.078e-02 +2.969e-01 1.000e-09 # ({x0}, (4.233e-01, 5.767e-01)) # ({x1}, (5.422e-01, 4.578e-01)) # ({x2}, (4.662e-01, 5.338e-01)) # ({x3}, (5.424e-01, 4.576e-01)) # ({x4}, (6.042e-01, 3.958e-01)) # ({x5}, (1.845e-01, 8.155e-01)) # ({x6}, (8.203e-01, 1.797e-01)) # ({x7}, (2.292e-01, 7.708e-01)) # ({x8}, (3.119e-01, 6.881e-01)) # ({x9}, (2.975e-01, 7.025e-01)) # ({x10}, (7.268e-01, 2.732e-01)) # ({x11}, (1.485e-01, 8.515e-01)) # ({x12}, (4.512e-01, 5.488e-01)) # ({x13}, (5.266e-01, 4.734e-01)) # ({x14}, (6.033e-01, 3.967e-01)) # ({x15}, (1.558e-01, 8.442e-01)) HAK_BETHE 9.483e-02 3.078e-02 +2.969e-01 1.000e-09 # ({x0}, (4.233e-01, 5.767e-01)) # ({x1}, (5.422e-01, 4.578e-01)) # ({x2}, (4.662e-01, 5.338e-01)) # ({x3}, (5.424e-01, 4.576e-01)) # ({x4}, (6.042e-01, 3.958e-01)) # ({x5}, (1.845e-01, 8.155e-01)) # ({x6}, (8.203e-01, 1.797e-01)) # ({x7}, (2.292e-01, 7.708e-01)) # ({x8}, (3.119e-01, 6.881e-01)) # ({x9}, (2.975e-01, 7.025e-01)) # ({x10}, (7.268e-01, 2.732e-01)) # ({x11}, (1.485e-01, 8.515e-01)) # ({x12}, (4.512e-01, 5.488e-01)) # ({x13}, (5.266e-01, 4.734e-01)) # ({x14}, (6.033e-01, 3.967e-01)) # ({x15}, (1.558e-01, 8.442e-01)) HAK_DELTA 3.684e-01 1.892e-01 +1.654e+01 1.000e-09 # ({x0}, (4.902e-01, 5.098e-01)) # ({x1}, (5.098e-01, 4.902e-01)) # ({x2}, (4.902e-01, 5.098e-01)) # ({x3}, (5.098e-01, 4.902e-01)) # ({x4}, (5.098e-01, 4.902e-01)) # ({x5}, (5.098e-01, 4.902e-01)) # ({x6}, (4.902e-01, 5.098e-01)) # ({x7}, (5.098e-01, 4.902e-01)) # ({x8}, (4.902e-01, 5.098e-01)) # ({x9}, (4.902e-01, 5.098e-01)) # ({x10}, (5.098e-01, 4.902e-01)) # ({x11}, (4.902e-01, 5.098e-01)) # ({x12}, (4.902e-01, 5.098e-01)) # ({x13}, (5.098e-01, 4.902e-01)) # ({x14}, (5.098e-01, 4.902e-01)) # ({x15}, (4.902e-01, 5.098e-01)) HAK_LOOP3 9.483e-02 3.078e-02 +2.969e-01 1.000e-09 # ({x0}, (4.233e-01, 5.767e-01)) # ({x1}, (5.422e-01, 4.578e-01)) # ({x2}, (4.662e-01, 5.338e-01)) # ({x3}, (5.424e-01, 4.576e-01)) # ({x4}, (6.042e-01, 3.958e-01)) # ({x5}, (1.845e-01, 8.155e-01)) # ({x6}, (8.203e-01, 1.797e-01)) # ({x7}, (2.292e-01, 7.708e-01)) # ({x8}, (3.119e-01, 6.881e-01)) # ({x9}, (2.975e-01, 7.025e-01)) # ({x10}, (7.268e-01, 2.732e-01)) # ({x11}, (1.485e-01, 8.515e-01)) # ({x12}, (4.512e-01, 5.488e-01)) # ({x13}, (5.266e-01, 4.734e-01)) # ({x14}, (6.033e-01, 3.967e-01)) # ({x15}, (1.558e-01, 8.442e-01)) HAK_LOOP4 4.970e-03 1.486e-03 -4.277e-03 1.000e-09 # ({x0}, (3.909e-01, 6.091e-01)) # ({x1}, (5.556e-01, 4.444e-01)) # ({x2}, (4.585e-01, 5.415e-01)) # ({x3}, (5.490e-01, 4.510e-01)) # ({x4}, (6.663e-01, 3.337e-01)) # ({x5}, (2.089e-01, 7.911e-01)) # ({x6}, (8.197e-01, 1.803e-01)) # ({x7}, (2.321e-01, 7.679e-01)) # ({x8}, (2.160e-01, 7.840e-01)) # ({x9}, (2.054e-01, 7.946e-01)) # ({x10}, (7.685e-01, 2.315e-01)) # ({x11}, (1.182e-01, 8.818e-01)) # ({x12}, (4.206e-01, 5.794e-01)) # ({x13}, (5.351e-01, 4.649e-01)) # ({x14}, (6.319e-01, 3.681e-01)) # ({x15}, (1.307e-01, 8.693e-01)) HAK_LOOP5 4.970e-03 1.486e-03 -4.277e-03 1.000e-09 # ({x0}, (3.909e-01, 6.091e-01)) # ({x1}, (5.556e-01, 4.444e-01)) # ({x2}, (4.585e-01, 5.415e-01)) # ({x3}, (5.490e-01, 4.510e-01)) # ({x4}, (6.663e-01, 3.337e-01)) # ({x5}, (2.089e-01, 7.911e-01)) # ({x6}, (8.197e-01, 1.803e-01)) # ({x7}, (2.321e-01, 7.679e-01)) # ({x8}, (2.160e-01, 7.840e-01)) # ({x9}, (2.054e-01, 7.946e-01)) # ({x10}, (7.685e-01, 2.315e-01)) # ({x11}, (1.182e-01, 8.818e-01)) # ({x12}, (4.206e-01, 5.794e-01)) # ({x13}, (5.351e-01, 4.649e-01)) # ({x14}, (6.319e-01, 3.681e-01)) # ({x15}, (1.307e-01, 8.693e-01)) MR_RESPPROP_FULL 1.676e-02 4.933e-03 N/A 1.000e-09 # ({x0}, (3.941e-01, 6.059e-01)) # ({x1}, (5.534e-01, 4.466e-01)) # ({x2}, (4.602e-01, 5.398e-01)) # ({x3}, (5.477e-01, 4.523e-01)) # ({x4}, (6.557e-01, 3.443e-01)) # ({x5}, (2.084e-01, 7.916e-01)) # ({x6}, (8.163e-01, 1.837e-01)) # ({x7}, (2.332e-01, 7.668e-01)) # ({x8}, (2.334e-01, 7.666e-01)) # ({x9}, (2.220e-01, 7.780e-01)) # ({x10}, (7.583e-01, 2.417e-01)) # ({x11}, (1.221e-01, 8.779e-01)) # ({x12}, (4.190e-01, 5.810e-01)) # ({x13}, (5.407e-01, 4.593e-01)) # ({x14}, (6.252e-01, 3.748e-01)) # ({x15}, (1.346e-01, 8.654e-01)) MR_CLAMPING_FULL 6.060e-03 1.754e-03 N/A 1.000e-09 # ({x0}, (3.872e-01, 6.128e-01)) # ({x1}, (5.585e-01, 4.415e-01)) # ({x2}, (4.575e-01, 5.425e-01)) # ({x3}, (5.486e-01, 4.514e-01)) # ({x4}, (6.672e-01, 3.328e-01)) # ({x5}, (2.118e-01, 7.882e-01)) # ({x6}, (8.174e-01, 1.826e-01)) # ({x7}, (2.329e-01, 7.671e-01)) # ({x8}, (2.189e-01, 7.811e-01)) # ({x9}, (2.075e-01, 7.925e-01)) # ({x10}, (7.651e-01, 2.349e-01)) # ({x11}, (1.201e-01, 8.799e-01)) # ({x12}, (4.174e-01, 5.826e-01)) # ({x13}, (5.409e-01, 4.591e-01)) # ({x14}, (6.292e-01, 3.708e-01)) # ({x15}, (1.338e-01, 8.662e-01)) MR_EXACT_FULL 3.527e-03 1.038e-03 N/A 1.000e-09 # ({x0}, (3.867e-01, 6.133e-01)) # ({x1}, (5.572e-01, 4.428e-01)) # ({x2}, (4.585e-01, 5.415e-01)) # ({x3}, (5.478e-01, 4.522e-01)) # ({x4}, (6.681e-01, 3.319e-01)) # ({x5}, (2.101e-01, 7.899e-01)) # ({x6}, (8.179e-01, 1.821e-01)) # ({x7}, (2.329e-01, 7.671e-01)) # ({x8}, (2.166e-01, 7.834e-01)) # ({x9}, (2.053e-01, 7.947e-01)) # ({x10}, (7.666e-01, 2.334e-01)) # ({x11}, (1.201e-01, 8.799e-01)) # ({x12}, (4.194e-01, 5.806e-01)) # ({x13}, (5.384e-01, 4.616e-01)) # ({x14}, (6.296e-01, 3.704e-01)) # ({x15}, (1.344e-01, 8.656e-01)) MR_RESPPROP_LINEAR 1.932e-02 5.506e-03 N/A 1.000e-09 # ({x0}, (3.923e-01, 6.077e-01)) # ({x1}, (5.529e-01, 4.471e-01)) # ({x2}, (4.608e-01, 5.392e-01)) # ({x3}, (5.467e-01, 4.533e-01)) # ({x4}, (6.546e-01, 3.454e-01)) # ({x5}, (2.071e-01, 7.929e-01)) # ({x6}, (8.175e-01, 1.825e-01)) # ({x7}, (2.325e-01, 7.675e-01)) # ({x8}, (2.364e-01, 7.636e-01)) # ({x9}, (2.228e-01, 7.772e-01)) # ({x10}, (7.577e-01, 2.423e-01)) # ({x11}, (1.240e-01, 8.760e-01)) # ({x12}, (4.258e-01, 5.742e-01)) # ({x13}, (5.388e-01, 4.612e-01)) # ({x14}, (6.239e-01, 3.761e-01)) # ({x15}, (1.369e-01, 8.631e-01)) MR_CLAMPING_LINEAR 5.992e-03 1.960e-03 N/A 1.000e-09 # ({x0}, (3.856e-01, 6.144e-01)) # ({x1}, (5.573e-01, 4.427e-01)) # ({x2}, (4.586e-01, 5.414e-01)) # ({x3}, (5.474e-01, 4.526e-01)) # ({x4}, (6.653e-01, 3.347e-01)) # ({x5}, (2.101e-01, 7.899e-01)) # ({x6}, (8.189e-01, 1.811e-01)) # ({x7}, (2.321e-01, 7.679e-01)) # ({x8}, (2.231e-01, 7.769e-01)) # ({x9}, (2.089e-01, 7.911e-01)) # ({x10}, (7.643e-01, 2.357e-01)) # ({x11}, (1.224e-01, 8.776e-01)) # ({x12}, (4.252e-01, 5.748e-01)) # ({x13}, (5.388e-01, 4.612e-01)) # ({x14}, (6.275e-01, 3.725e-01)) # ({x15}, (1.366e-01, 8.634e-01)) MR_EXACT_LINEAR 5.617e-03 1.742e-03 N/A 1.000e-09 # ({x0}, (3.853e-01, 6.147e-01)) # ({x1}, (5.560e-01, 4.440e-01)) # ({x2}, (4.596e-01, 5.404e-01)) # ({x3}, (5.466e-01, 4.534e-01)) # ({x4}, (6.661e-01, 3.339e-01)) # ({x5}, (2.083e-01, 7.917e-01)) # ({x6}, (8.194e-01, 1.806e-01)) # ({x7}, (2.320e-01, 7.680e-01)) # ({x8}, (2.210e-01, 7.790e-01)) # ({x9}, (2.069e-01, 7.931e-01)) # ({x10}, (7.657e-01, 2.343e-01)) # ({x11}, (1.225e-01, 8.775e-01)) # ({x12}, (4.270e-01, 5.730e-01)) # ({x13}, (5.362e-01, 4.638e-01)) # ({x14}, (6.279e-01, 3.721e-01)) # ({x15}, (1.372e-01, 8.628e-01)) LCBP_FULLCAV_SEQFIX 1.225e-03 5.589e-04 N/A 1.000e-09 # ({x0}, (3.888e-01, 6.112e-01)) # ({x1}, (5.559e-01, 4.441e-01)) # ({x2}, (4.583e-01, 5.417e-01)) # ({x3}, (5.482e-01, 4.518e-01)) # ({x4}, (6.657e-01, 3.343e-01)) # ({x5}, (2.113e-01, 7.887e-01)) # ({x6}, (8.172e-01, 1.828e-01)) # ({x7}, (2.329e-01, 7.671e-01)) # ({x8}, (2.182e-01, 7.818e-01)) # ({x9}, (2.062e-01, 7.938e-01)) # ({x10}, (7.652e-01, 2.348e-01)) # ({x11}, (1.214e-01, 8.786e-01)) # ({x12}, (4.205e-01, 5.795e-01)) # ({x13}, (5.358e-01, 4.642e-01)) # ({x14}, (6.285e-01, 3.715e-01)) # ({x15}, (1.359e-01, 8.641e-01)) LCBP_FULLCAVin_SEQFIX 1.225e-03 5.589e-04 N/A 1.000e-09 # ({x0}, (3.888e-01, 6.112e-01)) # ({x1}, (5.559e-01, 4.441e-01)) # ({x2}, (4.583e-01, 5.417e-01)) # ({x3}, (5.482e-01, 4.518e-01)) # ({x4}, (6.657e-01, 3.343e-01)) # ({x5}, (2.113e-01, 7.887e-01)) # ({x6}, (8.172e-01, 1.828e-01)) # ({x7}, (2.329e-01, 7.671e-01)) # ({x8}, (2.182e-01, 7.818e-01)) # ({x9}, (2.062e-01, 7.938e-01)) # ({x10}, (7.652e-01, 2.348e-01)) # ({x11}, (1.214e-01, 8.786e-01)) # ({x12}, (4.205e-01, 5.795e-01)) # ({x13}, (5.358e-01, 4.642e-01)) # ({x14}, (6.285e-01, 3.715e-01)) # ({x15}, (1.359e-01, 8.641e-01)) LCBP_FULLCAV_SEQRND 1.225e-03 5.589e-04 N/A 1.000e-09 # ({x0}, (3.888e-01, 6.112e-01)) # ({x1}, (5.559e-01, 4.441e-01)) # ({x2}, (4.583e-01, 5.417e-01)) # ({x3}, (5.482e-01, 4.518e-01)) # ({x4}, (6.657e-01, 3.343e-01)) # ({x5}, (2.113e-01, 7.887e-01)) # ({x6}, (8.172e-01, 1.828e-01)) # ({x7}, (2.329e-01, 7.671e-01)) # ({x8}, (2.182e-01, 7.818e-01)) # ({x9}, (2.062e-01, 7.938e-01)) # ({x10}, (7.652e-01, 2.348e-01)) # ({x11}, (1.214e-01, 8.786e-01)) # ({x12}, (4.205e-01, 5.795e-01)) # ({x13}, (5.358e-01, 4.642e-01)) # ({x14}, (6.285e-01, 3.715e-01)) # ({x15}, (1.359e-01, 8.641e-01)) LCBP_FULLCAVin_SEQRND 1.225e-03 5.589e-04 N/A 1.000e-09 # ({x0}, (3.888e-01, 6.112e-01)) # ({x1}, (5.559e-01, 4.441e-01)) # ({x2}, (4.583e-01, 5.417e-01)) # ({x3}, (5.482e-01, 4.518e-01)) # ({x4}, (6.657e-01, 3.343e-01)) # ({x5}, (2.113e-01, 7.887e-01)) # ({x6}, (8.172e-01, 1.828e-01)) # ({x7}, (2.329e-01, 7.671e-01)) # ({x8}, (2.182e-01, 7.818e-01)) # ({x9}, (2.062e-01, 7.938e-01)) # ({x10}, (7.652e-01, 2.348e-01)) # ({x11}, (1.214e-01, 8.786e-01)) # ({x12}, (4.205e-01, 5.795e-01)) # ({x13}, (5.358e-01, 4.642e-01)) # ({x14}, (6.285e-01, 3.715e-01)) # ({x15}, (1.359e-01, 8.641e-01)) LCBP_FULLCAV_NONE 1.318e-02 2.644e-03 N/A 1.000e+00 # ({x0}, (3.859e-01, 6.141e-01)) # ({x1}, (5.569e-01, 4.431e-01)) # ({x2}, (4.719e-01, 5.281e-01)) # ({x3}, (5.491e-01, 4.509e-01)) # ({x4}, (6.629e-01, 3.371e-01)) # ({x5}, (2.119e-01, 7.881e-01)) # ({x6}, (8.245e-01, 1.755e-01)) # ({x7}, (2.313e-01, 7.687e-01)) # ({x8}, (2.191e-01, 7.809e-01)) # ({x9}, (2.058e-01, 7.942e-01)) # ({x10}, (7.698e-01, 2.302e-01)) # ({x11}, (1.207e-01, 8.793e-01)) # ({x12}, (4.179e-01, 5.821e-01)) # ({x13}, (5.350e-01, 4.650e-01)) # ({x14}, (6.290e-01, 3.710e-01)) # ({x15}, (1.364e-01, 8.636e-01)) LCBP_FULLCAVin_NONE 1.318e-02 2.644e-03 N/A 1.000e+00 # ({x0}, (3.859e-01, 6.141e-01)) # ({x1}, (5.569e-01, 4.431e-01)) # ({x2}, (4.719e-01, 5.281e-01)) # ({x3}, (5.491e-01, 4.509e-01)) # ({x4}, (6.629e-01, 3.371e-01)) # ({x5}, (2.119e-01, 7.881e-01)) # ({x6}, (8.245e-01, 1.755e-01)) # ({x7}, (2.313e-01, 7.687e-01)) # ({x8}, (2.191e-01, 7.809e-01)) # ({x9}, (2.058e-01, 7.942e-01)) # ({x10}, (7.698e-01, 2.302e-01)) # ({x11}, (1.207e-01, 8.793e-01)) # ({x12}, (4.179e-01, 5.821e-01)) # ({x13}, (5.350e-01, 4.650e-01)) # ({x14}, (6.290e-01, 3.710e-01)) # ({x15}, (1.364e-01, 8.636e-01)) LCBP_PAIRCAV_SEQFIX 1.564e-02 5.284e-03 N/A 1.000e-09 # ({x0}, (3.872e-01, 6.128e-01)) # ({x1}, (5.540e-01, 4.460e-01)) # ({x2}, (4.596e-01, 5.404e-01)) # ({x3}, (5.460e-01, 4.540e-01)) # ({x4}, (6.601e-01, 3.399e-01)) # ({x5}, (2.050e-01, 7.950e-01)) # ({x6}, (8.200e-01, 1.800e-01)) # ({x7}, (2.314e-01, 7.686e-01)) # ({x8}, (2.327e-01, 7.673e-01)) # ({x9}, (2.095e-01, 7.905e-01)) # ({x10}, (7.621e-01, 2.379e-01)) # ({x11}, (1.283e-01, 8.717e-01)) # ({x12}, (4.367e-01, 5.633e-01)) # ({x13}, (5.282e-01, 4.718e-01)) # ({x14}, (6.240e-01, 3.760e-01)) # ({x15}, (1.409e-01, 8.591e-01)) LCBP_PAIRCAVin_SEQFIX 1.564e-02 5.284e-03 N/A 1.000e-09 # ({x0}, (3.872e-01, 6.128e-01)) # ({x1}, (5.540e-01, 4.460e-01)) # ({x2}, (4.596e-01, 5.404e-01)) # ({x3}, (5.460e-01, 4.540e-01)) # ({x4}, (6.601e-01, 3.399e-01)) # ({x5}, (2.050e-01, 7.950e-01)) # ({x6}, (8.200e-01, 1.800e-01)) # ({x7}, (2.314e-01, 7.686e-01)) # ({x8}, (2.327e-01, 7.673e-01)) # ({x9}, (2.095e-01, 7.905e-01)) # ({x10}, (7.621e-01, 2.379e-01)) # ({x11}, (1.283e-01, 8.717e-01)) # ({x12}, (4.367e-01, 5.633e-01)) # ({x13}, (5.282e-01, 4.718e-01)) # ({x14}, (6.240e-01, 3.760e-01)) # ({x15}, (1.409e-01, 8.591e-01)) LCBP_PAIRCAV_SEQRND 1.564e-02 5.284e-03 N/A 1.000e-09 # ({x0}, (3.872e-01, 6.128e-01)) # ({x1}, (5.540e-01, 4.460e-01)) # ({x2}, (4.596e-01, 5.404e-01)) # ({x3}, (5.460e-01, 4.540e-01)) # ({x4}, (6.601e-01, 3.399e-01)) # ({x5}, (2.050e-01, 7.950e-01)) # ({x6}, (8.200e-01, 1.800e-01)) # ({x7}, (2.314e-01, 7.686e-01)) # ({x8}, (2.327e-01, 7.673e-01)) # ({x9}, (2.095e-01, 7.905e-01)) # ({x10}, (7.621e-01, 2.379e-01)) # ({x11}, (1.283e-01, 8.717e-01)) # ({x12}, (4.367e-01, 5.633e-01)) # ({x13}, (5.282e-01, 4.718e-01)) # ({x14}, (6.240e-01, 3.760e-01)) # ({x15}, (1.409e-01, 8.591e-01)) LCBP_PAIRCAVin_SEQRND 1.564e-02 5.284e-03 N/A 1.000e-09 # ({x0}, (3.872e-01, 6.128e-01)) # ({x1}, (5.540e-01, 4.460e-01)) # ({x2}, (4.596e-01, 5.404e-01)) # ({x3}, (5.460e-01, 4.540e-01)) # ({x4}, (6.601e-01, 3.399e-01)) # ({x5}, (2.050e-01, 7.950e-01)) # ({x6}, (8.200e-01, 1.800e-01)) # ({x7}, (2.314e-01, 7.686e-01)) # ({x8}, (2.327e-01, 7.673e-01)) # ({x9}, (2.095e-01, 7.905e-01)) # ({x10}, (7.621e-01, 2.379e-01)) # ({x11}, (1.283e-01, 8.717e-01)) # ({x12}, (4.367e-01, 5.633e-01)) # ({x13}, (5.282e-01, 4.718e-01)) # ({x14}, (6.240e-01, 3.760e-01)) # ({x15}, (1.409e-01, 8.591e-01)) LCBP_PAIRCAV_NONE 1.869e-01 6.816e-02 N/A 1.000e+00 # ({x0}, (3.558e-01, 6.442e-01)) # ({x1}, (5.320e-01, 4.680e-01)) # ({x2}, (4.581e-01, 5.419e-01)) # ({x3}, (5.768e-01, 4.232e-01)) # ({x4}, (7.724e-01, 2.276e-01)) # ({x5}, (2.314e-01, 7.686e-01)) # ({x6}, (9.366e-01, 6.343e-02)) # ({x7}, (1.862e-01, 8.138e-01)) # ({x8}, (1.145e-01, 8.855e-01)) # ({x9}, (1.196e-01, 8.804e-01)) # ({x10}, (8.803e-01, 1.197e-01)) # ({x11}, (5.173e-02, 9.483e-01)) # ({x12}, (4.454e-01, 5.546e-01)) # ({x13}, (6.323e-01, 3.677e-01)) # ({x14}, (8.161e-01, 1.839e-01)) # ({x15}, (1.676e-01, 8.324e-01)) LCBP_PAIRCAVin_NONE 1.869e-01 6.816e-02 N/A 1.000e+00 # ({x0}, (3.558e-01, 6.442e-01)) # ({x1}, (5.320e-01, 4.680e-01)) # ({x2}, (4.581e-01, 5.419e-01)) # ({x3}, (5.768e-01, 4.232e-01)) # ({x4}, (7.724e-01, 2.276e-01)) # ({x5}, (2.314e-01, 7.686e-01)) # ({x6}, (9.366e-01, 6.343e-02)) # ({x7}, (1.862e-01, 8.138e-01)) # ({x8}, (1.145e-01, 8.855e-01)) # ({x9}, (1.196e-01, 8.804e-01)) # ({x10}, (8.803e-01, 1.197e-01)) # ({x11}, (5.173e-02, 9.483e-01)) # ({x12}, (4.454e-01, 5.546e-01)) # ({x13}, (6.323e-01, 3.677e-01)) # ({x14}, (8.161e-01, 1.839e-01)) # ({x15}, (1.676e-01, 8.324e-01)) LCBP_PAIR2CAV_SEQFIX 1.535e-02 4.445e-03 N/A 1.000e-09 # ({x0}, (3.844e-01, 6.156e-01)) # ({x1}, (5.557e-01, 4.443e-01)) # ({x2}, (4.588e-01, 5.412e-01)) # ({x3}, (5.461e-01, 4.539e-01)) # ({x4}, (6.648e-01, 3.352e-01)) # ({x5}, (2.057e-01, 7.943e-01)) # ({x6}, (8.205e-01, 1.795e-01)) # ({x7}, (2.312e-01, 7.688e-01)) # ({x8}, (2.282e-01, 7.718e-01)) # ({x9}, (2.029e-01, 7.971e-01)) # ({x10}, (7.643e-01, 2.357e-01)) # ({x11}, (1.286e-01, 8.714e-01)) # ({x12}, (4.368e-01, 5.632e-01)) # ({x13}, (5.280e-01, 4.720e-01)) # ({x14}, (6.250e-01, 3.750e-01)) # ({x15}, (1.411e-01, 8.589e-01)) LCBP_PAIR2CAVin_SEQFIX 1.535e-02 4.445e-03 N/A 1.000e-09 # ({x0}, (3.844e-01, 6.156e-01)) # ({x1}, (5.557e-01, 4.443e-01)) # ({x2}, (4.588e-01, 5.412e-01)) # ({x3}, (5.461e-01, 4.539e-01)) # ({x4}, (6.648e-01, 3.352e-01)) # ({x5}, (2.057e-01, 7.943e-01)) # ({x6}, (8.205e-01, 1.795e-01)) # ({x7}, (2.312e-01, 7.688e-01)) # ({x8}, (2.282e-01, 7.718e-01)) # ({x9}, (2.029e-01, 7.971e-01)) # ({x10}, (7.643e-01, 2.357e-01)) # ({x11}, (1.286e-01, 8.714e-01)) # ({x12}, (4.368e-01, 5.632e-01)) # ({x13}, (5.280e-01, 4.720e-01)) # ({x14}, (6.250e-01, 3.750e-01)) # ({x15}, (1.411e-01, 8.589e-01)) LCBP_PAIR2CAV_SEQRND 1.535e-02 4.445e-03 N/A 1.000e-09 # ({x0}, (3.844e-01, 6.156e-01)) # ({x1}, (5.557e-01, 4.443e-01)) # ({x2}, (4.588e-01, 5.412e-01)) # ({x3}, (5.461e-01, 4.539e-01)) # ({x4}, (6.648e-01, 3.352e-01)) # ({x5}, (2.057e-01, 7.943e-01)) # ({x6}, (8.205e-01, 1.795e-01)) # ({x7}, (2.312e-01, 7.688e-01)) # ({x8}, (2.282e-01, 7.718e-01)) # ({x9}, (2.029e-01, 7.971e-01)) # ({x10}, (7.643e-01, 2.357e-01)) # ({x11}, (1.286e-01, 8.714e-01)) # ({x12}, (4.368e-01, 5.632e-01)) # ({x13}, (5.280e-01, 4.720e-01)) # ({x14}, (6.250e-01, 3.750e-01)) # ({x15}, (1.411e-01, 8.589e-01)) LCBP_PAIR2CAVin_SEQRND 1.535e-02 4.445e-03 N/A 1.000e-09 # ({x0}, (3.844e-01, 6.156e-01)) # ({x1}, (5.557e-01, 4.443e-01)) # ({x2}, (4.588e-01, 5.412e-01)) # ({x3}, (5.461e-01, 4.539e-01)) # ({x4}, (6.648e-01, 3.352e-01)) # ({x5}, (2.057e-01, 7.943e-01)) # ({x6}, (8.205e-01, 1.795e-01)) # ({x7}, (2.312e-01, 7.688e-01)) # ({x8}, (2.282e-01, 7.718e-01)) # ({x9}, (2.029e-01, 7.971e-01)) # ({x10}, (7.643e-01, 2.357e-01)) # ({x11}, (1.286e-01, 8.714e-01)) # ({x12}, (4.368e-01, 5.632e-01)) # ({x13}, (5.280e-01, 4.720e-01)) # ({x14}, (6.250e-01, 3.750e-01)) # ({x15}, (1.411e-01, 8.589e-01)) LCBP_PAIR2CAV_NONE 1.894e-01 7.196e-02 N/A 1.000e+00 # ({x0}, (3.525e-01, 6.475e-01)) # ({x1}, (5.395e-01, 4.605e-01)) # ({x2}, (4.567e-01, 5.433e-01)) # ({x3}, (5.786e-01, 4.214e-01)) # ({x4}, (7.797e-01, 2.203e-01)) # ({x5}, (2.350e-01, 7.650e-01)) # ({x6}, (9.358e-01, 6.415e-02)) # ({x7}, (1.860e-01, 8.140e-01)) # ({x8}, (1.133e-01, 8.867e-01)) # ({x9}, (1.167e-01, 8.833e-01)) # ({x10}, (8.886e-01, 1.114e-01)) # ({x11}, (4.668e-02, 9.533e-01)) # ({x12}, (4.484e-01, 5.516e-01)) # ({x13}, (6.444e-01, 3.556e-01)) # ({x14}, (8.185e-01, 1.815e-01)) # ({x15}, (1.841e-01, 8.159e-01)) LCBP_PAIR2CAVin_NONE 1.894e-01 7.196e-02 N/A 1.000e+00 # ({x0}, (3.525e-01, 6.475e-01)) # ({x1}, (5.395e-01, 4.605e-01)) # ({x2}, (4.567e-01, 5.433e-01)) # ({x3}, (5.786e-01, 4.214e-01)) # ({x4}, (7.797e-01, 2.203e-01)) # ({x5}, (2.350e-01, 7.650e-01)) # ({x6}, (9.358e-01, 6.415e-02)) # ({x7}, (1.860e-01, 8.140e-01)) # ({x8}, (1.133e-01, 8.867e-01)) # ({x9}, (1.167e-01, 8.833e-01)) # ({x10}, (8.886e-01, 1.114e-01)) # ({x11}, (4.668e-02, 9.533e-01)) # ({x12}, (4.484e-01, 5.516e-01)) # ({x13}, (6.444e-01, 3.556e-01)) # ({x14}, (8.185e-01, 1.815e-01)) # ({x15}, (1.841e-01, 8.159e-01)) LCBP_UNICAV_SEQFIX 9.483e-02 3.078e-02 N/A 1.000e-09 # ({x0}, (4.233e-01, 5.767e-01)) # ({x1}, (5.422e-01, 4.578e-01)) # ({x2}, (4.662e-01, 5.338e-01)) # ({x3}, (5.424e-01, 4.576e-01)) # ({x4}, (6.042e-01, 3.958e-01)) # ({x5}, (1.845e-01, 8.155e-01)) # ({x6}, (8.203e-01, 1.797e-01)) # ({x7}, (2.292e-01, 7.708e-01)) # ({x8}, (3.119e-01, 6.881e-01)) # ({x9}, (2.975e-01, 7.025e-01)) # ({x10}, (7.268e-01, 2.732e-01)) # ({x11}, (1.485e-01, 8.515e-01)) # ({x12}, (4.512e-01, 5.488e-01)) # ({x13}, (5.266e-01, 4.734e-01)) # ({x14}, (6.033e-01, 3.967e-01)) # ({x15}, (1.558e-01, 8.442e-01)) LCBP_UNICAV_SEQRND 9.483e-02 3.078e-02 N/A 1.000e-09 # ({x0}, (4.233e-01, 5.767e-01)) # ({x1}, (5.422e-01, 4.578e-01)) # ({x2}, (4.662e-01, 5.338e-01)) # ({x3}, (5.424e-01, 4.576e-01)) # ({x4}, (6.042e-01, 3.958e-01)) # ({x5}, (1.845e-01, 8.155e-01)) # ({x6}, (8.203e-01, 1.797e-01)) # ({x7}, (2.292e-01, 7.708e-01)) # ({x8}, (3.119e-01, 6.881e-01)) # ({x9}, (2.975e-01, 7.025e-01)) # ({x10}, (7.268e-01, 2.732e-01)) # ({x11}, (1.485e-01, 8.515e-01)) # ({x12}, (4.512e-01, 5.488e-01)) # ({x13}, (5.266e-01, 4.734e-01)) # ({x14}, (6.033e-01, 3.967e-01)) # ({x15}, (1.558e-01, 8.442e-01)) BBP 7.049e-04 2.319e-04 +1.209e-03 1.000e-09 # ({x0}, (3.890e-01, 6.110e-01)) # ({x1}, (5.555e-01, 4.445e-01)) # ({x2}, (4.587e-01, 5.413e-01)) # ({x3}, (5.479e-01, 4.521e-01)) # ({x4}, (6.663e-01, 3.337e-01)) # ({x5}, (2.105e-01, 7.895e-01)) # ({x6}, (8.180e-01, 1.820e-01)) # ({x7}, (2.324e-01, 7.676e-01)) # ({x8}, (2.169e-01, 7.831e-01)) # ({x9}, (2.050e-01, 7.950e-01)) # ({x10}, (7.666e-01, 2.334e-01)) # ({x11}, (1.216e-01, 8.784e-01)) # ({x12}, (4.210e-01, 5.790e-01)) # ({x13}, (5.351e-01, 4.649e-01)) # ({x14}, (6.284e-01, 3.716e-01)) # ({x15}, (1.355e-01, 8.645e-01)) CBP 3.294e-06 8.863e-07 +3.531e-06 1.000e-09 # ({x0}, (3.888e-01, 6.112e-01)) # ({x1}, (5.556e-01, 4.444e-01)) # ({x2}, (4.587e-01, 5.413e-01)) # ({x3}, (5.480e-01, 4.520e-01)) # ({x4}, (6.660e-01, 3.340e-01)) # ({x5}, (2.107e-01, 7.893e-01)) # ({x6}, (8.178e-01, 1.822e-01)) # ({x7}, (2.327e-01, 7.673e-01)) # ({x8}, (2.171e-01, 7.829e-01)) # ({x9}, (2.052e-01, 7.948e-01)) # ({x10}, (7.665e-01, 2.335e-01)) # ({x11}, (1.217e-01, 8.783e-01)) # ({x12}, (4.214e-01, 5.786e-01)) # ({x13}, (5.348e-01, 4.652e-01)) # ({x14}, (6.291e-01, 3.709e-01)) # ({x15}, (1.357e-01, 8.643e-01)) libDAI-0.2.4/tests/zeroes1.fg0000644000263000017630000000025111334764774014543 0ustar jorismkyb# Factor graph that contains many zeroes (useful for testing purposes) 3 1 0 2 2 0 0 1 1 2 0 1 2 2 4 0 1 1 2 2 2 3 1 2 1 2 2 2 4 0 1 1 2 2 2 3 1 libDAI-0.2.4/tests/alarm.fg0000644000263000017630000004107411334764774014257 0ustar jorismkyb# ALARM network # from http://compbio.cs.huji.ac.il/Repository/Datasets/alarm/alarm.dsc 37 2 0 5 2 2 4 0 0.9 1 0.1 2 0.01 3 0.99 2 1 4 3 3 9 0 0.95 1 0.04 2 0.01 3 0.04 4 0.95 5 0.01 6 0.01 7 0.29 8 0.7 2 2 4 3 3 9 0 0.95 1 0.04 2 0.01 3 0.04 4 0.95 5 0.01 6 0.01 7 0.04 8 0.95 1 3 2 2 0 0.2 1 0.8 3 3 4 5 2 3 2 12 0 0.95 1 0.01 2 0.04 3 0.09 4 0.01 5 0.9 6 0.98 7 0.05 8 0.01 9 0.9 10 0.01 11 0.05 1 5 2 2 0 0.05 1 0.95 3 3 5 6 2 2 3 12 0 0.98 1 0.5 2 0.95 3 0.05 4 0.01 5 0.49 6 0.04 7 0.9 8 0.01 9 0.01 10 0.01 11 0.05 1 7 2 2 0 0.05 1 0.95 3 7 8 34 2 3 3 18 0 0.98 1 0.98 2 0.01 3 0.01 4 0.01 5 0.01 6 0.4 7 0.01 8 0.59 9 0.98 10 0.01 11 0.01 12 0.3 13 0.01 14 0.4 15 0.01 16 0.3 17 0.98 3 9 10 34 3 2 3 18 0 0.333 1 0.333 2 0.333 3 0.98 4 0.01 5 0.01 6 0.333 7 0.333 8 0.333 9 0.01 10 0.98 11 0.01 12 0.333 13 0.333 14 0.333 15 0.01 16 0.01 17 0.98 1 10 2 2 0 0.1 1 0.9 3 10 11 34 2 3 3 18 0 0.333 1 0.98 2 0.333 3 0.01 4 0.333 5 0.01 6 0.333 7 0.01 8 0.333 9 0.98 10 0.333 11 0.01 12 0.333 13 0.01 14 0.333 15 0.01 16 0.333 17 0.98 1 12 2 2 0 0.1 1 0.9 1 13 2 2 0 0.01 1 0.99 2 13 14 2 3 6 0 0.98 1 0.3 2 0.01 3 0.4 4 0.01 5 0.3 3 15 30 32 4 4 3 48 0 0.97 1 0.01 2 0.01 3 0.01 4 0.01 5 0.97 6 0.01 7 0.01 8 0.01 9 0.01 10 0.97 11 0.01 12 0.01 13 0.01 14 0.01 15 0.97 16 0.01 17 0.97 18 0.01 19 0.01 20 0.97 21 0.01 22 0.01 23 0.01 24 0.01 25 0.01 26 0.97 27 0.01 28 0.01 29 0.01 30 0.01 31 0.97 32 0.01 33 0.97 34 0.01 35 0.01 36 0.01 37 0.01 38 0.97 39 0.01 40 0.97 41 0.01 42 0.01 43 0.01 44 0.01 45 0.01 46 0.01 47 0.97 1 16 2 2 0 0.04 1 0.96 3 17 24 30 4 3 4 48 0 0.97 1 0.01 2 0.01 3 0.01 4 0.97 5 0.01 6 0.01 7 0.01 8 0.97 9 0.01 10 0.01 11 0.01 12 0.01 13 0.97 14 0.01 15 0.01 16 0.6 17 0.38 18 0.01 19 0.01 20 0.01 21 0.97 22 0.01 23 0.01 24 0.01 25 0.01 26 0.97 27 0.01 28 0.5 29 0.48 30 0.01 31 0.01 32 0.01 33 0.01 34 0.97 35 0.01 36 0.01 37 0.01 38 0.01 39 0.97 40 0.5 41 0.48 42 0.01 43 0.01 44 0.01 45 0.01 46 0.01 47 0.97 1 18 2 2 0 0.05 1 0.95 3 18 19 31 2 3 4 19 0 1 1 1 6 0.99 7 0.95 8 0.01 9 0.04 11 0.01 12 0.95 13 0.01 14 0.04 15 0.95 16 0.01 17 0.04 18 0.95 19 0.01 20 0.04 21 0.01 22 0.01 23 0.98 3 19 20 23 3 3 2 18 0 0.98 1 0.01 2 0.98 3 0.01 4 0.01 5 0.01 6 0.01 7 0.98 8 0.01 9 0.01 10 0.98 11 0.69 12 0.98 13 0.01 14 0.3 15 0.01 16 0.01 17 0.01 2 21 22 3 2 6 0 0.01 1 0.19 2 0.8 3 0.05 4 0.9 5 0.05 1 22 2 2 0 0.01 1 0.99 3 22 23 24 2 2 3 12 0 0.1 1 0.95 2 0.9 3 0.05 4 0.1 5 0.95 6 0.9 7 0.05 8 0.01 9 0.05 10 0.99 11 0.95 1 24 3 3 0 0.92 1 0.03 2 0.05 4 16 24 25 29 2 3 4 4 96 0 0.97 1 0.97 2 0.97 3 0.97 4 0.97 5 0.97 6 0.01 7 0.01 8 0.01 9 0.01 10 0.01 11 0.01 12 0.01 13 0.01 14 0.01 15 0.01 16 0.01 17 0.01 18 0.01 19 0.01 20 0.01 21 0.01 22 0.01 23 0.01 24 0.01 25 0.01 26 0.1 27 0.4 28 0.01 29 0.01 30 0.3 31 0.97 32 0.84 33 0.58 34 0.29 35 0.9 36 0.49 37 0.01 38 0.05 39 0.01 40 0.3 41 0.08 42 0.2 43 0.01 44 0.01 45 0.01 46 0.4 47 0.01 48 0.01 49 0.01 50 0.05 51 0.2 52 0.01 53 0.01 54 0.01 55 0.01 56 0.25 57 0.75 58 0.01 59 0.01 60 0.08 61 0.97 62 0.25 63 0.04 64 0.08 65 0.38 66 0.9 67 0.01 68 0.45 69 0.01 70 0.9 71 0.6 72 0.01 73 0.01 74 0.01 75 0.2 76 0.01 77 0.01 78 0.01 79 0.01 80 0.15 81 0.7 82 0.01 83 0.01 84 0.01 85 0.01 86 0.25 87 0.09 88 0.01 89 0.01 90 0.97 91 0.97 92 0.59 93 0.01 94 0.97 95 0.97 1 26 2 2 0 0.1 1 0.9 1 27 3 3 0 0.05 1 0.9 2 0.05 2 27 28 3 4 12 0 0.05 1 0.05 2 0.05 3 0.93 4 0.01 5 0.01 6 0.01 7 0.93 8 0.01 9 0.01 10 0.01 11 0.93 3 26 28 29 2 4 4 32 0 0.97 1 0.97 2 0.97 3 0.01 4 0.97 5 0.01 6 0.97 7 0.01 8 0.01 9 0.01 10 0.01 11 0.97 12 0.01 13 0.01 14 0.01 15 0.01 16 0.01 17 0.01 18 0.01 19 0.01 20 0.01 21 0.97 22 0.01 23 0.01 24 0.01 25 0.01 26 0.01 27 0.01 28 0.01 29 0.01 30 0.01 31 0.97 4 16 24 29 30 2 3 4 4 96 0 0.97 1 0.97 2 0.97 3 0.97 4 0.97 5 0.97 6 0.95 7 0.01 8 0.97 9 0.97 10 0.95 11 0.01 12 0.4 13 0.01 14 0.97 15 0.97 16 0.5 17 0.01 18 0.3 19 0.01 20 0.97 21 0.97 22 0.3 23 0.01 24 0.01 25 0.01 26 0.01 27 0.01 28 0.01 29 0.01 30 0.03 31 0.97 32 0.01 33 0.01 34 0.03 35 0.97 36 0.58 37 0.01 38 0.01 39 0.01 40 0.48 41 0.01 42 0.68 43 0.01 44 0.01 45 0.01 46 0.68 47 0.01 48 0.01 49 0.01 50 0.01 51 0.01 52 0.01 53 0.01 54 0.01 55 0.01 56 0.01 57 0.01 58 0.01 59 0.01 60 0.01 61 0.97 62 0.01 63 0.01 64 0.01 65 0.97 66 0.01 67 0.01 68 0.01 69 0.01 70 0.01 71 0.01 72 0.01 73 0.01 74 0.01 75 0.01 76 0.01 77 0.01 78 0.01 79 0.01 80 0.01 81 0.01 82 0.01 83 0.01 84 0.01 85 0.01 86 0.01 87 0.01 88 0.01 89 0.01 90 0.01 91 0.97 92 0.01 93 0.01 94 0.01 95 0.97 3 24 30 31 3 4 4 48 0 0.97 1 0.97 2 0.97 3 0.01 4 0.01 5 0.03 6 0.01 7 0.01 8 0.01 9 0.01 10 0.01 11 0.01 12 0.01 13 0.01 14 0.01 15 0.97 16 0.97 17 0.95 18 0.01 19 0.01 20 0.94 21 0.01 22 0.01 23 0.88 24 0.01 25 0.01 26 0.01 27 0.01 28 0.01 29 0.01 30 0.97 31 0.97 32 0.04 33 0.01 34 0.01 35 0.1 36 0.01 37 0.01 38 0.01 39 0.01 40 0.01 41 0.01 42 0.01 43 0.01 44 0.01 45 0.97 46 0.97 47 0.01 2 31 32 4 3 12 0 0.01 1 0.01 2 0.04 3 0.9 4 0.01 5 0.01 6 0.92 7 0.09 8 0.98 9 0.98 10 0.04 11 0.01 5 12 14 20 32 33 2 3 3 3 2 108 0 0.01 1 0.05 2 0.01 3 0.7 4 0.01 5 0.95 6 0.01 7 0.05 8 0.01 9 0.7 10 0.05 11 0.95 12 0.01 13 0.05 14 0.05 15 0.7 16 0.05 17 0.95 18 0.01 19 0.05 20 0.01 21 0.7 22 0.01 23 0.99 24 0.01 25 0.05 26 0.01 27 0.7 28 0.05 29 0.99 30 0.01 31 0.05 32 0.05 33 0.7 34 0.05 35 0.99 36 0.01 37 0.01 38 0.01 39 0.1 40 0.01 41 0.3 42 0.01 43 0.01 44 0.01 45 0.1 46 0.01 47 0.3 48 0.01 49 0.01 50 0.01 51 0.1 52 0.01 53 0.3 54 0.99 55 0.95 56 0.99 57 0.3 58 0.99 59 0.05 60 0.99 61 0.95 62 0.99 63 0.3 64 0.95 65 0.05 66 0.99 67 0.95 68 0.95 69 0.3 70 0.95 71 0.05 72 0.99 73 0.95 74 0.99 75 0.3 76 0.99 77 0.01 78 0.99 79 0.95 80 0.99 81 0.3 82 0.95 83 0.01 84 0.99 85 0.95 86 0.95 87 0.3 88 0.95 89 0.01 90 0.99 91 0.99 92 0.99 93 0.9 94 0.99 95 0.7 96 0.99 97 0.99 98 0.99 99 0.9 100 0.99 101 0.7 102 0.99 103 0.99 104 0.99 105 0.9 106 0.99 107 0.7 2 33 34 2 3 6 0 0.05 1 0.01 2 0.9 3 0.09 4 0.05 5 0.9 3 6 34 35 3 3 3 27 0 0.98 1 0.95 2 0.3 3 0.95 4 0.04 5 0.01 6 0.8 7 0.01 8 0.01 9 0.01 10 0.04 11 0.69 12 0.04 13 0.95 14 0.3 15 0.19 16 0.04 17 0.01 18 0.01 19 0.01 20 0.01 21 0.01 22 0.01 23 0.69 24 0.01 25 0.95 26 0.98 3 14 35 36 3 3 3 27 0 0.98 1 0.98 2 0.3 3 0.98 4 0.1 5 0.05 6 0.9 7 0.05 8 0.01 9 0.01 10 0.01 11 0.6 12 0.01 13 0.85 14 0.4 15 0.09 16 0.2 17 0.09 18 0.01 19 0.01 20 0.1 21 0.01 22 0.05 23 0.55 24 0.01 25 0.75 26 0.9 libDAI-0.2.4/tests/hoi3.fg0000644000263000017630000000123611334764774014021 0ustar jorismkyb# Factor graph made by ../utils/createfg # type = hoi # N = 10 # M = 3 # k = 3 # beta = 1 # seed = 1234567 3 3 0 2 7 2 2 2 8 0 1.4681858088541 1 0.62677975912889 2 0.93772291212951 3 0.55789818196925 4 2.2169178835152 5 1.1158597402573 6 4.3668946864226 7 0.5386131975631 3 2 5 9 2 2 2 8 0 0.42394324261549 1 1.8698790799175 2 0.751673014734 3 3.3944709353 4 3.0697466018763 5 1.3518859952286 6 0.85108939407003 7 0.44249854609337 3 1 4 6 2 2 2 8 0 1.7323418161587 1 1.1774643424739 2 1.8134284856927 3 0.46535724537261 4 2.9520075062676 5 0.87717718658893 6 0.30844599722711 7 0.9045019040901 libDAI-0.2.4/.gitignore0000644000263000017630000000003111334764774013457 0ustar jorismkyb.gitignore Makefile.conf libDAI-0.2.4/utils/0000755000263000017630000000000011334764774012635 5ustar jorismkyblibDAI-0.2.4/utils/fg2dot.cpp0000644000263000017630000000345111334764774014531 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include #include using namespace dai; using namespace std; int main( int argc, char *argv[] ) { if( argc != 3 ) { // Display help message if number of command line arguments is incorrect cout << "This program is part of libDAI - http://www.libdai.org/" << endl << endl; cout << "Usage: ./fg2dot " << endl << endl; cout << "Converts a libDAI factor graph file to a GraphViz .dot file for visualization." << endl; cout << "The .dot file can be converted to .ps (PostScript) by" << endl; cout << "'neato -T ps out.dot > out.ps' or by 'dot -T ps out.dot > out.ps'" << endl << endl; return 1; } else { // Read factorgraph FactorGraph fg; char *infile = argv[1]; fg.ReadFromFile( infile ); // Open output file for writing (except if filename equals "-") ostream *os = &cout; ofstream outfile; if( string( argv[2] ) != "-" ) { outfile.open( argv[2] ); if( !outfile.is_open() ) { cerr << "Cannot open " << argv[2] << " for writing" << endl; return 1; } os = &outfile; } // else, write to cout // Write the .dot file fg.printDot( *os ); return 0; } } libDAI-0.2.4/utils/createfg.cpp0000644000263000017630000006272011334764774015130 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include #include #include #include #include #include #include #include #include using namespace std; using namespace dai; namespace po = boost::program_options; /// Possible factor types DAI_ENUM(FactorType,ISING,EXPGAUSS,POTTS); /// Creates a factor graph from a pairwise interactions graph /** \param G Graph describing interactions between variables * \param ft Type of factors to use for interactions * \param states Number of states of the variables * \param props Additional properties for generating the interactions */ FactorGraph createFG( const GraphAL &G, FactorType ft, size_t states, const PropertySet &props ) { size_t N = G.nrNodes(); if( states > 2 ) DAI_ASSERT( ft != FactorType::ISING ); // Get inverse temperature Real beta = 1.0; if( ft != FactorType::ISING ) beta = props.GetAs("beta"); // Get properties for Ising factors Real mean_h = 0.0; Real sigma_h = 0.0; Real mean_J = 0.0; Real sigma_J = 0.0; if( ft == FactorType::ISING ) { mean_h = props.GetAs("mean_th"); sigma_h = props.GetAs("sigma_th"); mean_J = props.GetAs("mean_w"); sigma_J = props.GetAs("sigma_w"); } // Create variables vector vars; vars.reserve( N ); for( size_t i = 0; i < N; i++ ) vars.push_back( Var( i, states ) ); // Create factors vector factors; factors.reserve( G.nrEdges() + N ); // Pairwise factors for( size_t i = 0; i < N; i++ ) foreach( const GraphAL::Neighbor &j, G.nb(i) ) if( i < j ) { if( ft == FactorType::POTTS ) factors.push_back( createFactorPotts( vars[i], vars[j], beta ) ); else if( ft == FactorType::EXPGAUSS ) factors.push_back( createFactorExpGauss( VarSet( vars[i], vars[j] ), beta ) ); else if( ft == FactorType::ISING ) { Real J = rnd_stdnormal() * sigma_J + mean_J; factors.push_back( createFactorIsing( vars[i], vars[j], J ) ); } } // Unary factors if( ft == FactorType::ISING ) for( size_t i = 0; i < N; i++ ) { Real h = rnd_stdnormal() * sigma_h + mean_h; factors.push_back( createFactorIsing( vars[i], h ) ); } return FactorGraph( factors.begin(), factors.end(), vars.begin(), vars.end(), factors.size(), vars.size() ); } /// Return a random factor graph with higher-order interactions /** \param N number of variables * \param M number of factors * \param k number of variables that each factor depends on * \param beta standard-deviation of Gaussian log-factor entries */ FactorGraph createHOIFG( size_t N, size_t M, size_t k, Real beta ) { vector vars; vector factors; vars.reserve(N); for( size_t i = 0; i < N; i++ ) vars.push_back(Var(i,2)); for( size_t I = 0; I < M; I++ ) { VarSet vars; while( vars.size() < k ) { do { size_t newind = (size_t)(N * rnd_uniform()); Var newvar = Var(newind, 2); if( !vars.contains( newvar ) ) { vars |= newvar; break; } } while( 1 ); } factors.push_back( createFactorExpGauss( vars, beta ) ); } return FactorGraph( factors.begin(), factors.end(), vars.begin(), vars.end(), factors.size(), vars.size() ); } /// Creates a regular random bipartite graph /** \param N1 = number of nodes of type 1 * \param d1 = size of neighborhoods of nodes of type 1 * \param N2 = number of nodes of type 2 * \param d2 = size of neighborhoods of nodes of type 2 * \note asserts that N1 * d1 == N2 * d2 */ BipartiteGraph createRandomBipartiteGraph( size_t N1, size_t N2, size_t d1, size_t d2 ) { BipartiteGraph G; DAI_ASSERT( N1 * d1 == N2 * d2 ); // build lists of degree-repeated vertex numbers std::vector stubs1( N1*d1, 0 ); for( size_t n1 = 0; n1 < N1; n1++ ) for( size_t t = 0; t < d1; t++ ) stubs1[n1*d1 + t] = n1; // build lists of degree-repeated vertex numbers std::vector stubs2( N2*d2, 0 ); for( size_t n2 = 0; n2 < N2; n2++ ) for( size_t t = 0; t < d2; t++ ) stubs2[n2*d2 + t] = n2; // shuffle lists random_shuffle( stubs1.begin(), stubs1.end() ); random_shuffle( stubs2.begin(), stubs2.end() ); // add edges vector edges; edges.reserve( N1*d1 ); for( size_t e = 0; e < N1*d1; e++ ) edges.push_back( BipartiteGraph::Edge(stubs1[e], stubs2[e]) ); // finish construction G.construct( N1, N2, edges.begin(), edges.end() ); return G; } /// Returns x**n % p, assuming p is prime int powmod (int x, int n, int p) { int y = 1; for( int m = 0; m < n; m++ ) y = (x * y) % p; return y; } /// Returns order of x in GF(p) with p prime size_t order (int x, int p) { x = x % p; DAI_ASSERT( x != 0 ); size_t n = 0; size_t prod = 1; do { prod = (prod * x) % p; n++; } while( prod != 1 ); return n; } /// Returns whether n is a prime number bool isPrime (size_t n) { bool result = true; for( size_t k = 2; (k < n) && result; k++ ) if( n % k == 0 ) result = false; return result; } /// Constructs a regular LDPC graph with N=6, j=2, K=4, k=3 BipartiteGraph createSmallLDPCGraph() { BipartiteGraph G; size_t N=4, j=3, K=4; // k=3; typedef BipartiteGraph::Edge Edge; vector edges; edges.reserve( N*j ); edges.push_back( Edge(0,0) ); edges.push_back( Edge(1,0) ); edges.push_back( Edge(2,0) ); edges.push_back( Edge(0,1) ); edges.push_back( Edge(1,1) ); edges.push_back( Edge(3,1) ); edges.push_back( Edge(0,2) ); edges.push_back( Edge(2,2) ); edges.push_back( Edge(3,2) ); edges.push_back( Edge(1,3) ); edges.push_back( Edge(2,3) ); edges.push_back( Edge(3,3) ); // finish construction G.construct( N, K, edges.begin(), edges.end() ); return G; } /// Creates group-structured LDPC code /** Use construction described in "A Class of Group-Structured LDPC Codes" * by R. M. Tanner, D. Sridhara and T. Fuja * Proceedings of ICSTA, 2001 * * Example parameters: (p,j,k) = (31,3,5) * (p,j,k) = (37,3,4) * (p,j,k) = (7,2,4) * (p,j,k) = (29,2,4) * * j and k must be divisors of p-1 */ BipartiteGraph createGroupStructuredLDPCGraph( size_t p, size_t j, size_t k ) { BipartiteGraph G; size_t n = j; size_t N = p * k; size_t K = p * j; size_t a, b; for( a = 2; a < p; a++ ) if( order(a,p) == k ) break; DAI_ASSERT( a != p ); for( b = 2; b < p; b++ ) if( order(b,p) == j ) break; DAI_ASSERT( b != p ); // cout << "# order(a=" << a << ") = " << order(a,p) << endl; // cout << "# order(b=" << b << ") = " << order(b,p) << endl; DAI_ASSERT( N * n == K * k ); typedef BipartiteGraph::Edge Edge; vector edges; edges.reserve( N * n ); for( size_t s = 0; s < j; s++ ) for( size_t t = 0; t < k; t++ ) { size_t P = (powmod(b,s,p) * powmod(a,t,p)) % p; for( size_t m = 0; m < p; m++ ) edges.push_back( Edge(t*p + m, s*p + ((m + P) % p)) ); } // finish construction G.construct( N, K, edges.begin(), edges.end() ); return G; } // Constructs a parity check table void createParityCheck( Real *result, size_t n, Real eps ) { size_t N = 1 << n; for( size_t i = 0; i < N; i++ ) { size_t c = 0; for( size_t t = 0; t < n; t++ ) if( i & (1 << t) ) c ^= 1; if( c ) result[i] = eps; else result[i] = 1.0 - eps; } return; } /// Predefined names of various factor graph types const char *FULL_TYPE = "FULL"; const char *DREG_TYPE = "DREG"; const char *LOOP_TYPE = "LOOP"; const char *TREE_TYPE = "TREE"; const char *GRID_TYPE = "GRID"; const char *GRID3D_TYPE = "GRID3D"; const char *HOI_TYPE = "HOI"; const char *LDPC_TYPE = "LDPC"; /// Possible LDPC structures DAI_ENUM(LDPCType,SMALL,GROUP,RANDOM); /// Main function int main( int argc, char *argv[] ) { try { // Variables for storing command line arguments size_t seed; size_t states = 2; string type; size_t d, N, K, k, j, n1, n2, n3, prime; bool periodic = false; FactorType ft; LDPCType ldpc; Real beta, sigma_w, sigma_th, mean_w, mean_th, noise; // Declare the supported options. po::options_description opts("General command line options"); opts.add_options() ("help", "produce help message") ("seed", po::value(&seed), "random number seed (tries to read from /dev/urandom if not specified)") ("states", po::value(&states), "number of states of each variable (default=2 for binary variables)") ; // Graph structure options po::options_description opts_graph("Options for specifying graph structure"); opts_graph.add_options() ("type", po::value(&type), "factor graph type (one of 'FULL', 'DREG', 'LOOP', 'TREE', 'GRID', 'GRID3D', 'HOI', 'LDPC')") ("d", po::value(&d), "variable connectivity (only for type=='DREG');\n\t should be even") ("N", po::value(&N), "number of variables (not for type=='GRID','GRID3D')") ("n1", po::value(&n1), "width of grid (only for type=='GRID','GRID3D')") ("n2", po::value(&n2), "height of grid (only for type=='GRID','GRID3D')") ("n3", po::value(&n3), "length of grid (only for type=='GRID3D')") ("periodic", po::value(&periodic), "periodic grid? (only for type=='GRID','GRID3D'; default=0)") ("K", po::value(&K), "number of factors (only for type=='HOI','LDPC')") ("k", po::value(&k), "number of variables per factor (only for type=='HOI','LDPC')") ; // Factor options po::options_description opts_factors("Options for specifying factors"); opts_factors.add_options() ("factors", po::value(&ft), "factor type (one of 'EXPGAUSS','POTTS','ISING')") ("beta", po::value(&beta), "inverse temperature (ignored for factors=='ISING')") ("mean_w", po::value(&mean_w), "mean of pairwise interactions w_{ij} (only for factors=='ISING')") ("mean_th", po::value(&mean_th), "mean of unary interactions th_i (only for factors=='ISING')") ("sigma_w", po::value(&sigma_w), "stddev of pairwise interactions w_{ij} (only for factors=='ISING')") ("sigma_th", po::value(&sigma_th), "stddev of unary interactions th_i (only for factors=='ISING'") ; // LDPC options po::options_description opts_ldpc("Options for specifying LDPC code factor graphs"); opts_ldpc.add_options() ("ldpc", po::value(&ldpc), "type of LDPC code (one of 'SMALL','GROUP','RANDOM')") ("j", po::value(&j), "number of parity checks per bit (only for type=='LDPC')") ("noise", po::value(&noise), "bitflip probability for binary symmetric channel (only for type=='LDPC')") ("prime", po::value(&prime), "prime number for construction of LDPC code (only for type=='LDPC' with ldpc='GROUP'))") ; // All options opts.add(opts_graph).add(opts_factors).add(opts_ldpc); // Parse command line arguments po::variables_map vm; po::store(po::parse_command_line(argc, argv, opts), vm); po::notify(vm); // Display help message if necessary if( vm.count("help") || !vm.count("type") ) { cout << "This program is part of libDAI - http://www.libdai.org/" << endl << endl; cout << "Usage: ./createfg [options]" << endl << endl; cout << "Creates a factor graph according to the specified options." << endl << endl; cout << endl << opts << endl; cout << "The following factor graph types with pairwise interactions can be created:" << endl; cout << "\t'FULL': fully connected graph of variables" << endl; cout << "\t'DREG': random regular graph of variables where each variable is connected with others" << endl; cout << "\t'LOOP': a single loop of variables" << endl; cout << "\t'TREE': random tree-structured (acyclic, connected) graph of variables" << endl; cout << "\t'GRID': 2D grid of x variables" << endl; cout << "\t'GRID3D': 3D grid of xx variables" << endl; cout << "The following higher-order interactions factor graphs can be created:" << endl; cout << "\t'HOI': random factor graph consisting of variables and factors," << endl; cout << "\t each factor being an interaction of variables." << endl; cout << "The following LDPC code factor graphs can be created:" << endl; cout << "\t'LDPC': simulates LDPC decoding problem, using an LDPC code of bits and " << endl; cout << "\t parity checks, with bits per check and checks per bit, transmitted" << endl; cout << "\t on a binary symmetric channel with probability of flipping a bit." << endl; cout << "\t The transmitted codeword has all bits set to zero. The argument 'ldpc'" << endl; cout << "\t determines how the LDPC code is constructed: either using a group structure," << endl; cout << "\t or randomly, or a fixed small code with (N,K,k,j) = (4,4,3,3)." << endl << endl; cout << "For all types except type=='LDPC', the factors have to be specified as well." << endl << endl; cout << "EXPGAUSS factors (the default) are created by drawing all log-factor entries" << endl; cout << "independently from a Gaussian with mean 0 and standard deviation ." << endl << endl; cout << "In case of pairwise interactions, one can also choose POTTS factors, for which" << endl; cout << "the log-factors are simply delta functions multiplied by the strength ." << endl << endl; cout << "For pairwise interactions and binary variables, one can also use ISING factors." << endl; cout << "Here variables x1...xN are assumed to be +1/-1--valued, and unary interactions" << endl; cout << "are of the form exp(th*xi) with th drawn from a Gaussian distribution with mean" << endl; cout << " and standard deviation , and pairwise interactions are of the" << endl; cout << "form exp(w*xi*xj) with w drawn from a Gaussian distribution with mean " << endl; cout << "and standard deviation ." << endl; return 1; } // Set default number of states if( !vm.count("states") ) states = 2; // Set default factor type if( !vm.count("factors") ) ft = FactorType::EXPGAUSS; // Check validness of factor type if( ft == FactorType::POTTS ) if( type == HOI_TYPE ) throw "For factors=='POTTS', interactions should be pairwise (type!='HOI')"; if( ft == FactorType::ISING ) if( ((states != 2) || (type == HOI_TYPE)) ) throw "For factors=='ISING', variables should be binary (states==2) and interactions should be pairwise (type!='HOI')"; // Read random seed if( !vm.count("seed") ) { ifstream infile; bool success; infile.open( "/dev/urandom" ); success = infile.is_open(); if( success ) { infile.read( (char *)&seed, sizeof(size_t) / sizeof(char) ); success = infile.good(); infile.close(); } if( !success ) throw "Please specify random number seed."; } rnd_seed( seed ); // Set default periodicity if( !vm.count("periodic") ) periodic = false; // Store some options in a PropertySet object PropertySet options; if( vm.count("mean_th") ) options.Set("mean_th", mean_th); if( vm.count("sigma_th") ) options.Set("sigma_th", sigma_th); if( vm.count("mean_w") ) options.Set("mean_w", mean_w); if( vm.count("sigma_w") ) options.Set("sigma_w", sigma_w); if( vm.count("beta") ) options.Set("beta", beta); // Output some comments cout << "# Factor graph made by " << argv[0] << endl; cout << "# type = " << type << endl; cout << "# states = " << states << endl; // The factor graph to be constructed FactorGraph fg; #define NEED_ARG(name, desc) do { if(!vm.count(name)) throw "Please specify " desc " with --" name; } while(0); if( type == FULL_TYPE || type == DREG_TYPE || type == LOOP_TYPE || type == TREE_TYPE || type == GRID_TYPE || type == GRID3D_TYPE ) { // Pairwise interactions // Check command line options if( type == GRID_TYPE ) { NEED_ARG("n1", "width of grid"); NEED_ARG("n2", "height of grid"); N = n1 * n2; } else if( type == GRID3D_TYPE ) { NEED_ARG("n1", "width of grid"); NEED_ARG("n2", "height of grid"); NEED_ARG("n3", "depth of grid"); N = n1 * n2 * n3; } else NEED_ARG("N", "number of variables"); if( states > 2 || ft == FactorType::POTTS ) { NEED_ARG("beta", "stddev of log-factor entries"); } else { NEED_ARG("mean_w", "mean of pairwise interactions"); NEED_ARG("mean_th", "mean of unary interactions"); NEED_ARG("sigma_w", "stddev of pairwise interactions"); NEED_ARG("sigma_th", "stddev of unary interactions"); } if( type == DREG_TYPE ) NEED_ARG("d", "connectivity (number of neighboring variables of each variable)"); // Build pairwise interaction graph GraphAL G; if( type == FULL_TYPE ) G = createGraphFull( N ); else if( type == DREG_TYPE ) G = createGraphRegular( N, d ); else if( type == LOOP_TYPE ) G = createGraphLoop( N ); else if( type == TREE_TYPE ) G = createGraphTree( N ); else if( type == GRID_TYPE ) G = createGraphGrid( n1, n2, periodic ); else if( type == GRID3D_TYPE ) G = createGraphGrid3D( n1, n2, n3, periodic ); // Construct factor graph from pairwise interaction graph fg = createFG( G, ft, states, options ); // Output some additional comments if( type == GRID_TYPE || type == GRID3D_TYPE ) { cout << "# n1 = " << n1 << endl; cout << "# n2 = " << n2 << endl; if( type == GRID3D_TYPE ) cout << "# n3 = " << n3 << endl; } if( type == DREG_TYPE ) cout << "# d = " << d << endl; cout << "# options = " << options << endl; } else if( type == HOI_TYPE ) { // Higher order interactions // Check command line arguments NEED_ARG("N", "number of variables"); NEED_ARG("K", "number of factors"); NEED_ARG("k", "number of variables per factor"); NEED_ARG("beta", "stddev of log-factor entries"); // Create higher-order interactions factor graph do { fg = createHOIFG( N, K, k, beta ); } while( !fg.isConnected() ); // Output some additional comments cout << "# K = " << K << endl; cout << "# k = " << k << endl; cout << "# beta = " << beta << endl; } else if( type == LDPC_TYPE ) { // LDPC codes // Check command line arguments NEED_ARG("ldpc", "type of LDPC code"); NEED_ARG("noise", "bitflip probability for binary symmetric channel"); // Check more command line arguments (seperately for each LDPC type) if( ldpc == LDPCType::RANDOM ) { NEED_ARG("N", "number of variables"); NEED_ARG("K", "number of factors"); NEED_ARG("k", "number of variables per factor"); NEED_ARG("j", "number of parity checks per bit"); if( N * j != K * k ) throw "Parameters should satisfy N * j == K * k"; } else if( ldpc == LDPCType::GROUP ) { NEED_ARG("prime", "prime number"); NEED_ARG("k", "number of variables per factor"); NEED_ARG("j", "number of parity checks per bit"); if( !isPrime(prime) ) throw "Parameter should be prime"; if( !((prime-1) % j == 0 ) ) throw "Parameters should satisfy (prime-1) % j == 0"; if( !((prime-1) % k == 0 ) ) throw "Parameters should satisfy (prime-1) % k == 0"; N = prime * k; K = prime * j; } else if( ldpc == LDPCType::SMALL ) { N = 4; K = 4; j = 3; k = 3; } // Output some additional comments cout << "# N = " << N << endl; cout << "# K = " << K << endl; cout << "# j = " << j << endl; cout << "# k = " << k << endl; if( ldpc == LDPCType::GROUP ) cout << "# prime = " << prime << endl; cout << "# noise = " << noise << endl; // Construct likelihood and paritycheck factors Real likelihood[4] = {1.0 - noise, noise, noise, 1.0 - noise}; Real *paritycheck = new Real[1 << k]; createParityCheck(paritycheck, k, 0.0); // Create LDPC structure BipartiteGraph ldpcG; bool regular; do { if( ldpc == LDPCType::GROUP ) ldpcG = createGroupStructuredLDPCGraph( prime, j, k ); else if( ldpc == LDPCType::RANDOM ) ldpcG = createRandomBipartiteGraph( N, K, j, k ); else if( ldpc == LDPCType::SMALL ) ldpcG = createSmallLDPCGraph(); regular = true; for( size_t i = 0; i < N; i++ ) if( ldpcG.nb1(i).size() != j ) regular = false; for( size_t I = 0; I < K; I++ ) if( ldpcG.nb2(I).size() != k ) regular = false; } while( !regular && !ldpcG.isConnected() ); // Convert to FactorGraph vector factors; for( size_t I = 0; I < K; I++ ) { VarSet vs; for( size_t _i = 0; _i < k; _i++ ) { size_t i = ldpcG.nb2(I)[_i]; vs |= Var( i, 2 ); } factors.push_back( Factor( vs, paritycheck ) ); } delete paritycheck; // Generate noise vector vector noisebits(N,0); size_t bitflips = 0; for( size_t i = 0; i < N; i++ ) { if( rnd_uniform() < noise ) { noisebits[i] = 1; bitflips++; } } cout << "# bitflips = " << bitflips << endl; // Simulate transmission of all-zero codeword vector input(N,0); vector output(N,0); for( size_t i = 0; i < N; i++ ) output[i] = (input[i] + noisebits[i]) & 1; // Add likelihoods for( size_t i = 0; i < N; i++ ) factors.push_back( Factor(Var(i,2), likelihood + output[i]*2) ); // Construct Factor Graph fg = FactorGraph( factors ); } else throw "Invalid type"; // Output additional comments cout << "# N = " << fg.nrVars() << endl; cout << "# seed = " << seed << endl; // Output factor graph cout << fg; } catch( const char *e ) { /// Display error message cerr << "Error: " << e << endl; return 1; } return 0; } libDAI-0.2.4/utils/fginfo.cpp0000644000263000017630000001560011334764774014613 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include using namespace std; using namespace dai; void findLoopClusters( const FactorGraph & fg, std::set &allcl, VarSet newcl, const Var & root, size_t length, VarSet vars ) { for( VarSet::const_iterator in = vars.begin(); in != vars.end(); in++ ) { VarSet ind = fg.delta( *in ); if( (newcl.size()) >= 2 && ind.contains( root ) ) { allcl.insert( newcl | *in ); } else if( length > 1 ) findLoopClusters( fg, allcl, newcl | *in, root, length - 1, ind / newcl ); } } size_t countLoops( const FactorGraph & fg, size_t loopdepth ) { set loops; for( vector::const_iterator i0 = fg.vars().begin(); i0 != fg.vars().end(); i0++ ) { VarSet i0d = fg.delta(*i0); if( loopdepth > 1 ) findLoopClusters( fg, loops, *i0, *i0, loopdepth - 1, i0d ); } return loops.size(); } bool hasShortLoops( const std::vector &P ) { bool found = false; vector::const_iterator I, J; for( I = P.begin(); I != P.end(); I++ ) { J = I; J++; for( ; J != P.end(); J++ ) if( (I->vars() & J->vars()).size() >= 2 ) { found = true; break; } if( found ) break; } return found; } bool hasNegatives( const std::vector &P ) { bool found = false; for( size_t I = 0; I < P.size(); I++ ) if( P[I].hasNegatives() ) { found = true; break; } return found; } int main( int argc, char *argv[] ) { if( argc != 3 ) { // Display help message if number of command line arguments is incorrect cout << "This program is part of libDAI - http://www.libdai.org/" << endl << endl; cout << "Usage: ./fginfo " << endl << endl; cout << "Reports some detailed information about the factor graph ." << endl; cout << "Also calculates treewidth (which may take some time) unless == 0." << endl; return 1; } else { // Read factorgraph FactorGraph fg; char *infile = argv[1]; int calc_tw = atoi(argv[2]); fg.ReadFromFile( infile ); // Output various statistics cout << "Number of variables: " << fg.nrVars() << endl; cout << "Number of factors: " << fg.nrFactors() << endl; cout << "Connected: " << fg.isConnected() << endl; cout << "Tree: " << fg.isTree() << endl; cout << "Has short loops: " << hasShortLoops(fg.factors()) << endl; cout << "Has negatives: " << hasNegatives(fg.factors()) << endl; cout << "Binary variables? " << fg.isBinary() << endl; cout << "Pairwise interactions? " << fg.isPairwise() << endl; // Calculate treewidth using various heuristics, if requested if( calc_tw ) { std::pair tw; tw = boundTreewidth(fg, &eliminationCost_MinNeighbors); cout << "Treewidth (MinNeighbors): " << tw.first << " (" << tw.second << " states)" << endl; tw = boundTreewidth(fg, &eliminationCost_MinWeight); cout << "Treewidth (MinWeight): " << tw.first << " (" << tw.second << " states)" << endl; tw = boundTreewidth(fg, &eliminationCost_MinFill); cout << "Treewidth (MinFill): " << tw.first << " (" << tw.second << " states)" << endl; tw = boundTreewidth(fg, &eliminationCost_WeightedMinFill); cout << "Treewidth (WeightedMinFill): " << tw.first << " (" << tw.second << " states)" << endl; } // Calculate total state space long double stsp = 1.0; for( size_t i = 0; i < fg.nrVars(); i++ ) stsp *= fg.var(i).states(); cout << "Total state space: " << stsp << endl; // Output type of factor graph cout << "Type: " << (fg.isPairwise() ? "pairwise" : "higher order") << " interactions, " << (fg.isBinary() ? "binary" : "nonbinary") << " variables" << endl; // Calculate complexity for LCBP long double cavsum_lcbp = 0.0; long double cavsum_lcbp2 = 0.0; size_t max_Delta_size = 0; map cavsizes; for( size_t i = 0; i < fg.nrVars(); i++ ) { VarSet di = fg.delta(i); if( cavsizes.count(di.size()) ) cavsizes[di.size()]++; else cavsizes[di.size()] = 1; size_t Ds = fg.Delta(i).nrStates(); if( Ds > max_Delta_size ) max_Delta_size = Ds; cavsum_lcbp += di.nrStates(); for( VarSet::const_iterator j = di.begin(); j != di.end(); j++ ) cavsum_lcbp2 += j->states(); } cout << "Maximum pancake has " << max_Delta_size << " states" << endl; cout << "LCBP with full cavities needs " << cavsum_lcbp << " BP runs" << endl; cout << "LCBP with only pairinteractions needs " << cavsum_lcbp2 << " BP runs" << endl; cout << "Cavity sizes: "; for( map::const_iterator it = cavsizes.begin(); it != cavsizes.end(); it++ ) cout << it->first << "(" << it->second << ") "; cout << endl; // Calculate girth and length of loops if( fg.isPairwise() ) { bool girth_reached = false; size_t loopdepth; for( loopdepth = 2; loopdepth <= fg.nrVars() && !girth_reached; loopdepth++ ) { size_t nr_loops = countLoops( fg, loopdepth ); cout << "Loops up to " << loopdepth << " variables: " << nr_loops << endl; if( nr_loops > 0 ) girth_reached = true; } if( girth_reached ) cout << "Girth: " << loopdepth-1 << endl; else cout << "Girth: infinity" << endl; } // Output factor state spaces map facsizes; for( size_t I = 0; I < fg.nrFactors(); I++ ) { size_t Isize = fg.factor(I).vars().size(); if( facsizes.count( Isize ) ) facsizes[Isize]++; else facsizes[Isize] = 1; } cout << "Factor sizes: "; for( map::const_iterator it = facsizes.begin(); it != facsizes.end(); it++ ) cout << it->first << "(" << it->second << ") "; cout << endl; return 0; } } libDAI-0.2.4/utils/viewfg0000755000263000017630000000005711334764774014054 0ustar jorismkyb#!/bin/bash ./fg2dot $1 - | neato -T ps | gv - libDAI-0.2.4/AUTHORS0000644000263000017630000000071411334764774012547 0ustar jorismkybThe following people have contributed to libDAI (in decreasing order of importance): Joris Mooij Martijn Leisink Frederik Eaton Charles Vaske Giuseppe Passino Bastian Wemmenhove Patrick Pletscher Christian Wojek Claudio Lima Jiuxiang Hu Peter Gober Sebastian Nowozin Alexander Schwing Alejandro Lage This work is part of the Interactive Collaborative Information Systems (ICIS) project, supported by the Dutch Ministry of Economic Affairs, grant BSIK03024. libDAI-0.2.4/Makefile.CYGWIN0000644000263000017630000000365511334764774014145 0ustar jorismkyb# This file is part of libDAI - http://www.libdai.org/ # # libDAI is licensed under the terms of the GNU General Public License version # 2, or (at your option) any later version. libDAI is distributed without any # warranty. See the file COPYING for more details. # # Copyright (C) 2009-2010 Joris Mooij [joris dot mooij at libdai dot org] # This template contains configurations for compiling libDAI under CygWin # # To use it, simply copy this file to 'Makefile.conf' and adapt 'Makefile.conf' # to your local setup # OPERATING SYSTEM # Choose OS from {LINUX, WINDOWS, CYGWIN, MACOSX} OS=CYGWIN # FILE EXTENSIONS # Static library LE=.a # Object file OE=.o # Binary executable EE= # MatLab compiled MEX file ME=.mexglx # COMPILER # Compile using GNU C++ Compiler CC=g++ # Output filename option of the compiler CCO=-o # Flags for the C++ compiler # (dynamic linking of Boost libraries seems not to work on Cygwin) CCFLAGS=-Wno-deprecated -Wall -W -Wextra -DCYGWIN -static # Flags to add in debugging mode (if DEBUG=true) CCDEBUGFLAGS=-O3 -g -DDAI_DEBUG # Flags to add in non-debugging mode (if DEBUG=false) CCNODEBUGFLAGS=-O3 # Standard include directories CCINC=-Iinclude -I/usr/local/include/boost-1_37 # LINKER # Standard libraries to include LIBS=-ldai # For linking with the BOOST Program Options library BOOSTLIBS=-lboost_program_options-gcc34-mt # Additional library search paths for linker CCLIB=-Llib # MATLAB # Replace the following by the directory where MatLab has been installed MATLABDIR=/agbs/share/sw/matlab # The following should resolve to the MatLab mex compile command MEX=$(MATLABDIR)/bin/mex # Specify the same C++ compiler and flags to mex MEXFLAGS=CXX\#$(CC) CXXFLAGS\#'$(CCFLAGS)' # SWIG PYTHON INTERFACE # The following should resolve to the SWIG command SWIG=swig # Location of Python header files INCLUDE_PYTHON=/usr/include/python2.5 # Location of Boost C++ library header files INCLUDE_BOOST=/usr/local/include/boost-1_37 libDAI-0.2.4/Makefile0000644000263000017630000002625311334764774013145 0ustar jorismkyb# This file is part of libDAI - http://www.libdai.org/ # # libDAI is licensed under the terms of the GNU General Public License version # 2, or (at your option) any later version. libDAI is distributed without any # warranty. See the file COPYING for more details. # # Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] # Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands # Load the platform independent build configuration file include Makefile.ALL # Load the local configuration from Makefile.conf include Makefile.conf # Set version and date DAI_VERSION="0.2.4" DAI_DATE="February 11, 2010" # Directories of libDAI sources # Location libDAI headers INC=include/dai # Location of libDAI source files SRC=src # Destination directory of libDAI library LIB=lib # Set final compiler flags ifdef DEBUG CCFLAGS:=$(CCFLAGS) $(CCDEBUGFLAGS) else CCFLAGS:=$(CCFLAGS) $(CCNODEBUGFLAGS) endif # Define build targets TARGETS=tests utils lib examples testregression testem ifdef WITH_DOC TARGETS:=$(TARGETS) doc endif ifdef WITH_MATLAB TARGETS:=$(TARGETS) matlabs # Specify the same C++ compiler and flags to mex ifneq ($(OS),WINDOWS) MEXFLAGS=CXX\#$(CC) CXXFLAGS\#'$(CCFLAGS)' else MEXFLAGS=CXX\#$(CC) CXXFLAGS\#"$(CCFLAGS)" endif ifdef NEW_MATLAB MEXFLAGS:=$(MEXFLAGS) -largeArrayDims else MEXFLAGS:=$(MEXFLAGS) -DSMALLMEM endif endif # Define conditional build targets OBJECTS:=exactinf$(OE) evidence$(OE) emalg$(OE) ifdef WITH_BP CCFLAGS:=$(CCFLAGS) -DDAI_WITH_BP OBJECTS:=$(OBJECTS) bp$(OE) endif ifdef WITH_FBP CCFLAGS:=$(CCFLAGS) -DDAI_WITH_FBP OBJECTS:=$(OBJECTS) fbp$(OE) endif ifdef WITH_TRWBP CCFLAGS:=$(CCFLAGS) -DDAI_WITH_TRWBP OBJECTS:=$(OBJECTS) trwbp$(OE) endif ifdef WITH_MF CCFLAGS:=$(CCFLAGS) -DDAI_WITH_MF OBJECTS:=$(OBJECTS) mf$(OE) endif ifdef WITH_HAK CCFLAGS:=$(CCFLAGS) -DDAI_WITH_HAK OBJECTS:=$(OBJECTS) hak$(OE) endif ifdef WITH_LC CCFLAGS:=$(CCFLAGS) -DDAI_WITH_LC OBJECTS:=$(OBJECTS) lc$(OE) endif ifdef WITH_TREEEP CCFLAGS:=$(CCFLAGS) -DDAI_WITH_TREEEP OBJECTS:=$(OBJECTS) treeep$(OE) endif ifdef WITH_JTREE CCFLAGS:=$(CCFLAGS) -DDAI_WITH_JTREE OBJECTS:=$(OBJECTS) jtree$(OE) endif ifdef WITH_MR CCFLAGS:=$(CCFLAGS) -DDAI_WITH_MR OBJECTS:=$(OBJECTS) mr$(OE) endif ifdef WITH_GIBBS CCFLAGS:=$(CCFLAGS) -DDAI_WITH_GIBBS OBJECTS:=$(OBJECTS) gibbs$(OE) endif ifdef WITH_CBP CCFLAGS:=$(CCFLAGS) -DDAI_WITH_CBP OBJECTS:=$(OBJECTS) bbp$(OE) cbp$(OE) bp_dual$(OE) endif # Define standard libDAI header dependencies HEADERS=$(INC)/bipgraph.h $(INC)/graph.h $(INC)/index.h $(INC)/var.h $(INC)/factor.h $(INC)/varset.h $(INC)/smallset.h $(INC)/prob.h $(INC)/daialg.h $(INC)/properties.h $(INC)/alldai.h $(INC)/enum.h $(INC)/exceptions.h $(INC)/util.h # Setup final command for C++ compiler and MEX ifneq ($(OS),WINDOWS) CC:=$(CC) $(CCINC) $(CCFLAGS) $(CCLIB) else CC:=$(CC) $(CCINC) $(CCFLAGS) LIBS:=$(LIBS) $(CCLIB) endif MEX:=$(MEX) $(CCLIB) $(CCINC) $(MEXFLAGS) # META TARGETS ############### all : $(TARGETS) examples : examples/example$(EE) examples/example_bipgraph$(EE) examples/example_varset$(EE) examples/example_permute$(EE) examples/example_sprinkler$(EE) examples/example_sprinkler_gibbs$(EE) examples/example_sprinkler_em$(EE) matlabs : matlab/dai$(ME) matlab/dai_readfg$(ME) matlab/dai_writefg$(ME) matlab/dai_potstrength$(ME) tests : tests/testdai$(EE) tests/testem/testem$(EE) tests/testbbp$(EE) utils : utils/createfg$(EE) utils/fg2dot$(EE) utils/fginfo$(EE) lib: $(LIB)/libdai$(LE) # OBJECTS ########## bipgraph$(OE) : $(SRC)/bipgraph.cpp $(HEADERS) $(CC) -c $(SRC)/bipgraph.cpp graph$(OE) : $(SRC)/graph.cpp $(HEADERS) $(CC) -c $(SRC)/graph.cpp varset$(OE) : $(SRC/varset.cpp $(HEADERS) $(CC) -c $(SRC)/varset.cpp daialg$(OE) : $(SRC)/daialg.cpp $(HEADERS) $(CC) -c $(SRC)/daialg.cpp exactinf$(OE) : $(SRC)/exactinf.cpp $(INC)/exactinf.h $(HEADERS) $(CC) -c $(SRC)/exactinf.cpp bp$(OE) : $(SRC)/bp.cpp $(INC)/bp.h $(HEADERS) $(CC) -c $(SRC)/bp.cpp fbp$(OE) : $(SRC)/fbp.cpp $(INC)/fbp.h $(HEADERS) $(CC) -c $(SRC)/fbp.cpp trwbp$(OE) : $(SRC)/trwbp.cpp $(INC)/trwbp.h $(HEADERS) $(CC) -c $(SRC)/trwbp.cpp bp_dual$(OE) : $(SRC)/bp_dual.cpp $(INC)/bp_dual.h $(HEADERS) $(CC) -c $(SRC)/bp_dual.cpp bbp$(OE) : $(SRC)/bbp.cpp $(INC)/bbp.h $(INC)/bp_dual.h $(HEADERS) $(CC) -c $(SRC)/bbp.cpp cbp$(OE) : $(SRC)/cbp.cpp $(INC)/cbp.h $(INC)/bbp.h $(INC)/bp_dual.h $(HEADERS) $(CC) -c $(SRC)/cbp.cpp lc$(OE) : $(SRC)/lc.cpp $(INC)/lc.h $(HEADERS) $(CC) -c $(SRC)/lc.cpp mf$(OE) : $(SRC)/mf.cpp $(INC)/mf.h $(HEADERS) $(CC) -c $(SRC)/mf.cpp factor$(OE) : $(SRC)/factor.cpp $(INC)/factor.h $(HEADERS) $(CC) -c $(SRC)/factor.cpp factorgraph$(OE) : $(SRC)/factorgraph.cpp $(INC)/factorgraph.h $(HEADERS) $(CC) -c $(SRC)/factorgraph.cpp util$(OE) : $(SRC)/util.cpp $(INC)/util.h $(HEADERS) $(CC) -c $(SRC)/util.cpp regiongraph$(OE) : $(SRC)/regiongraph.cpp $(INC)/regiongraph.h $(HEADERS) $(CC) -c $(SRC)/regiongraph.cpp hak$(OE) : $(SRC)/hak.cpp $(INC)/hak.h $(HEADERS) $(INC)/regiongraph.h $(CC) -c $(SRC)/hak.cpp clustergraph$(OE) : $(SRC)/clustergraph.cpp $(INC)/clustergraph.h $(HEADERS) $(CC) -c $(SRC)/clustergraph.cpp jtree$(OE) : $(SRC)/jtree.cpp $(INC)/jtree.h $(HEADERS) $(INC)/weightedgraph.h $(INC)/clustergraph.h $(INC)/regiongraph.h $(CC) -c $(SRC)/jtree.cpp treeep$(OE) : $(SRC)/treeep.cpp $(INC)/treeep.h $(HEADERS) $(INC)/weightedgraph.h $(INC)/clustergraph.h $(INC)/regiongraph.h $(INC)/jtree.h $(CC) -c $(SRC)/treeep.cpp weightedgraph$(OE) : $(SRC)/weightedgraph.cpp $(INC)/weightedgraph.h $(HEADERS) $(CC) -c $(SRC)/weightedgraph.cpp mr$(OE) : $(SRC)/mr.cpp $(INC)/mr.h $(HEADERS) $(CC) -c $(SRC)/mr.cpp gibbs$(OE) : $(SRC)/gibbs.cpp $(INC)/gibbs.h $(HEADERS) $(CC) -c $(SRC)/gibbs.cpp evidence$(OE) : $(SRC)/evidence.cpp $(INC)/evidence.h $(HEADERS) $(CC) -c $(SRC)/evidence.cpp emalg$(OE) : $(SRC)/emalg.cpp $(INC)/emalg.h $(INC)/evidence.h $(HEADERS) $(CC) -c $(SRC)/emalg.cpp properties$(OE) : $(SRC)/properties.cpp $(HEADERS) $(CC) -c $(SRC)/properties.cpp exceptions$(OE) : $(SRC)/exceptions.cpp $(HEADERS) $(CC) -c $(SRC)/exceptions.cpp alldai$(OE) : $(SRC)/alldai.cpp $(HEADERS) $(CC) -c $(SRC)/alldai.cpp # EXAMPLES ########### examples/example$(EE) : examples/example.cpp $(HEADERS) $(LIB)/libdai$(LE) $(CC) $(CCO)examples/example$(EE) examples/example.cpp $(LIBS) examples/example_bipgraph$(EE) : examples/example_bipgraph.cpp $(HEADERS) $(LIB)/libdai$(LE) $(CC) $(CCO)examples/example_bipgraph$(EE) examples/example_bipgraph.cpp $(LIBS) examples/example_varset$(EE) : examples/example_varset.cpp $(HEADERS) $(LIB)/libdai$(LE) $(CC) $(CCO)examples/example_varset$(EE) examples/example_varset.cpp $(LIBS) examples/example_permute$(EE) : examples/example_permute.cpp $(HEADERS) $(LIB)/libdai$(LE) $(CC) $(CCO)examples/example_permute$(EE) examples/example_permute.cpp $(LIBS) examples/example_sprinkler$(EE) : examples/example_sprinkler.cpp $(HEADERS) $(LIB)/libdai$(LE) $(CC) $(CCO)examples/example_sprinkler$(EE) examples/example_sprinkler.cpp $(LIBS) examples/example_sprinkler_gibbs$(EE) : examples/example_sprinkler_gibbs.cpp $(HEADERS) $(LIB)/libdai$(LE) $(CC) $(CCO)examples/example_sprinkler_gibbs$(EE) examples/example_sprinkler_gibbs.cpp $(LIBS) examples/example_sprinkler_em$(EE) : examples/example_sprinkler_em.cpp $(HEADERS) $(LIB)/libdai$(LE) $(CC) $(CCO)examples/example_sprinkler_em$(EE) examples/example_sprinkler_em.cpp $(LIBS) # TESTS ######## tests/testdai$(EE) : tests/testdai.cpp $(HEADERS) $(LIB)/libdai$(LE) $(CC) $(CCO)tests/testdai$(EE) tests/testdai.cpp $(LIBS) $(BOOSTLIBS) tests/testem/testem$(EE) : tests/testem/testem.cpp $(HEADERS) $(LIB)/libdai$(LE) $(CC) $(CCO)$@ $< $(LIBS) $(BOOSTLIBS) tests/testbbp$(EE) : tests/testbbp.cpp $(HEADERS) $(LIB)/libdai$(LE) $(CC) $(CCO)tests/testbbp$(EE) tests/testbbp.cpp $(LIBS) # MATLAB INTERFACE ################### matlab/dai$(ME) : $(SRC)/matlab/dai.cpp $(HEADERS) matlab$(OE) $(LIB)/libdai$(LE) $(MEX) -o matlab/dai $(SRC)/matlab/dai.cpp matlab$(OE) $(LIB)/libdai$(LE) matlab/dai_readfg$(ME) : $(SRC)/matlab/dai_readfg.cpp $(HEADERS) factorgraph$(OE) matlab$(OE) exceptions$(OE) bipgraph$(OE) $(MEX) -o matlab/dai_readfg $(SRC)/matlab/dai_readfg.cpp factorgraph$(OE) matlab$(OE) exceptions$(OE) bipgraph$(OE) matlab/dai_writefg$(ME) : $(SRC)/matlab/dai_writefg.cpp $(HEADERS) factorgraph$(OE) matlab$(OE) exceptions$(OE) bipgraph$(OE) $(MEX) -o matlab/dai_writefg $(SRC)/matlab/dai_writefg.cpp factorgraph$(OE) matlab$(OE) exceptions$(OE) bipgraph$(OE) matlab/dai_potstrength$(ME) : $(SRC)/matlab/dai_potstrength.cpp $(HEADERS) matlab$(OE) exceptions$(OE) $(MEX) -o matlab/dai_potstrength $(SRC)/matlab/dai_potstrength.cpp matlab$(OE) exceptions$(OE) matlab$(OE) : $(SRC)/matlab/matlab.cpp $(INC)/matlab/matlab.h $(HEADERS) $(MEX) -c $(SRC)/matlab/matlab.cpp # UTILS ######## utils/createfg$(EE) : utils/createfg.cpp $(HEADERS) $(LIB)/libdai$(LE) $(CC) $(CCO)utils/createfg$(EE) utils/createfg.cpp $(LIBS) $(BOOSTLIBS) utils/fg2dot$(EE) : utils/fg2dot.cpp $(HEADERS) $(LIB)/libdai$(LE) $(CC) $(CCO)utils/fg2dot$(EE) utils/fg2dot.cpp $(LIBS) utils/fginfo$(EE) : utils/fginfo.cpp $(HEADERS) $(LIB)/libdai$(LE) $(CC) $(CCO)utils/fginfo$(EE) utils/fginfo.cpp $(LIBS) # LIBRARY ########## OBJECTS:=bipgraph$(OE) graph$(OE) varset$(OE) daialg$(OE) alldai$(OE) clustergraph$(OE) factor$(OE) factorgraph$(OE) properties$(OE) regiongraph$(OE) util$(OE) weightedgraph$(OE) exceptions$(OE) $(OBJECTS) ifneq ($(OS),WINDOWS) $(LIB)/libdai$(LE) : $(OBJECTS) -mkdir -p lib ar rcus $(LIB)/libdai$(LE) $(OBJECTS) else $(LIB)/libdai$(LE) : $(OBJECTS) -mkdir lib lib /out:$(LIB)/libdai$(LE) $(OBJECTS) endif # REGRESSION TESTS ################### testregression : tests/testdai$(EE) @echo Starting regression test...this can take a minute or so! ifneq ($(OS),WINDOWS) cd tests && ./testregression && cd .. else cd tests && testregression.bat && cd .. endif testem : tests/testem/testem$(EE) @echo Starting EM tests ifneq ($(OS),WINDOWS) cd tests/testem && ./runtests && cd ../.. else cd tests\testem && runtests && cd ..\.. endif # DOCUMENTATION ################ doc : $(INC)/*.h $(SRC)/*.cpp examples/*.cpp doxygen.conf doxygen doxygen.conf README : doc scripts/makeREADME DAI_VERSION=$(DAI_VERSION) DAI_DATE=$(DAI_DATE) scripts/makeREADME TAGS : etags src/*.cpp include/dai/*.h tests/*.cpp utils/*.cpp ctags src/*.cpp include/dai/*.h tests/*.cpp utils/*.cpp # CLEAN ######## ifneq ($(OS),WINDOWS) .PHONY : clean clean : -rm *$(OE) -rm matlab/*$(ME) -rm examples/example$(EE) examples/example_bipgraph$(EE) examples/example_varset$(EE) examples/example_permute$(EE) examples/example_sprinkler$(EE) examples/example_sprinkler_gibbs$(EE) examples/example_sprinkler_em$(EE) -rm tests/testdai$(EE) tests/testem/testem$(EE) tests/testbbp$(EE) -rm utils/fg2dot$(EE) utils/createfg$(EE) utils/fginfo$(EE) -rm -R doc -rm -R lib else .PHONY : clean clean : -del *$(OE) -del *.ilk -del *.pdb -del *$(EE) -del matlab\*$(ME) -del examples\*$(EE) -del examples\*.ilk -del examples\*.pdb -del tests\testdai$(EE) -del tests\testbbp$(EE) -del tests\testem\testem$(EE) -del tests\*.pdb -del tests\*.ilk -del tests\testem\*.pdb -del tests\testem\*.ilk -del utils\*$(EE) -del utils\*.pdb -del utils\*.ilk -del $(LIB)\libdai$(LE) -rmdir lib endif libDAI-0.2.4/Makefile.LINUX0000644000263000017630000000351211334764774014034 0ustar jorismkyb# This file is part of libDAI - http://www.libdai.org/ # # libDAI is licensed under the terms of the GNU General Public License version # 2, or (at your option) any later version. libDAI is distributed without any # warranty. See the file COPYING for more details. # # Copyright (C) 2009-2010 Joris Mooij [joris dot mooij at libdai dot org] # This template contains configurations for compiling libDAI under GNU/Linux # and other UNIX variants # # To use it, simply copy this file to 'Makefile.conf' and adapt 'Makefile.conf' # to your local setup # OPERATING SYSTEM # Choose OS from {LINUX, WINDOWS, CYGWIN, MACOSX} OS=LINUX # FILE EXTENSIONS # Static library LE=.a # Object file OE=.o # Binary executable EE= # MatLab compiled MEX file ME=.mexglx # COMPILER # Compile using GNU C++ Compiler CC=g++ # Output filename option of the compiler CCO=-o # Flags for the C++ compiler CCFLAGS=-Wno-deprecated -Wall -W -Wextra -fpic # Flags to add in debugging mode (if DEBUG=true) CCDEBUGFLAGS=-O3 -g -DDAI_DEBUG # Flags to add in non-debugging mode (if DEBUG=false) CCNODEBUGFLAGS=-O3 # Standard include directories CCINC=-Iinclude # LINKER # Standard libraries to include LIBS=-ldai # For linking with the BOOST Program Options library BOOSTLIBS=-lboost_program_options-mt # Additional library search paths for linker CCLIB=-Llib # MATLAB # Replace the following by the directory where MatLab has been installed MATLABDIR=/agbs/share/sw/matlab # The following should resolve to the MatLab mex compile command MEX=$(MATLABDIR)/bin/mex # Specify the same C++ compiler and flags to mex MEXFLAGS=CXX\#$(CC) CXXFLAGS\#'$(CCFLAGS)' # SWIG PYTHON INTERFACE # The following should resolve to the SWIG command SWIG=swig # Location of Python header files INCLUDE_PYTHON=/usr/include/python2.5 # Location of Boost C++ library header files INCLUDE_BOOST=/usr/include/boost libDAI-0.2.4/src/0000755000263000017630000000000011334764774012264 5ustar jorismkyblibDAI-0.2.4/src/evidence.cpp0000644000263000017630000000562211334764774014557 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Charles Vaske [cvaske at soe dot ucsc dot edu] * Copyright (C) 2009 University of California, Santa Cruz */ #include #include #include #include #include #include namespace dai { void Evidence::addEvidenceTabFile( std::istream &is, FactorGraph &fg ) { std::map varMap; for( std::vector::const_iterator v = fg.vars().begin(); v != fg.vars().end(); ++v ) { std::stringstream s; s << v->label(); varMap[s.str()] = *v; } addEvidenceTabFile( is, varMap ); } void Evidence::addEvidenceTabFile( std::istream &is, std::map &varMap ) { std::string line; getline( is, line ); size_t line_number = 0; // Parse header std::vector header_fields; tokenizeString( line, header_fields ); std::vector::const_iterator p_field = header_fields.begin(); if( p_field == header_fields.end() ) DAI_THROWE(INVALID_EVIDENCE_FILE,"Empty header line"); std::vector vars; for( ; p_field != header_fields.end(); ++p_field ) { std::map::iterator elem = varMap.find( *p_field ); if( elem == varMap.end() ) DAI_THROWE(INVALID_EVIDENCE_FILE,"Variable " + *p_field + " not known"); vars.push_back( elem->second ); } getline(is,line); if( is.fail() || line.size() > 0 ) DAI_THROWE(INVALID_EVIDENCE_FILE,"Expecting empty line"); // Read samples while( getline(is, line) ) { line_number++; std::vector fields; tokenizeString( line, fields ); if( fields.size() != vars.size() ) DAI_THROWE(INVALID_EVIDENCE_FILE,"Invalid number of fields in line " + boost::lexical_cast(line_number)); Observation sample; for( size_t i = 0; i < vars.size(); ++i ) { if( fields[i].size() > 0 ) { // skip if missing observation if( fields[i].find_first_not_of("0123456789") != std::string::npos ) DAI_THROWE(INVALID_EVIDENCE_FILE,"Invalid state " + fields[i] + " in line " + boost::lexical_cast(line_number)); size_t state = atoi( fields[i].c_str() ); if( state >= vars[i].states() ) DAI_THROWE(INVALID_EVIDENCE_FILE,"State " + fields[i] + " too large in line " + boost::lexical_cast(line_number)); sample[vars[i]] = state; } } _samples.push_back( sample ); } // finished sample line } } // end of namespace dai libDAI-0.2.4/src/exactinf.cpp0000644000263000017630000000600711334764774014574 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include namespace dai { using namespace std; const char *ExactInf::Name = "EXACT"; void ExactInf::setProperties( const PropertySet &opts ) { DAI_ASSERT( opts.hasKey("verbose") ); props.verbose = opts.getStringAs("verbose"); } PropertySet ExactInf::getProperties() const { PropertySet opts; opts.Set( "verbose", props.verbose ); return opts; } string ExactInf::printProperties() const { stringstream s( stringstream::out ); s << "["; s << "verbose=" << props.verbose << "]"; return s.str(); } void ExactInf::construct() { // clear variable beliefs and reserve space _beliefsV.clear(); _beliefsV.reserve( nrVars() ); for( size_t i = 0; i < nrVars(); i++ ) _beliefsV.push_back( Factor( var(i) ) ); // clear factor beliefs and reserve space _beliefsF.clear(); _beliefsF.reserve( nrFactors() ); for( size_t I = 0; I < nrFactors(); I++ ) _beliefsF.push_back( Factor( factor(I).vars() ) ); } void ExactInf::init() { for( size_t i = 0; i < nrVars(); i++ ) _beliefsV[i].fill( 1.0 ); for( size_t I = 0; I < nrFactors(); I++ ) _beliefsF[I].fill( 1.0 ); } Real ExactInf::run() { if( props.verbose >= 1 ) cerr << "Starting " << identify() << "..."; Factor P; for( size_t I = 0; I < nrFactors(); I++ ) P *= factor(I); Real Z = P.sum(); _logZ = std::log(Z); for( size_t i = 0; i < nrVars(); i++ ) _beliefsV[i] = P.marginal(var(i)); for( size_t I = 0; I < nrFactors(); I++ ) _beliefsF[I] = P.marginal(factor(I).vars()); if( props.verbose >= 1 ) cerr << "finished" << endl; return 0.0; } Factor ExactInf::calcMarginal( const VarSet &vs ) const { Factor P; for( size_t I = 0; I < nrFactors(); I++ ) P *= factor(I); return P.marginal( vs, true ); } vector ExactInf::beliefs() const { vector result = _beliefsV; result.insert( result.end(), _beliefsF.begin(), _beliefsF.end() ); return result; } Factor ExactInf::belief( const VarSet &ns ) const { if( ns.size() == 0 ) return Factor(); else if( ns.size() == 1 ) { return beliefV( findVar( *(ns.begin()) ) ); } else { size_t I; for( I = 0; I < nrFactors(); I++ ) if( factor(I).vars() >> ns ) break; if( I == nrFactors() ) DAI_THROW(BELIEF_NOT_AVAILABLE); return beliefF(I).marginal(ns); } } string ExactInf::identify() const { return string(Name) + printProperties(); } } // end of namespace dai libDAI-0.2.4/src/lc.cpp0000644000263000017630000002472111334764774013374 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include #include #include #include namespace dai { using namespace std; const char *LC::Name = "LC"; void LC::setProperties( const PropertySet &opts ) { DAI_ASSERT( opts.hasKey("tol") ); DAI_ASSERT( opts.hasKey("maxiter") ); DAI_ASSERT( opts.hasKey("verbose") ); DAI_ASSERT( opts.hasKey("cavity") ); DAI_ASSERT( opts.hasKey("updates") ); props.tol = opts.getStringAs("tol"); props.maxiter = opts.getStringAs("maxiter"); props.verbose = opts.getStringAs("verbose"); props.cavity = opts.getStringAs("cavity"); props.updates = opts.getStringAs("updates"); if( opts.hasKey("cavainame") ) props.cavainame = opts.getStringAs("cavainame"); if( opts.hasKey("cavaiopts") ) props.cavaiopts = opts.getStringAs("cavaiopts"); if( opts.hasKey("reinit") ) props.reinit = opts.getStringAs("reinit"); if( opts.hasKey("damping") ) props.damping = opts.getStringAs("damping"); else props.damping = 0.0; } PropertySet LC::getProperties() const { PropertySet opts; opts.Set( "tol", props.tol ); opts.Set( "maxiter", props.maxiter ); opts.Set( "verbose", props.verbose ); opts.Set( "cavity", props.cavity ); opts.Set( "updates", props.updates ); opts.Set( "cavainame", props.cavainame ); opts.Set( "cavaiopts", props.cavaiopts ); opts.Set( "reinit", props.reinit ); opts.Set( "damping", props.damping ); return opts; } string LC::printProperties() const { stringstream s( stringstream::out ); s << "["; s << "tol=" << props.tol << ","; s << "maxiter=" << props.maxiter << ","; s << "verbose=" << props.verbose << ","; s << "cavity=" << props.cavity << ","; s << "updates=" << props.updates << ","; s << "cavainame=" << props.cavainame << ","; s << "cavaiopts=" << props.cavaiopts << ","; s << "reinit=" << props.reinit << ","; s << "damping=" << props.damping << "]"; return s.str(); } LC::LC( const FactorGraph & fg, const PropertySet &opts ) : DAIAlgFG(fg), _pancakes(), _cavitydists(), _phis(), _beliefs(), _maxdiff(0.0), _iters(0), props() { setProperties( opts ); // create pancakes _pancakes.resize( nrVars() ); // create cavitydists for( size_t i=0; i < nrVars(); i++ ) _cavitydists.push_back(Factor( delta(i) )); // create phis _phis.reserve( nrVars() ); for( size_t i = 0; i < nrVars(); i++ ) { _phis.push_back( vector() ); _phis[i].reserve( nbV(i).size() ); foreach( const Neighbor &I, nbV(i) ) _phis[i].push_back( Factor( factor(I).vars() / var(i) ) ); } // create beliefs _beliefs.reserve( nrVars() ); for( size_t i=0; i < nrVars(); i++ ) _beliefs.push_back(Factor(var(i))); } string LC::identify() const { return string(Name) + printProperties(); } void LC::CalcBelief (size_t i) { _beliefs[i] = _pancakes[i].marginal(var(i)); } Real LC::CalcCavityDist (size_t i, const std::string &name, const PropertySet &opts) { Factor Bi; Real maxdiff = 0; if( props.verbose >= 2 ) cerr << "Initing cavity " << var(i) << "(" << delta(i).size() << " vars, " << delta(i).nrStates() << " states)" << endl; if( props.cavity == Properties::CavityType::UNIFORM ) Bi = Factor(delta(i)); else { InfAlg *cav = newInfAlg( name, *this, opts ); cav->makeCavity( i ); if( props.cavity == Properties::CavityType::FULL ) Bi = calcMarginal( *cav, cav->fg().delta(i), props.reinit ); else if( props.cavity == Properties::CavityType::PAIR ) { vector pairbeliefs = calcPairBeliefs( *cav, cav->fg().delta(i), props.reinit, false ); for( size_t ij = 0; ij < pairbeliefs.size(); ij++ ) Bi *= pairbeliefs[ij]; } else if( props.cavity == Properties::CavityType::PAIR2 ) { vector pairbeliefs = calcPairBeliefs( *cav, cav->fg().delta(i), props.reinit, true ); for( size_t ij = 0; ij < pairbeliefs.size(); ij++ ) Bi *= pairbeliefs[ij]; } maxdiff = cav->maxDiff(); delete cav; } Bi.normalize(); _cavitydists[i] = Bi; return maxdiff; } Real LC::InitCavityDists( const std::string &name, const PropertySet &opts ) { double tic = toc(); if( props.verbose >= 1 ) { cerr << Name << "::InitCavityDists: "; if( props.cavity == Properties::CavityType::UNIFORM ) cerr << "Using uniform initial cavity distributions" << endl; else if( props.cavity == Properties::CavityType::FULL ) cerr << "Using full " << name << opts << "..."; else if( props.cavity == Properties::CavityType::PAIR ) cerr << "Using pairwise " << name << opts << "..."; else if( props.cavity == Properties::CavityType::PAIR2 ) cerr << "Using pairwise(new) " << name << opts << "..."; } Real maxdiff = 0.0; for( size_t i = 0; i < nrVars(); i++ ) { Real md = CalcCavityDist(i, name, opts); if( md > maxdiff ) maxdiff = md; } if( props.verbose >= 1 ) { cerr << Name << "::InitCavityDists used " << toc() - tic << " seconds." << endl; } return maxdiff; } long LC::SetCavityDists( std::vector &Q ) { if( props.verbose >= 1 ) cerr << Name << "::SetCavityDists: Setting initial cavity distributions" << endl; if( Q.size() != nrVars() ) return -1; for( size_t i = 0; i < nrVars(); i++ ) { if( _cavitydists[i].vars() != Q[i].vars() ) { return i+1; } else _cavitydists[i] = Q[i]; } return 0; } void LC::init() { for( size_t i = 0; i < nrVars(); ++i ) foreach( const Neighbor &I, nbV(i) ) if( props.updates == Properties::UpdateType::SEQRND ) _phis[i][I.iter].randomize(); else _phis[i][I.iter].fill(1.0); } Factor LC::NewPancake (size_t i, size_t _I, bool & hasNaNs) { size_t I = nbV(i)[_I]; Factor piet = _pancakes[i]; // recalculate _pancake[i] VarSet Ivars = factor(I).vars(); Factor A_I; for( VarSet::const_iterator k = Ivars.begin(); k != Ivars.end(); k++ ) if( var(i) != *k ) A_I *= (_pancakes[findVar(*k)] * factor(I).inverse()).marginal( Ivars / var(i), false ); if( Ivars.size() > 1 ) A_I ^= (1.0 / (Ivars.size() - 1)); Factor A_Ii = (_pancakes[i] * factor(I).inverse() * _phis[i][_I].inverse()).marginal( Ivars / var(i), false ); Factor quot = A_I / A_Ii; if( props.damping != 0.0 ) quot = (quot^(1.0 - props.damping)) * (_phis[i][_I]^props.damping); piet *= quot / _phis[i][_I].normalized(); _phis[i][_I] = quot.normalized(); piet.normalize(); if( piet.hasNaNs() ) { cerr << Name << "::NewPancake(" << i << ", " << _I << "): has NaNs!" << endl; hasNaNs = true; } return piet; } Real LC::run() { if( props.verbose >= 1 ) cerr << "Starting " << identify() << "..."; if( props.verbose >= 2 ) cerr << endl; double tic = toc(); Real md = InitCavityDists( props.cavainame, props.cavaiopts ); if( md > _maxdiff ) _maxdiff = md; for( size_t i = 0; i < nrVars(); i++ ) { _pancakes[i] = _cavitydists[i]; foreach( const Neighbor &I, nbV(i) ) { _pancakes[i] *= factor(I); if( props.updates == Properties::UpdateType::SEQRND ) _pancakes[i] *= _phis[i][I.iter]; } _pancakes[i].normalize(); CalcBelief(i); } vector oldBeliefsV; for( size_t i = 0; i < nrVars(); i++ ) oldBeliefsV.push_back( beliefV(i) ); bool hasNaNs = false; for( size_t i=0; i < nrVars(); i++ ) if( _pancakes[i].hasNaNs() ) { hasNaNs = true; break; } if( hasNaNs ) { cerr << Name << "::run: initial _pancakes has NaNs!" << endl; return 1.0; } size_t nredges = nrEdges(); vector update_seq; update_seq.reserve( nredges ); for( size_t i = 0; i < nrVars(); ++i ) foreach( const Neighbor &I, nbV(i) ) update_seq.push_back( Edge( i, I.iter ) ); // do several passes over the network until maximum number of iterations has // been reached or until the maximum belief difference is smaller than tolerance Real maxDiff = INFINITY; for( _iters = 0; _iters < props.maxiter && maxDiff > props.tol; _iters++ ) { // Sequential updates if( props.updates == Properties::UpdateType::SEQRND ) random_shuffle( update_seq.begin(), update_seq.end() ); for( size_t t=0; t < nredges; t++ ) { size_t i = update_seq[t].first; size_t _I = update_seq[t].second; _pancakes[i] = NewPancake( i, _I, hasNaNs); if( hasNaNs ) return 1.0; CalcBelief( i ); } // compare new beliefs with old ones maxDiff = -INFINITY; for( size_t i = 0; i < nrVars(); i++ ) { maxDiff = std::max( maxDiff, dist( beliefV(i), oldBeliefsV[i], Prob::DISTLINF ) ); oldBeliefsV[i] = beliefV(i); } if( props.verbose >= 3 ) cerr << Name << "::run: maxdiff " << maxDiff << " after " << _iters+1 << " passes" << endl; } if( maxDiff > _maxdiff ) _maxdiff = maxDiff; if( props.verbose >= 1 ) { if( maxDiff > props.tol ) { if( props.verbose == 1 ) cerr << endl; cerr << Name << "::run: WARNING: not converged within " << props.maxiter << " passes (" << toc() - tic << " seconds)...final maxdiff:" << maxDiff << endl; } else { if( props.verbose >= 2 ) cerr << Name << "::run: "; cerr << "converged in " << _iters << " passes (" << toc() - tic << " seconds)." << endl; } } return maxDiff; } } // end of namespace dai libDAI-0.2.4/src/mf.cpp0000644000263000017630000001271311334764774013376 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include #include #include namespace dai { using namespace std; const char *MF::Name = "MF"; void MF::setProperties( const PropertySet &opts ) { DAI_ASSERT( opts.hasKey("tol") ); DAI_ASSERT( opts.hasKey("maxiter") ); props.tol = opts.getStringAs("tol"); props.maxiter = opts.getStringAs("maxiter"); if( opts.hasKey("verbose") ) props.verbose = opts.getStringAs("verbose"); else props.verbose = 0U; if( opts.hasKey("damping") ) props.damping = opts.getStringAs("damping"); else props.damping = 0.0; } PropertySet MF::getProperties() const { PropertySet opts; opts.Set( "tol", props.tol ); opts.Set( "maxiter", props.maxiter ); opts.Set( "verbose", props.verbose ); opts.Set( "damping", props.damping ); return opts; } string MF::printProperties() const { stringstream s( stringstream::out ); s << "["; s << "tol=" << props.tol << ","; s << "maxiter=" << props.maxiter << ","; s << "verbose=" << props.verbose << ","; s << "damping=" << props.damping << "]"; return s.str(); } void MF::construct() { // create beliefs _beliefs.clear(); _beliefs.reserve( nrVars() ); for( size_t i = 0; i < nrVars(); ++i ) _beliefs.push_back( Factor( var(i) ) ); } string MF::identify() const { return string(Name) + printProperties(); } void MF::init() { for( vector::iterator qi = _beliefs.begin(); qi != _beliefs.end(); qi++ ) qi->fill(1.0); } Factor MF::calcNewBelief( size_t i ) { Factor result; foreach( const Neighbor &I, nbV(i) ) { Factor henk; foreach( const Neighbor &j, nbF(I) ) // for all j in I \ i if( j != i ) henk *= _beliefs[j]; Factor piet = factor(I).log(true); piet *= henk; piet = piet.marginal(var(i), false); piet = piet.exp(); result *= piet; } result.normalize(); return result; } Real MF::run() { if( props.verbose >= 1 ) cerr << "Starting " << identify() << "..."; double tic = toc(); vector update_seq; update_seq.reserve( nrVars() ); for( size_t i = 0; i < nrVars(); i++ ) update_seq.push_back( i ); // do several passes over the network until maximum number of iterations has // been reached or until the maximum belief difference is smaller than tolerance Real maxDiff = INFINITY; for( _iters = 0; _iters < props.maxiter && maxDiff > props.tol; _iters++ ) { random_shuffle( update_seq.begin(), update_seq.end() ); maxDiff = -INFINITY; foreach( const size_t &i, update_seq ) { Factor nb = calcNewBelief( i ); if( nb.hasNaNs() ) { cerr << Name << "::run(): ERROR: new belief of variable " << var(i) << " has NaNs!" << endl; return 1.0; } if( props.damping != 0.0 ) nb = (nb^(1.0 - props.damping)) * (_beliefs[i]^props.damping); maxDiff = std::max( maxDiff, dist( nb, _beliefs[i], Prob::DISTLINF ) ); _beliefs[i] = nb; } if( props.verbose >= 3 ) cerr << Name << "::run: maxdiff " << maxDiff << " after " << _iters+1 << " passes" << endl; } if( maxDiff > _maxdiff ) _maxdiff = maxDiff; if( props.verbose >= 1 ) { if( maxDiff > props.tol ) { if( props.verbose == 1 ) cerr << endl; cerr << Name << "::run: WARNING: not converged within " << props.maxiter << " passes (" << toc() - tic << " seconds)...final maxdiff:" << maxDiff << endl; } else { if( props.verbose >= 3 ) cerr << Name << "::run: "; cerr << "converged in " << _iters << " passes (" << toc() - tic << " seconds)." << endl; } } return maxDiff; } Factor MF::beliefV( size_t i ) const { return _beliefs[i].normalized(); } Factor MF::belief (const VarSet &ns) const { if( ns.size() == 0 ) return Factor(); else if( ns.size() == 1 ) return beliefV( findVar( *(ns.begin()) ) ); else { DAI_THROW(BELIEF_NOT_AVAILABLE); return Factor(); } } vector MF::beliefs() const { vector result; for( size_t i = 0; i < nrVars(); i++ ) result.push_back( beliefV(i) ); return result; } Real MF::logZ() const { Real s = 0.0; for( size_t i = 0; i < nrVars(); i++ ) s -= beliefV(i).entropy(); for( size_t I = 0; I < nrFactors(); I++ ) { Factor henk; foreach( const Neighbor &j, nbF(I) ) // for all j in I henk *= _beliefs[j]; henk.normalize(); Factor piet; piet = factor(I).log(true); piet *= henk; s -= piet.sum(); } return -s; } void MF::init( const VarSet &ns ) { for( size_t i = 0; i < nrVars(); i++ ) { if( ns.contains(var(i) ) ) _beliefs[i].fill( 1.0 ); } } } // end of namespace dai libDAI-0.2.4/src/bipgraph.cpp0000644000263000017630000002756111334764774014577 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include namespace dai { using namespace std; void BipartiteGraph::addEdge( size_t n1, size_t n2, bool check ) { DAI_ASSERT( n1 < nrNodes1() ); DAI_ASSERT( n2 < nrNodes2() ); bool exists = false; if( check ) { // Check whether the edge already exists foreach( const Neighbor &nb2, nb1(n1) ) if( nb2 == n2 ) { exists = true; break; } } if( !exists ) { // Add edge Neighbor nb_1( nb1(n1).size(), n2, nb2(n2).size() ); Neighbor nb_2( nb_1.dual, n1, nb_1.iter ); nb1(n1).push_back( nb_1 ); nb2(n2).push_back( nb_2 ); } } void BipartiteGraph::eraseNode1( size_t n1 ) { DAI_ASSERT( n1 < nrNodes1() ); // Erase neighbor entry of node n1 _nb1.erase( _nb1.begin() + n1 ); // Adjust neighbor entries of nodes of type 2 for( size_t n2 = 0; n2 < nrNodes2(); n2++ ) { for( size_t iter = 0; iter < nb2(n2).size(); ) { Neighbor &m1 = nb2(n2, iter); if( m1.node == n1 ) { // delete this entry, because it points to the deleted node nb2(n2).erase( nb2(n2).begin() + iter ); } else if( m1.node > n1 ) { // update this entry and the corresponding dual of the neighboring node of type 1 m1.iter = iter; m1.node--; nb1( m1.node, m1.dual ).dual = iter; iter++; } else { // skip iter++; } } } } void BipartiteGraph::eraseNode2( size_t n2 ) { DAI_ASSERT( n2 < nrNodes2() ); // Erase neighbor entry of node n2 _nb2.erase( _nb2.begin() + n2 ); // Adjust neighbor entries of nodes of type 1 for( size_t n1 = 0; n1 < nrNodes1(); n1++ ) { for( size_t iter = 0; iter < nb1(n1).size(); ) { Neighbor &m2 = nb1(n1, iter); if( m2.node == n2 ) { // delete this entry, because it points to the deleted node nb1(n1).erase( nb1(n1).begin() + iter ); } else if( m2.node > n2 ) { // update this entry and the corresponding dual of the neighboring node of type 2 m2.iter = iter; m2.node--; nb2( m2.node, m2.dual ).dual = iter; iter++; } else { // skip iter++; } } } } void BipartiteGraph::eraseEdge( size_t n1, size_t n2 ) { DAI_ASSERT( n1 < nrNodes1() ); DAI_ASSERT( n2 < nrNodes2() ); size_t iter; // Search for edge among neighbors of n1 for( iter = 0; iter < nb1(n1).size(); iter++ ) if( nb1(n1, iter).node == n2 ) { // Remove it nb1(n1).erase( nb1(n1).begin() + iter ); break; } // Change the iter and dual values of the subsequent neighbors for( ; iter < nb1(n1).size(); iter++ ) { Neighbor &m2 = nb1( n1, iter ); m2.iter = iter; nb2( m2.node, m2.dual ).dual = iter; } // Search for edge among neighbors of n2 for( iter = 0; iter < nb2(n2).size(); iter++ ) if( nb2(n2, iter).node == n1 ) { // Remove it nb2(n2).erase( nb2(n2).begin() + iter ); break; } // Change the iter and node values of the subsequent neighbors for( ; iter < nb2(n2).size(); iter++ ) { Neighbor &m1 = nb2( n2, iter ); m1.iter = iter; nb1( m1.node, m1.dual ).dual = iter; } } std::vector BipartiteGraph::delta1( size_t n1, bool include ) const { // get all second-order neighbors std::vector result; foreach( const Neighbor &n2, nb1(n1) ) foreach( const Neighbor &m1, nb2(n2) ) if( include || (m1 != n1) ) result.push_back( m1 ); // remove duplicates std::vector::iterator it = std::unique( result.begin(), result.end() ); result.erase( it, result.end() ); return result; } std::vector BipartiteGraph::delta2( size_t n2, bool include ) const { // store all second-order neighbors std::vector result; foreach( const Neighbor &n1, nb2(n2) ) foreach( const Neighbor &m2, nb1(n1) ) if( include || (m2 != n2) ) result.push_back( m2 ); // remove duplicates std::vector::iterator it = std::unique( result.begin(), result.end() ); result.erase( it, result.end() ); return result; } bool BipartiteGraph::isConnected() const { if( nrNodes1() == 0 ) { return true; } else { /* // The BGL implementation is significantly slower... using namespace boost; typedef adjacency_list< vecS, vecS, undirectedS, property > boostGraph; typedef pair E; // Copy graph structure into boostGraph object size_t N = nrNodes1(); vector edges; edges.reserve( nrEdges() ); for( size_t n1 = 0; n1 < nrNodes1(); n1++ ) foreach( const Neighbor &n2, nb1(n1) ) edges.push_back( E( n1, n2.node + N ) ); boostGraph g( edges.begin(), edges.end(), nrNodes1() + nrNodes2() ); // Construct connected components using Boost Graph Library std::vector component( num_vertices( g ) ); int num_comp = connected_components( g, make_iterator_property_map(component.begin(), get(vertex_index, g)) ); return (num_comp == 1); */ std::vector incomponent1( nrNodes1(), false ); std::vector incomponent2( nrNodes2(), false ); incomponent1[0] = true; bool found_new_nodes; do { found_new_nodes = false; // For all nodes of type 2, check if they are connected with the (growing) component for( size_t n2 = 0; n2 < nrNodes2(); n2++ ) if( !incomponent2[n2] ) { foreach( const Neighbor &n1, nb2(n2) ) { if( incomponent1[n1] ) { found_new_nodes = true; incomponent2[n2] = true; break; } } } // For all nodes of type 1, check if they are connected with the (growing) component for( size_t n1 = 0; n1 < nrNodes1(); n1++ ) if( !incomponent1[n1] ) { foreach( const Neighbor &n2, nb1(n1) ) { if( incomponent2[n2] ) { found_new_nodes = true; incomponent1[n1] = true; break; } } } } while( found_new_nodes ); // Check if there are remaining nodes (not in the component) bool all_connected = true; for( size_t n1 = 0; (n1 < nrNodes1()) && all_connected; n1++ ) if( !incomponent1[n1] ) all_connected = false; for( size_t n2 = 0; (n2 < nrNodes2()) && all_connected; n2++ ) if( !incomponent2[n2] ) all_connected = false; return all_connected; } } bool BipartiteGraph::isTree() const { using namespace std; vector levels; bool foundCycle = false; size_t nr_1 = 0; size_t nr_2 = 0; if( nrNodes1() == 0 || nrNodes2() == 0 ) return true; else { levelType newLevel; do { newLevel.ind1.clear(); newLevel.ind2.clear(); if( levels.size() == 0 ) { size_t n1 = 0; // add n1 to ind1 newLevel.ind1 = vector( 1, n1 ); // add all neighbors of n1 to ind2 newLevel.ind2.reserve( nb1(n1).size() ); foreach( const Neighbor &n2, nb1(n1) ) newLevel.ind2.push_back( n2 ); } else { const levelType &prevLevel = levels.back(); // build newLevel.ind1 foreach( size_t n2, prevLevel.ind2 ) { // for all n2 in the previous level foreach( const Neighbor &n1, nb2(n2) ) { // for all neighbors n1 of n2 if( find( prevLevel.ind1.begin(), prevLevel.ind1.end(), n1 ) == prevLevel.ind1.end() ) { // n1 not in previous level if( find( newLevel.ind1.begin(), newLevel.ind1.end(), n1 ) != newLevel.ind1.end() ) foundCycle = true; // n1 already in new level: we found a cycle else newLevel.ind1.push_back( n1 ); // add n1 to new level } if( foundCycle ) break; } if( foundCycle ) break; } // build newLevel.ind2 foreach( size_t n1, newLevel.ind1 ) { // for all n1 in this level foreach( const Neighbor &n2, nb1(n1) ) { // for all neighbors n2 of n1 if( find( prevLevel.ind2.begin(), prevLevel.ind2.end(), n2 ) == prevLevel.ind2.end() ) { // n2 not in previous level if( find( newLevel.ind2.begin(), newLevel.ind2.end(), n2 ) != newLevel.ind2.end() ) foundCycle = true; // n2 already in new level: we found a cycle else newLevel.ind2.push_back( n2 ); // add n2 to new level } if( foundCycle ) break; } if( foundCycle ) break; } } levels.push_back( newLevel ); nr_1 += newLevel.ind1.size(); nr_2 += newLevel.ind2.size(); } while( ((newLevel.ind1.size() != 0) || (newLevel.ind2.size() != 0)) && !foundCycle ); if( nr_1 == nrNodes1() && nr_2 == nrNodes2() && !foundCycle ) return true; else return false; } } void BipartiteGraph::printDot( std::ostream& os ) const { using namespace std; os << "graph G {" << endl; os << "node[shape=circle,width=0.4,fixedsize=true];" << endl; for( size_t n1 = 0; n1 < nrNodes1(); n1++ ) os << "\tx" << n1 << ";" << endl; os << "node[shape=box,width=0.3,height=0.3,fixedsize=true];" << endl; for( size_t n2 = 0; n2 < nrNodes2(); n2++ ) os << "\ty" << n2 << ";" << endl; for( size_t n1 = 0; n1 < nrNodes1(); n1++ ) foreach( const Neighbor &n2, nb1(n1) ) os << "\tx" << n1 << " -- y" << n2 << ";" << endl; os << "}" << endl; } void BipartiteGraph::checkConsistency() const { size_t N1 = nrNodes1(); size_t N2 = nrNodes2(); for( size_t n1 = 0; n1 < N1; n1++ ) { size_t iter = 0; foreach( const Neighbor &n2, nb1(n1) ) { DAI_ASSERT( n2.iter == iter ); DAI_ASSERT( n2.node < N2 ); DAI_ASSERT( n2.dual < nb2(n2).size() ); DAI_ASSERT( nb2(n2, n2.dual) == n1 ); iter++; } } for( size_t n2 = 0; n2 < N2; n2++ ) { size_t iter = 0; foreach( const Neighbor &n1, nb2(n2) ) { DAI_ASSERT( n1.iter == iter ); DAI_ASSERT( n1.node < N1 ); DAI_ASSERT( n1.dual < nb1(n1).size() ); DAI_ASSERT( nb1(n1, n1.dual) == n2 ); iter++; } } } } // end of namespace dai libDAI-0.2.4/src/cbp.cpp0000644000263000017630000005526711334764774013553 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Frederik Eaton [frederik at ofb dot net] */ #include #include #include #include #include #include #include #include #include #include #include namespace dai { using namespace std; using boost::shared_ptr; const char *CBP::Name = "CBP"; /// Given a sorted vector of states \a xis and total state count \a n_states, return a vector of states not in \a xis vector complement( vector &xis, size_t n_states ) { vector cmp_xis( 0 ); size_t j = 0; for( size_t xi = 0; xi < n_states; xi++ ) { while( j < xis.size() && xis[j] < xi ) j++; if( j >= xis.size() || xis[j] > xi ) cmp_xis.push_back(xi); } DAI_ASSERT( xis.size()+cmp_xis.size() == n_states ); return cmp_xis; } /// Computes \f$\frac{\exp(a)}{\exp(a)+\exp(b)}\f$ Real unSoftMax( Real a, Real b ) { if( a > b ) return 1.0 / (1.0 + exp(b-a)); else return exp(a-b) / (exp(a-b) + 1.0); } /// Computes log of sum of exponents, i.e., \f$\log\left(\exp(a) + \exp(b)\right)\f$ Real logSumExp( Real a, Real b ) { if( a > b ) return a + log1p( exp( b-a ) ); else return b + log1p( exp( a-b ) ); } /// Compute sum of pairwise L-infinity distances of the first \a nv factors in each vector Real dist( const vector &b1, const vector &b2, size_t nv ) { Real d = 0.0; for( size_t k = 0; k < nv; k++ ) d += dist( b1[k], b2[k], Prob::DISTLINF ); return d; } void CBP::setBeliefs( const std::vector &bs, Real logZ ) { size_t i = 0; _beliefsV.clear(); _beliefsV.reserve( nrVars() ); _beliefsF.clear(); _beliefsF.reserve( nrFactors() ); for( i = 0; i < nrVars(); i++ ) _beliefsV.push_back( bs[i] ); for( ; i < nrVars() + nrFactors(); i++ ) _beliefsF.push_back( bs[i] ); _logZ = logZ; } void CBP::construct() { _beliefsV.clear(); _beliefsV.reserve(nrVars()); for( size_t i = 0; i < nrVars(); i++ ) _beliefsV.push_back( Factor(var(i)).normalized() ); _beliefsF.clear(); _beliefsF.reserve(nrFactors()); for( size_t I = 0; I < nrFactors(); I++ ) { Factor f = factor(I); f.fill(1); f.normalize(); _beliefsF.push_back( f ); } // to compute average level _sum_level = 0; _num_leaves = 0; _maxdiff = 0; _iters = 0; if( props.clamp_outfile.length() > 0 ) { _clamp_ofstream = shared_ptr(new ofstream( props.clamp_outfile.c_str(), ios_base::out|ios_base::trunc )); *_clamp_ofstream << "# COUNT LEVEL VAR STATE" << endl; } } /// Calculates a vector of mixtures p * b + (1-p) * c static vector mixBeliefs( Real p, const vector &b, const vector &c ) { vector out; DAI_ASSERT( b.size() == c.size() ); out.reserve( b.size() ); Real pc = 1 - p; for( size_t i = 0; i < b.size(); i++ ) // probably already normalized, but do it again just in case out.push_back( b[i].normalized() * p + c[i].normalized() * pc ); return out; } Real CBP::run() { size_t seed = props.rand_seed; if( seed > 0 ) rnd_seed( seed ); InfAlg *bp = getInfAlg(); bp->init(); bp->run(); _iters += bp->Iterations(); vector beliefs_out; Real lz_out; size_t choose_count=0; runRecurse( bp, bp->logZ(), vector(0), _num_leaves, choose_count, _sum_level, lz_out, beliefs_out ); if( props.verbose >= 1 ) cerr << "CBP average levels = " << (_sum_level / _num_leaves) << ", leaves = " << _num_leaves << endl; setBeliefs( beliefs_out, lz_out ); return 0.0; } InfAlg* CBP::getInfAlg() { PropertySet bpProps; bpProps.Set("updates", props.updates); bpProps.Set("tol", props.tol); bpProps.Set("maxiter", props.maxiter); bpProps.Set("verbose", props.verbose); bpProps.Set("logdomain", false); bpProps.Set("damping", (Real)0.0); BP *bp = new BP( *this, bpProps ); bp->recordSentMessages = true; bp->init(); return bp; } void CBP::runRecurse( InfAlg *bp, Real orig_logZ, vector clamped_vars_list, size_t &num_leaves, size_t &choose_count, Real &sum_level, Real &lz_out, vector& beliefs_out) { // choose a variable/states to clamp: size_t i; vector xis; Real maxVar = 0.0; bool found; bool clampingVar = (props.clamp == Properties::ClampType::CLAMP_VAR); if( props.recursion == Properties::RecurseType::REC_LOGZ && props.rec_tol > 0 && exp( bp->logZ() - orig_logZ ) < props.rec_tol ) found = false; else found = chooseNextClampVar( bp, clamped_vars_list, i, xis, &maxVar ); if( !found ) { num_leaves++; sum_level += clamped_vars_list.size(); beliefs_out = bp->beliefs(); lz_out = bp->logZ(); return; } choose_count++; if( props.clamp_outfile.length() > 0 ) *_clamp_ofstream << choose_count << "\t" << clamped_vars_list.size() << "\t" << i << "\t" << xis[0] << endl; if( clampingVar ) foreach( size_t xi, xis ) DAI_ASSERT(/*0<=xi &&*/ xi < var(i).states() ); else foreach( size_t xI, xis ) DAI_ASSERT(/*0<=xI &&*/ xI < factor(i).states() ); // - otherwise, clamp and recurse, saving margin estimates for each // clamp setting. afterwards, combine estimates. // compute complement of 'xis' vector cmp_xis = complement( xis, clampingVar ? var(i).states() : factor(i).states() ); /// \idea dai::CBP::runRecurse() could be implemented more efficiently with a nesting version of backupFactors/restoreFactors // this improvement could also be done locally: backup the clamped factor in a local variable, // and restore it just before we return. Real lz; vector b; InfAlg *bp_c = bp->clone(); if( clampingVar ) { bp_c->fg().clampVar( i, xis ); bp_c->init( var(i) ); } else { bp_c->fg().clampFactor( i, xis ); bp_c->init( factor(i).vars() ); } bp_c->run(); _iters += bp_c->Iterations(); lz = bp_c->logZ(); b = bp_c->beliefs(); Real cmp_lz; vector cmp_b; InfAlg *cmp_bp_c = bp->clone(); if( clampingVar ) { cmp_bp_c->fg().clampVar( i, cmp_xis ); cmp_bp_c->init(var(i)); } else { cmp_bp_c->fg().clampFactor( i, cmp_xis ); cmp_bp_c->init( factor(i).vars() ); } cmp_bp_c->run(); _iters += cmp_bp_c->Iterations(); cmp_lz = cmp_bp_c->logZ(); cmp_b = cmp_bp_c->beliefs(); Real p = unSoftMax( lz, cmp_lz ); Real bp__d = 0.0; if( props.recursion == Properties::RecurseType::REC_BDIFF && props.rec_tol > 0 ) { vector combined_b( mixBeliefs( p, b, cmp_b ) ); Real new_lz = logSumExp( lz,cmp_lz ); bp__d = dist( bp->beliefs(), combined_b, nrVars() ); if( exp( new_lz - orig_logZ) * bp__d < props.rec_tol ) { num_leaves++; sum_level += clamped_vars_list.size(); beliefs_out = combined_b; lz_out = new_lz; return; } } // either we are not doing REC_BDIFF or the distance was large // enough to recurse: runRecurse( bp_c, orig_logZ, clamped_vars_list, num_leaves, choose_count, sum_level, lz, b ); runRecurse( cmp_bp_c, orig_logZ, clamped_vars_list, num_leaves, choose_count, sum_level, cmp_lz, cmp_b ); p = unSoftMax( lz, cmp_lz ); beliefs_out = mixBeliefs( p, b, cmp_b ); lz_out = logSumExp( lz, cmp_lz ); if( props.verbose >= 2 ) { Real d = dist( bp->beliefs(), beliefs_out, nrVars() ); cerr << "Distance (clamping " << i << "): " << d; if( props.recursion == Properties::RecurseType::REC_BDIFF ) cerr << "; bp_dual predicted " << bp__d; cerr << "; max_adjoint = " << maxVar << "; logZ = " << lz_out << " (in " << bp->logZ() << ") (orig " << orig_logZ << "); p = " << p << "; level = " << clamped_vars_list.size() << endl; } delete bp_c; delete cmp_bp_c; } // 'xis' must be sorted bool CBP::chooseNextClampVar( InfAlg *bp, vector &clamped_vars_list, size_t &i, vector &xis, Real *maxVarOut ) { Real tiny = 1.0e-14; if( props.verbose >= 3 ) cerr << "clamped_vars_list" << clamped_vars_list << endl; if( clamped_vars_list.size() >= props.max_levels ) return false; if( props.choose == Properties::ChooseMethodType::CHOOSE_RANDOM ) { if( props.clamp == Properties::ClampType::CLAMP_VAR ) { int t = 0, t1 = 100; do { i = rnd( nrVars() ); t++; } while( abs( bp->beliefV(i).p().max() - 1) < tiny && t < t1 ); if( t == t1 ) { return false; // die("Too many levels requested in CBP"); } // only pick probable values for variable size_t xi; do { xi = rnd( var(i).states() ); t++; } while( bp->beliefV(i).p()[xi] < tiny && t < t1 ); DAI_ASSERT( t < t1 ); xis.resize( 1, xi ); // DAI_ASSERT(!_clamped_vars.count(i)); // not true for >2-ary variables DAI_IFVERB(2, "CHOOSE_RANDOM at level " << clamped_vars_list.size() << " chose variable " << i << " state " << xis[0] << endl); } else { int t = 0, t1 = 100; do { i = rnd( nrFactors() ); t++; } while( abs( bp->beliefF(i).p().max() - 1) < tiny && t < t1 ); if( t == t1 ) return false; // die("Too many levels requested in CBP"); // only pick probable values for variable size_t xi; do { xi = rnd( factor(i).states() ); t++; } while( bp->beliefF(i).p()[xi] < tiny && t < t1 ); DAI_ASSERT( t < t1 ); xis.resize( 1, xi ); // DAI_ASSERT(!_clamped_vars.count(i)); // not true for >2-ary variables DAI_IFVERB(2, endl<<"CHOOSE_RANDOM chose factor "<beliefV(k).entropy(); if( max_ent < ent ) { max_ent = ent; win_k = k; win_xk = bp->beliefV(k).p().argmax().first; } } DAI_ASSERT( win_k >= 0 ); DAI_ASSERT( win_xk >= 0 ); i = win_k; xis.resize( 1, win_xk ); DAI_IFVERB(2, endl<<"CHOOSE_MAXENT chose variable "<beliefV(i).p()[xis[0]] < tiny ) { DAI_IFVERB(2, "Warning: CHOOSE_MAXENT found unlikely state, not recursing"); return false; } } else { Real max_ent = -1.0; int win_k = -1, win_xk = -1; for( size_t k = 0; k < nrFactors(); k++ ) { Real ent = bp->beliefF(k).entropy(); if( max_ent < ent ) { max_ent = ent; win_k = k; win_xk = bp->beliefF(k).p().argmax().first; } } DAI_ASSERT( win_k >= 0 ); DAI_ASSERT( win_xk >= 0 ); i = win_k; xis.resize( 1, win_xk ); DAI_IFVERB(2, endl<<"CHOOSE_MAXENT chose factor "<beliefF(i).p()[xis[0]] < tiny ) { DAI_IFVERB(2, "Warning: CHOOSE_MAXENT found unlikely state, not recursing"); return false; } } } else if( props.choose==Properties::ChooseMethodType::CHOOSE_BP_L1 || props.choose==Properties::ChooseMethodType::CHOOSE_BP_CFN ) { bool doL1 = (props.choose == Properties::ChooseMethodType::CHOOSE_BP_L1); vector state; if( !doL1 && props.bbp_cfn.needGibbsState() ) state = getGibbsState( bp->fg(), 2*bp->Iterations() ); // try clamping each variable manually DAI_ASSERT( props.clamp == Properties::ClampType::CLAMP_VAR ); Real max_cost = 0.0; int win_k = -1, win_xk = -1; for( size_t k = 0; k < nrVars(); k++ ) { for( size_t xk = 0; xk < var(k).states(); xk++ ) { if( bp->beliefV(k)[xk] < tiny ) continue; InfAlg *bp1 = bp->clone(); bp1->clamp( k, xk ); bp1->init( var(k) ); bp1->run(); Real cost = 0; if( doL1 ) for( size_t j = 0; j < nrVars(); j++ ) cost += dist( bp->beliefV(j), bp1->beliefV(j), Prob::DISTL1 ); else cost = props.bbp_cfn.evaluate( *bp1, &state ); if( cost > max_cost || win_k == -1 ) { max_cost = cost; win_k = k; win_xk = xk; } delete bp1; } } DAI_ASSERT( win_k >= 0 ); DAI_ASSERT( win_xk >= 0 ); i = win_k; xis.resize( 1, win_xk ); } else if( props.choose == Properties::ChooseMethodType::CHOOSE_BBP ) { Real mvo; if( !maxVarOut ) maxVarOut = &mvo; bool clampingVar = (props.clamp == Properties::ClampType::CLAMP_VAR); pair cv = BBPFindClampVar( *bp, clampingVar, props.bbp_props, props.bbp_cfn, &mvo ); // if slope isn't big enough then don't clamp if( mvo < props.min_max_adj ) return false; size_t xi = cv.second; i = cv.first; #define VAR_INFO (clampingVar?"variable ":"factor ") \ << i << " state " << xi \ << " (p=" << (clampingVar?bp->beliefV(i)[xi]:bp->beliefF(i)[xi]) \ << ", entropy = " << (clampingVar?bp->beliefV(i):bp->beliefF(i)).entropy() \ << ", maxVar = "<< mvo << ")" Prob b = ( clampingVar ? bp->beliefV(i).p() : bp->beliefF(i).p()); if( b[xi] < tiny ) { cerr << "Warning, at level " << clamped_vars_list.size() << ", BBPFindClampVar found unlikely " << VAR_INFO << endl; return false; } if( abs(b[xi] - 1) < tiny ) { cerr << "Warning at level " << clamped_vars_list.size() << ", BBPFindClampVar found overly likely " << VAR_INFO << endl; return false; } xis.resize( 1, xi ); if( clampingVar ) DAI_ASSERT(/*0<=xi &&*/ xi < var(i).states() ); else DAI_ASSERT(/*0<=xi &&*/ xi < factor(i).states() ); DAI_IFVERB(2, "CHOOSE_BBP (num clamped = " << clamped_vars_list.size() << ") chose " << i << " state " << xi << endl); } else DAI_THROW(UNKNOWN_ENUM_VALUE); clamped_vars_list.push_back( i ); return true; } void CBP::printDebugInfo() { DAI_PV(_beliefsV); DAI_PV(_beliefsF); DAI_PV(_logZ); } pair BBPFindClampVar( const InfAlg &in_bp, bool clampingVar, const PropertySet &bbp_props, const BBPCostFunction &cfn, Real *maxVarOut ) { BBP bbp( &in_bp, bbp_props ); bbp.initCostFnAdj( cfn, NULL ); bbp.run(); // find and return the (variable,state) with the largest adj_psi_V size_t argmax_var = 0; size_t argmax_var_state = 0; Real max_var = 0; if( clampingVar ) { for( size_t i = 0; i < in_bp.fg().nrVars(); i++ ) { Prob adj_psi_V = bbp.adj_psi_V(i); if(0) { // helps to account for amount of movement possible in variable // i's beliefs? seems not.. adj_psi_V *= in_bp.beliefV(i).entropy(); } if(0){ // adj_psi_V *= Prob(in_bp.fg().var(i).states(),1.0)-in_bp.beliefV(i).p(); adj_psi_V *= in_bp.beliefV(i).p(); } // try to compensate for effect on same variable (doesn't work) // adj_psi_V[gibbs.state()[i]] -= bp_dual.beliefV(i)[gibbs.state()[i]]/10; pair argmax_state = adj_psi_V.argmax(); if( i == 0 || argmax_state.second > max_var ) { argmax_var = i; max_var = argmax_state.second; argmax_var_state = argmax_state.first; } } DAI_ASSERT(/*0 <= argmax_var_state &&*/ argmax_var_state < in_bp.fg().var(argmax_var).states() ); } else { for( size_t I = 0; I < in_bp.fg().nrFactors(); I++ ) { Prob adj_psi_F = bbp.adj_psi_F(I); if(0) { // helps to account for amount of movement possible in variable // i's beliefs? seems not.. adj_psi_F *= in_bp.beliefF(I).entropy(); } // try to compensate for effect on same variable (doesn't work) // adj_psi_V[gibbs.state()[i]] -= bp_dual.beliefV(i)[gibbs.state()[i]]/10; pair argmax_state = adj_psi_F.argmax(); if( I == 0 || argmax_state.second > max_var ) { argmax_var = I; max_var = argmax_state.second; argmax_var_state = argmax_state.first; } } DAI_ASSERT(/*0 <= argmax_var_state &&*/ argmax_var_state < in_bp.fg().factor(argmax_var).states() ); } if( maxVarOut ) *maxVarOut = max_var; return make_pair( argmax_var, argmax_var_state ); } } // end of namespace dai /* {{{ GENERATED CODE: DO NOT EDIT. Created by ./scripts/regenerate-properties include/dai/cbp.h src/cbp.cpp */ namespace dai { void CBP::Properties::set(const PropertySet &opts) { const std::set &keys = opts.keys(); std::string errormsg; for( std::set::const_iterator i = keys.begin(); i != keys.end(); i++ ) { if( *i == "verbose" ) continue; if( *i == "tol" ) continue; if( *i == "updates" ) continue; if( *i == "maxiter" ) continue; if( *i == "rec_tol" ) continue; if( *i == "max_levels" ) continue; if( *i == "min_max_adj" ) continue; if( *i == "choose" ) continue; if( *i == "recursion" ) continue; if( *i == "clamp" ) continue; if( *i == "bbp_props" ) continue; if( *i == "bbp_cfn" ) continue; if( *i == "rand_seed" ) continue; if( *i == "clamp_outfile" ) continue; errormsg = errormsg + "CBP: Unknown property " + *i + "\n"; } if( !errormsg.empty() ) DAI_THROWE(UNKNOWN_PROPERTY, errormsg); if( !opts.hasKey("tol") ) errormsg = errormsg + "CBP: Missing property \"tol\" for method \"CBP\"\n"; if( !opts.hasKey("updates") ) errormsg = errormsg + "CBP: Missing property \"updates\" for method \"CBP\"\n"; if( !opts.hasKey("maxiter") ) errormsg = errormsg + "CBP: Missing property \"maxiter\" for method \"CBP\"\n"; if( !opts.hasKey("rec_tol") ) errormsg = errormsg + "CBP: Missing property \"rec_tol\" for method \"CBP\"\n"; if( !opts.hasKey("min_max_adj") ) errormsg = errormsg + "CBP: Missing property \"min_max_adj\" for method \"CBP\"\n"; if( !opts.hasKey("choose") ) errormsg = errormsg + "CBP: Missing property \"choose\" for method \"CBP\"\n"; if( !opts.hasKey("recursion") ) errormsg = errormsg + "CBP: Missing property \"recursion\" for method \"CBP\"\n"; if( !opts.hasKey("clamp") ) errormsg = errormsg + "CBP: Missing property \"clamp\" for method \"CBP\"\n"; if( !opts.hasKey("bbp_props") ) errormsg = errormsg + "CBP: Missing property \"bbp_props\" for method \"CBP\"\n"; if( !opts.hasKey("bbp_cfn") ) errormsg = errormsg + "CBP: Missing property \"bbp_cfn\" for method \"CBP\"\n"; if( !errormsg.empty() ) DAI_THROWE(NOT_ALL_PROPERTIES_SPECIFIED,errormsg); if( opts.hasKey("verbose") ) { verbose = opts.getStringAs("verbose"); } else { verbose = 0; } tol = opts.getStringAs("tol"); updates = opts.getStringAs("updates"); maxiter = opts.getStringAs("maxiter"); rec_tol = opts.getStringAs("rec_tol"); if( opts.hasKey("max_levels") ) { max_levels = opts.getStringAs("max_levels"); } else { max_levels = 10; } min_max_adj = opts.getStringAs("min_max_adj"); choose = opts.getStringAs("choose"); recursion = opts.getStringAs("recursion"); clamp = opts.getStringAs("clamp"); bbp_props = opts.getStringAs("bbp_props"); bbp_cfn = opts.getStringAs("bbp_cfn"); if( opts.hasKey("rand_seed") ) { rand_seed = opts.getStringAs("rand_seed"); } else { rand_seed = 0; } if( opts.hasKey("clamp_outfile") ) { clamp_outfile = opts.getStringAs("clamp_outfile"); } else { clamp_outfile = ""; } } PropertySet CBP::Properties::get() const { PropertySet opts; opts.Set("verbose", verbose); opts.Set("tol", tol); opts.Set("updates", updates); opts.Set("maxiter", maxiter); opts.Set("rec_tol", rec_tol); opts.Set("max_levels", max_levels); opts.Set("min_max_adj", min_max_adj); opts.Set("choose", choose); opts.Set("recursion", recursion); opts.Set("clamp", clamp); opts.Set("bbp_props", bbp_props); opts.Set("bbp_cfn", bbp_cfn); opts.Set("rand_seed", rand_seed); opts.Set("clamp_outfile", clamp_outfile); return opts; } string CBP::Properties::toString() const { stringstream s(stringstream::out); s << "["; s << "verbose=" << verbose << ","; s << "tol=" << tol << ","; s << "updates=" << updates << ","; s << "maxiter=" << maxiter << ","; s << "rec_tol=" << rec_tol << ","; s << "max_levels=" << max_levels << ","; s << "min_max_adj=" << min_max_adj << ","; s << "choose=" << choose << ","; s << "recursion=" << recursion << ","; s << "clamp=" << clamp << ","; s << "bbp_props=" << bbp_props << ","; s << "bbp_cfn=" << bbp_cfn << ","; s << "rand_seed=" << rand_seed << ","; s << "clamp_outfile=" << clamp_outfile; s << "]"; return s.str(); } } // end of namespace dai /* }}} END OF GENERATED CODE */ libDAI-0.2.4/src/regiongraph.cpp0000644000263000017630000001755211334764774015307 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include #include #include namespace dai { using namespace std; void RegionGraph::construct( const FactorGraph &fg, const std::vector &ors, const std::vector &irs, const std::vector > &edges ) { // Copy factor graph structure FactorGraph::operator=( fg ); // Copy inner regions IRs = irs; // Construct outer regions (giving them counting number 1.0) ORs.clear(); ORs.reserve( ors.size() ); foreach( const VarSet &alpha, ors ) ORs.push_back( FRegion(Factor(alpha, 1.0), 1.0) ); // For each factor, find an outer region that subsumes that factor. // Then, multiply the outer region with that factor. fac2OR.clear(); fac2OR.reserve( nrFactors() ); for( size_t I = 0; I < nrFactors(); I++ ) { size_t alpha; for( alpha = 0; alpha < nrORs(); alpha++ ) if( OR(alpha).vars() >> factor(I).vars() ) { fac2OR.push_back( alpha ); break; } DAI_ASSERT( alpha != nrORs() ); } RecomputeORs(); // Create bipartite graph G.construct( nrORs(), nrIRs(), edges.begin(), edges.end() ); } void RegionGraph::constructCVM( const FactorGraph &fg, const std::vector &cl ) { // Retain only maximal clusters ClusterGraph cg( cl ); cg.eraseNonMaximal(); // Create inner regions - first pass set betas; for( size_t alpha = 0; alpha < cg.clusters.size(); alpha++ ) for( size_t alpha2 = alpha; (++alpha2) != cg.clusters.size(); ) { VarSet intersection = cg.clusters[alpha] & cg.clusters[alpha2]; if( intersection.size() > 0 ) betas.insert( intersection ); } // Create inner regions - subsequent passes set new_betas; do { new_betas.clear(); for( set::const_iterator gamma = betas.begin(); gamma != betas.end(); gamma++ ) for( set::const_iterator gamma2 = gamma; (++gamma2) != betas.end(); ) { VarSet intersection = (*gamma) & (*gamma2); if( (intersection.size() > 0) && (betas.count(intersection) == 0) ) new_betas.insert( intersection ); } betas.insert(new_betas.begin(), new_betas.end()); } while( new_betas.size() ); // Create inner regions - final phase vector irs; irs.reserve( betas.size() ); for( set::const_iterator beta = betas.begin(); beta != betas.end(); beta++ ) irs.push_back( Region(*beta,0.0) ); // Create edges vector > edges; for( size_t beta = 0; beta < irs.size(); beta++ ) for( size_t alpha = 0; alpha < cg.clusters.size(); alpha++ ) if( cg.clusters[alpha] >> irs[beta] ) edges.push_back( pair(alpha,beta) ); // Construct region graph construct( fg, cg.clusters, irs, edges ); // Calculate counting numbers calcCountingNumbers(); } RegionGraph::RegionGraph( const FactorGraph &fg, const std::vector &ors, const std::vector &irs, const std::vector > &edges ) { vector ors_alt; ors_alt.reserve( ors.size() ); for( size_t alpha = 0; alpha < ors.size(); alpha++ ) { ors_alt.push_back( ors[alpha] ); DAI_ASSERT( ors[alpha].c() == 1.0 ); } construct( fg, ors_alt, irs, edges ); // Check counting numbers #ifdef DAI_DEBUG checkCountingNumbers(); #endif } void RegionGraph::calcCountingNumbers() { // Calculates counting numbers of inner regions based upon counting numbers of outer regions vector > ancestors(nrIRs()); boost::dynamic_bitset<> assigned(nrIRs()); for( size_t beta = 0; beta < nrIRs(); beta++ ) { IR(beta).c() = 0.0; for( size_t beta2 = 0; beta2 < nrIRs(); beta2++ ) if( (beta2 != beta) && IR(beta2) >> IR(beta) ) ancestors[beta].push_back(beta2); } bool new_counting; do { new_counting = false; for( size_t beta = 0; beta < nrIRs(); beta++ ) { if( !assigned[beta] ) { bool has_unassigned_ancestor = false; for( vector::const_iterator beta2 = ancestors[beta].begin(); (beta2 != ancestors[beta].end()) && !has_unassigned_ancestor; beta2++ ) if( !assigned[*beta2] ) has_unassigned_ancestor = true; if( !has_unassigned_ancestor ) { Real c = 1.0; foreach( const Neighbor &alpha, nbIR(beta) ) c -= OR(alpha).c(); for( vector::const_iterator beta2 = ancestors[beta].begin(); beta2 != ancestors[beta].end(); beta2++ ) c -= IR(*beta2).c(); IR(beta).c() = c; assigned.set(beta, true); new_counting = true; } } } } while( new_counting ); } bool RegionGraph::checkCountingNumbers() const { // Checks whether the counting numbers satisfy the fundamental relation bool all_valid = true; for( vector::const_iterator n = vars().begin(); n != vars().end(); n++ ) { Real c_n = 0.0; for( size_t alpha = 0; alpha < nrORs(); alpha++ ) if( OR(alpha).vars().contains( *n ) ) c_n += OR(alpha).c(); for( size_t beta = 0; beta < nrIRs(); beta++ ) if( IR(beta).contains( *n ) ) c_n += IR(beta).c(); if( fabs(c_n - 1.0) > 1e-15 ) { all_valid = false; cerr << "WARNING: counting numbers do not satisfy relation for " << *n << "(c_n = " << c_n << ")." << endl; } } return all_valid; } void RegionGraph::RecomputeORs() { for( size_t alpha = 0; alpha < nrORs(); alpha++ ) OR(alpha).fill( 1.0 ); for( size_t I = 0; I < nrFactors(); I++ ) if( fac2OR[I] != -1U ) OR( fac2OR[I] ) *= factor( I ); } void RegionGraph::RecomputeORs( const VarSet &ns ) { for( size_t alpha = 0; alpha < nrORs(); alpha++ ) if( OR(alpha).vars().intersects( ns ) ) OR(alpha).fill( 1.0 ); for( size_t I = 0; I < nrFactors(); I++ ) if( fac2OR[I] != -1U ) if( OR( fac2OR[I] ).vars().intersects( ns ) ) OR( fac2OR[I] ) *= factor( I ); } void RegionGraph::RecomputeOR( size_t I ) { DAI_ASSERT( I < nrFactors() ); if( fac2OR[I] != -1U ) { size_t alpha = fac2OR[I]; OR(alpha).fill( 1.0 ); for( size_t J = 0; J < nrFactors(); J++ ) if( fac2OR[J] == alpha ) OR(alpha) *= factor( J ); } } /// Send RegionGraph to output stream ostream & operator << (ostream & os, const RegionGraph & rg) { os << "Outer regions" << endl; for( size_t alpha = 0; alpha < rg.nrORs(); alpha++ ) os << alpha << ": " << rg.OR(alpha).vars() << ": c = " << rg.OR(alpha).c() << endl; os << "Inner regions" << endl; for( size_t beta = 0; beta < rg.nrIRs(); beta++ ) os << beta << ": " << (VarSet)rg.IR(beta) << ": c = " << rg.IR(beta).c() << endl; os << "Edges" << endl; for( size_t alpha = 0; alpha < rg.nrORs(); alpha++ ) foreach( const RegionGraph::Neighbor &beta, rg.nbOR(alpha) ) os << alpha << "->" << beta << endl; return(os); } } // end of namespace dai libDAI-0.2.4/src/bp.cpp0000644000263000017630000004375411334764774013406 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include #include #include #include #include #include namespace dai { using namespace std; const char *BP::Name = "BP"; #define DAI_BP_FAST 1 void BP::setProperties( const PropertySet &opts ) { DAI_ASSERT( opts.hasKey("tol") ); DAI_ASSERT( opts.hasKey("maxiter") ); DAI_ASSERT( opts.hasKey("logdomain") ); DAI_ASSERT( opts.hasKey("updates") ); props.tol = opts.getStringAs("tol"); props.maxiter = opts.getStringAs("maxiter"); props.logdomain = opts.getStringAs("logdomain"); props.updates = opts.getStringAs("updates"); if( opts.hasKey("verbose") ) props.verbose = opts.getStringAs("verbose"); else props.verbose = 0; if( opts.hasKey("damping") ) props.damping = opts.getStringAs("damping"); else props.damping = 0.0; if( opts.hasKey("inference") ) props.inference = opts.getStringAs("inference"); else props.inference = Properties::InfType::SUMPROD; } PropertySet BP::getProperties() const { PropertySet opts; opts.Set( "tol", props.tol ); opts.Set( "maxiter", props.maxiter ); opts.Set( "verbose", props.verbose ); opts.Set( "logdomain", props.logdomain ); opts.Set( "updates", props.updates ); opts.Set( "damping", props.damping ); opts.Set( "inference", props.inference ); return opts; } string BP::printProperties() const { stringstream s( stringstream::out ); s << "["; s << "tol=" << props.tol << ","; s << "maxiter=" << props.maxiter << ","; s << "verbose=" << props.verbose << ","; s << "logdomain=" << props.logdomain << ","; s << "updates=" << props.updates << ","; s << "damping=" << props.damping << ","; s << "inference=" << props.inference << "]"; return s.str(); } void BP::construct() { // create edge properties _edges.clear(); _edges.reserve( nrVars() ); _edge2lut.clear(); if( props.updates == Properties::UpdateType::SEQMAX ) _edge2lut.reserve( nrVars() ); for( size_t i = 0; i < nrVars(); ++i ) { _edges.push_back( vector() ); _edges[i].reserve( nbV(i).size() ); if( props.updates == Properties::UpdateType::SEQMAX ) { _edge2lut.push_back( vector() ); _edge2lut[i].reserve( nbV(i).size() ); } foreach( const Neighbor &I, nbV(i) ) { EdgeProp newEP; newEP.message = Prob( var(i).states() ); newEP.newMessage = Prob( var(i).states() ); if( DAI_BP_FAST ) { newEP.index.reserve( factor(I).states() ); for( IndexFor k( var(i), factor(I).vars() ); k.valid(); ++k ) newEP.index.push_back( k ); } newEP.residual = 0.0; _edges[i].push_back( newEP ); if( props.updates == Properties::UpdateType::SEQMAX ) _edge2lut[i].push_back( _lut.insert( make_pair( newEP.residual, make_pair( i, _edges[i].size() - 1 ))) ); } } } void BP::init() { Real c = props.logdomain ? 0.0 : 1.0; for( size_t i = 0; i < nrVars(); ++i ) { foreach( const Neighbor &I, nbV(i) ) { message( i, I.iter ).fill( c ); newMessage( i, I.iter ).fill( c ); if( props.updates == Properties::UpdateType::SEQMAX ) updateResidual( i, I.iter, 0.0 ); } } } void BP::findMaxResidual( size_t &i, size_t &_I ) { DAI_ASSERT( !_lut.empty() ); LutType::const_iterator largestEl = _lut.end(); --largestEl; i = largestEl->second.first; _I = largestEl->second.second; } Prob BP::calcIncomingMessageProduct( size_t I, bool without_i, size_t i ) const { Factor Fprod( factor(I) ); Prob &prod = Fprod.p(); if( props.logdomain ) prod.takeLog(); // Calculate product of incoming messages and factor I foreach( const Neighbor &j, nbF(I) ) if( !(without_i && (j == i)) ) { // prod_j will be the product of messages coming into j Prob prod_j( var(j).states(), props.logdomain ? 0.0 : 1.0 ); foreach( const Neighbor &J, nbV(j) ) if( J != I ) { // for all J in nb(j) \ I if( props.logdomain ) prod_j += message( j, J.iter ); else prod_j *= message( j, J.iter ); } // multiply prod with prod_j if( !DAI_BP_FAST ) { // UNOPTIMIZED (SIMPLE TO READ, BUT SLOW) VERSION if( props.logdomain ) Fprod += Factor( var(j), prod_j ); else Fprod *= Factor( var(j), prod_j ); } else { // OPTIMIZED VERSION size_t _I = j.dual; // ind is the precalculated IndexFor(j,I) i.e. to x_I == k corresponds x_j == ind[k] const ind_t &ind = index(j, _I); for( size_t r = 0; r < prod.size(); ++r ) if( props.logdomain ) prod[r] += prod_j[ind[r]]; else prod[r] *= prod_j[ind[r]]; } } return prod; } void BP::calcNewMessage( size_t i, size_t _I ) { // calculate updated message I->i size_t I = nbV(i,_I); Prob marg; if( factor(I).vars().size() == 1 ) // optimization marg = factor(I).p(); else { Factor Fprod( factor(I) ); Prob &prod = Fprod.p(); prod = calcIncomingMessageProduct( I, true, i ); if( props.logdomain ) { prod -= prod.max(); prod.takeExp(); } // Marginalize onto i if( !DAI_BP_FAST ) { /* UNOPTIMIZED (SIMPLE TO READ, BUT SLOW) VERSION */ if( props.inference == Properties::InfType::SUMPROD ) marg = Fprod.marginal( var(i) ).p(); else marg = Fprod.maxMarginal( var(i) ).p(); } else { /* OPTIMIZED VERSION */ marg = Prob( var(i).states(), 0.0 ); // ind is the precalculated IndexFor(i,I) i.e. to x_I == k corresponds x_i == ind[k] const ind_t ind = index(i,_I); if( props.inference == Properties::InfType::SUMPROD ) for( size_t r = 0; r < prod.size(); ++r ) marg[ind[r]] += prod[r]; else for( size_t r = 0; r < prod.size(); ++r ) if( prod[r] > marg[ind[r]] ) marg[ind[r]] = prod[r]; marg.normalize(); } } // Store result if( props.logdomain ) newMessage(i,_I) = marg.log(); else newMessage(i,_I) = marg; // Update the residual if necessary if( props.updates == Properties::UpdateType::SEQMAX ) updateResidual( i, _I , dist( newMessage( i, _I ), message( i, _I ), Prob::DISTLINF ) ); } // BP::run does not check for NANs for performance reasons // Somehow NaNs do not often occur in BP... Real BP::run() { if( props.verbose >= 1 ) cerr << "Starting " << identify() << "..."; if( props.verbose >= 3) cerr << endl; double tic = toc(); Real maxDiff = INFINITY; vector oldBeliefsV, oldBeliefsF; oldBeliefsV.reserve( nrVars() ); for( size_t i = 0; i < nrVars(); ++i ) oldBeliefsV.push_back( beliefV(i) ); oldBeliefsF.reserve( nrFactors() ); for( size_t I = 0; I < nrFactors(); ++I ) oldBeliefsF.push_back( beliefF(I) ); size_t nredges = nrEdges(); vector update_seq; if( props.updates == Properties::UpdateType::SEQMAX ) { // do the first pass for( size_t i = 0; i < nrVars(); ++i ) foreach( const Neighbor &I, nbV(i) ) calcNewMessage( i, I.iter ); } else { update_seq.reserve( nredges ); for( size_t I = 0; I < nrFactors(); I++ ) foreach( const Neighbor &i, nbF(I) ) update_seq.push_back( Edge( i, i.dual ) ); } // do several passes over the network until maximum number of iterations has // been reached or until the maximum belief difference is smaller than tolerance for( _iters=0; _iters < props.maxiter && maxDiff > props.tol; ++_iters ) { if( props.updates == Properties::UpdateType::SEQMAX ) { // Residuals-BP by Koller et al. for( size_t t = 0; t < nredges; ++t ) { // update the message with the largest residual size_t i, _I; findMaxResidual( i, _I ); updateMessage( i, _I ); // I->i has been updated, which means that residuals for all // J->j with J in nb[i]\I and j in nb[J]\i have to be updated foreach( const Neighbor &J, nbV(i) ) { if( J.iter != _I ) { foreach( const Neighbor &j, nbF(J) ) { size_t _J = j.dual; if( j != i ) calcNewMessage( j, _J ); } } } } } else if( props.updates == Properties::UpdateType::PARALL ) { // Parallel updates for( size_t i = 0; i < nrVars(); ++i ) foreach( const Neighbor &I, nbV(i) ) calcNewMessage( i, I.iter ); for( size_t i = 0; i < nrVars(); ++i ) foreach( const Neighbor &I, nbV(i) ) updateMessage( i, I.iter ); } else { // Sequential updates if( props.updates == Properties::UpdateType::SEQRND ) random_shuffle( update_seq.begin(), update_seq.end() ); foreach( const Edge &e, update_seq ) { calcNewMessage( e.first, e.second ); updateMessage( e.first, e.second ); } } // calculate new beliefs and compare with old ones maxDiff = -INFINITY; for( size_t i = 0; i < nrVars(); ++i ) { Factor b( beliefV(i) ); maxDiff = std::max( maxDiff, dist( b, oldBeliefsV[i], Prob::DISTLINF ) ); oldBeliefsV[i] = b; } for( size_t I = 0; I < nrFactors(); ++I ) { Factor b( beliefF(I) ); maxDiff = std::max( maxDiff, dist( b, oldBeliefsF[I], Prob::DISTLINF ) ); oldBeliefsF[I] = b; } if( props.verbose >= 3 ) cerr << Name << "::run: maxdiff " << maxDiff << " after " << _iters+1 << " passes" << endl; } if( maxDiff > _maxdiff ) _maxdiff = maxDiff; if( props.verbose >= 1 ) { if( maxDiff > props.tol ) { if( props.verbose == 1 ) cerr << endl; cerr << Name << "::run: WARNING: not converged within " << props.maxiter << " passes (" << toc() - tic << " seconds)...final maxdiff:" << maxDiff << endl; } else { if( props.verbose >= 3 ) cerr << Name << "::run: "; cerr << "converged in " << _iters << " passes (" << toc() - tic << " seconds)." << endl; } } return maxDiff; } void BP::calcBeliefV( size_t i, Prob &p ) const { p = Prob( var(i).states(), props.logdomain ? 0.0 : 1.0 ); foreach( const Neighbor &I, nbV(i) ) if( props.logdomain ) p += newMessage( i, I.iter ); else p *= newMessage( i, I.iter ); } Factor BP::beliefV( size_t i ) const { Prob p; calcBeliefV( i, p ); if( props.logdomain ) { p -= p.max(); p.takeExp(); } p.normalize(); return( Factor( var(i), p ) ); } Factor BP::beliefF( size_t I ) const { Prob p; calcBeliefF( I, p ); if( props.logdomain ) { p -= p.max(); p.takeExp(); } p.normalize(); return( Factor( factor(I).vars(), p ) ); } vector BP::beliefs() const { vector result; for( size_t i = 0; i < nrVars(); ++i ) result.push_back( beliefV(i) ); for( size_t I = 0; I < nrFactors(); ++I ) result.push_back( beliefF(I) ); return result; } Factor BP::belief( const VarSet &ns ) const { if( ns.size() == 0 ) return Factor(); else if( ns.size() == 1 ) return beliefV( findVar( *(ns.begin() ) ) ); else { size_t I; for( I = 0; I < nrFactors(); I++ ) if( factor(I).vars() >> ns ) break; if( I == nrFactors() ) DAI_THROW(BELIEF_NOT_AVAILABLE); return beliefF(I).marginal(ns); } } Real BP::logZ() const { Real sum = 0.0; for( size_t i = 0; i < nrVars(); ++i ) sum += (1.0 - nbV(i).size()) * beliefV(i).entropy(); for( size_t I = 0; I < nrFactors(); ++I ) sum -= dist( beliefF(I), factor(I), Prob::DISTKL ); return sum; } string BP::identify() const { return string(Name) + printProperties(); } void BP::init( const VarSet &ns ) { for( VarSet::const_iterator n = ns.begin(); n != ns.end(); ++n ) { size_t ni = findVar( *n ); foreach( const Neighbor &I, nbV( ni ) ) { Real val = props.logdomain ? 0.0 : 1.0; message( ni, I.iter ).fill( val ); newMessage( ni, I.iter ).fill( val ); if( props.updates == Properties::UpdateType::SEQMAX ) updateResidual( ni, I.iter, 0.0 ); } } } void BP::updateMessage( size_t i, size_t _I ) { if( recordSentMessages ) _sentMessages.push_back(make_pair(i,_I)); if( props.damping == 0.0 ) { message(i,_I) = newMessage(i,_I); if( props.updates == Properties::UpdateType::SEQMAX ) updateResidual( i, _I, 0.0 ); } else { if( props.logdomain ) message(i,_I) = (message(i,_I) * props.damping) + (newMessage(i,_I) * (1.0 - props.damping)); else message(i,_I) = (message(i,_I) ^ props.damping) * (newMessage(i,_I) ^ (1.0 - props.damping)); if( props.updates == Properties::UpdateType::SEQMAX ) updateResidual( i, _I, dist( newMessage(i,_I), message(i,_I), Prob::DISTLINF ) ); } } void BP::updateResidual( size_t i, size_t _I, Real r ) { EdgeProp* pEdge = &_edges[i][_I]; pEdge->residual = r; // rearrange look-up table (delete and reinsert new key) _lut.erase( _edge2lut[i][_I] ); _edge2lut[i][_I] = _lut.insert( make_pair( r, make_pair(i, _I) ) ); } std::vector BP::findMaximum() const { vector maximum( nrVars() ); vector visitedVars( nrVars(), false ); vector visitedFactors( nrFactors(), false ); stack scheduledFactors; for( size_t i = 0; i < nrVars(); ++i ) { if( visitedVars[i] ) continue; visitedVars[i] = true; // Maximise with respect to variable i Prob prod; calcBeliefV( i, prod ); maximum[i] = prod.argmax().first; foreach( const Neighbor &I, nbV(i) ) if( !visitedFactors[I] ) scheduledFactors.push(I); while( !scheduledFactors.empty() ){ size_t I = scheduledFactors.top(); scheduledFactors.pop(); if( visitedFactors[I] ) continue; visitedFactors[I] = true; // Evaluate if some neighboring variables still need to be fixed; if not, we're done bool allDetermined = true; foreach( const Neighbor &j, nbF(I) ) if( !visitedVars[j.node] ) { allDetermined = false; break; } if( allDetermined ) continue; // Calculate product of incoming messages on factor I Prob prod2; calcBeliefF( I, prod2 ); // The allowed configuration is restrained according to the variables assigned so far: // pick the argmax amongst the allowed states Real maxProb = numeric_limits::min(); State maxState( factor(I).vars() ); for( State s( factor(I).vars() ); s.valid(); ++s ){ // First, calculate whether this state is consistent with variables that // have been assigned already bool allowedState = true; foreach( const Neighbor &j, nbF(I) ) if( visitedVars[j.node] && maximum[j.node] != s(var(j.node)) ) { allowedState = false; break; } // If it is consistent, check if its probability is larger than what we have seen so far if( allowedState && prod2[s] > maxProb ) { maxState = s; maxProb = prod2[s]; } } // Decode the argmax foreach( const Neighbor &j, nbF(I) ) { if( visitedVars[j.node] ) { // We have already visited j earlier - hopefully our state is consistent if( maximum[j.node] != maxState(var(j.node)) && props.verbose >= 1 ) cerr << "BP::findMaximum - warning: maximum not consistent due to loops." << endl; } else { // We found a consistent state for variable j visitedVars[j.node] = true; maximum[j.node] = maxState( var(j.node) ); foreach( const Neighbor &J, nbV(j) ) if( !visitedFactors[J] ) scheduledFactors.push(J); } } } } return maximum; } } // end of namespace dai libDAI-0.2.4/src/mr.cpp0000644000263000017630000004610411334764774013413 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2007 Bastian Wemmenhove * Copyright (C) 2007-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include #include #include #include #include namespace dai { using namespace std; const char *MR::Name = "MR"; void MR::setProperties( const PropertySet &opts ) { DAI_ASSERT( opts.hasKey("tol") ); DAI_ASSERT( opts.hasKey("verbose") ); DAI_ASSERT( opts.hasKey("updates") ); DAI_ASSERT( opts.hasKey("inits") ); props.tol = opts.getStringAs("tol"); props.verbose = opts.getStringAs("verbose"); props.updates = opts.getStringAs("updates"); props.inits = opts.getStringAs("inits"); } PropertySet MR::getProperties() const { PropertySet opts; opts.Set( "tol", props.tol ); opts.Set( "verbose", props.verbose ); opts.Set( "updates", props.updates ); opts.Set( "inits", props.inits ); return opts; } string MR::printProperties() const { stringstream s( stringstream::out ); s << "["; s << "tol=" << props.tol << ","; s << "verbose=" << props.verbose << ","; s << "updates=" << props.updates << ","; s << "inits=" << props.inits << "]"; return s.str(); } void MR::init(size_t Nin, Real *_w, Real *_th) { size_t i,j; N = Nin; con.resize(N); nb.resize(N); tJ.resize(N); for(i=0; i > tJ_org; vector > nb_org; vector con_org; vector theta_org; vector xfield(N*kmax,0.0); vector rfield(N*kmax,0.0); vector Hfield(N,0.0); vector devs(N*kmax,0.0); vector devs2(N*kmax,0.0); vector dev(N,0.0); vector avmag(N,0.0); // save original tJ, nb nb_org = nb; tJ_org = tJ; con_org = con; theta_org = theta; maxdev = 0.0; for(cavity=0; cavity md ) md = fabs(devs[kmax*k+l]); devs2[kmax*k+l] = rinter-rfield[kmax*k+l]; rfield[kmax*k+l] = rfield[kmax*k+l]+devs2[kmax*k+l]*eps; if( fabs(devs2[kmax*k+l]) > md ) md = fabs(devs2[kmax*k+l]); } } } } while((md > props.tol)&&(runx BP and RP finished if(runx==runs) if( props.verbose >= 2 ) cerr << "init_cor_resp: Convergence not reached (md=" << md << ")..." << endl; if(md > maxdev) maxdev = md; // compute the observables (i.e. magnetizations and responses)****** for(size_t i=0; i= maxdev ) maxdev = fabs(dev); newM = M[i][_j] + dev; if( fabs(newM) > 1.0 ) newM = sign(newM); M[i][_j] = newM; } } } while((maxdev>props.tol)&&(run _maxdiff ) _maxdiff = maxdev; if(run==maxruns){ if( props.verbose >= 1 ) cerr << "solve_mcav: Convergence not reached (maxdev=" << maxdev << ")..." << endl; } } void MR::solveM() { for(size_t i=0; i1.) Mag[i] = sign(Mag[i]); } } Real MR::init_cor() { Real md = 0.0; for( size_t i = 0; i < nrVars(); i++ ) { vector pairq; if( props.inits == Properties::InitType::CLAMPING ) { BP bpcav(*this, PropertySet()("updates", string("SEQMAX"))("tol", (Real)1.0e-9)("maxiter", (size_t)10000)("verbose", (size_t)0)("logdomain", false)); bpcav.makeCavity( i ); pairq = calcPairBeliefs( bpcav, delta(i), false, true ); md = std::max( md, bpcav.maxDiff() ); } else if( props.inits == Properties::InitType::EXACT ) { JTree jtcav(*this, PropertySet()("updates", string("HUGIN"))("verbose", (size_t)0) ); jtcav.makeCavity( i ); pairq = calcPairBeliefs( jtcav, delta(i), false, true ); } for( size_t jk = 0; jk < pairq.size(); jk++ ) { VarSet::const_iterator kit = pairq[jk].vars().begin(); size_t j = findVar( *(kit) ); size_t k = findVar( *(++kit) ); pairq[jk].normalize(); Real cor = (pairq[jk][3] - pairq[jk][2] - pairq[jk][1] + pairq[jk][0]) - (pairq[jk][3] + pairq[jk][2] - pairq[jk][1] - pairq[jk][0]) * (pairq[jk][3] - pairq[jk][2] + pairq[jk][1] - pairq[jk][0]); for( size_t _j = 0; _j < con[i]; _j++ ) if( nb[i][_j] == j ) for( size_t _k = 0; _k < con[i]; _k++ ) if( nb[i][_k] == k ) { cors[i][_j][_k] = cor; cors[i][_k][_j] = cor; } } } return md; } string MR::identify() const { return string(Name) + printProperties(); } Real MR::run() { if( supported ) { if( props.verbose >= 1 ) cerr << "Starting " << identify() << "..."; double tic = toc(); M.resize(N); for(size_t i=0; i _maxdiff ) _maxdiff = md; } else if( props.inits == Properties::InitType::EXACT ) { Real md = init_cor(); if( md > _maxdiff ) _maxdiff = md; } else if( props.inits == Properties::InitType::CLAMPING ) { Real md = init_cor(); if( md > _maxdiff ) _maxdiff = md; } solvemcav(); Mag.resize(N); solveM(); if( props.verbose >= 1 ) cerr << Name << " needed " << toc() - tic << " seconds." << endl; return _maxdiff; } else return 1.0; } void MR::makekindex() { for(size_t i=0; i MR::beliefs() const { vector result; for( size_t i = 0; i < nrVars(); i++ ) result.push_back( belief( var(i) ) ); return result; } MR::MR( const FactorGraph &fg, const PropertySet &opts ) : DAIAlgFG(fg), supported(true), _maxdiff(0.0), _iters(0) { setProperties( opts ); // check whether all vars in fg are binary // check whether connectivity is <= kmax for( size_t i = 0; i < fg.nrVars(); i++ ) if( (fg.var(i).states() > 2) || (fg.delta(i).size() > kmax) ) { supported = false; break; } if( !supported ) DAI_THROWE(NOT_IMPLEMENTED,"MR only supports binary variables with low connectivity"); // check whether all interactions are pairwise or single for( size_t I = 0; I < fg.nrFactors(); I++ ) if( fg.factor(I).vars().size() > 2 ) { supported = false; break; } if( !supported ) DAI_THROWE(NOT_IMPLEMENTED,"MR does not support higher order interactions (only single and pairwise are supported)"); // create w and th size_t Nin = fg.nrVars(); Real *w = new Real[Nin*Nin]; Real *th = new Real[Nin]; for( size_t i = 0; i < Nin; i++ ) { th[i] = 0.0; for( size_t j = 0; j < Nin; j++ ) w[i*Nin+j] = 0.0; } for( size_t I = 0; I < fg.nrFactors(); I++ ) { const Factor &psi = fg.factor(I); if( psi.vars().size() == 1 ) { size_t i = fg.findVar( *(psi.vars().begin()) ); th[i] += 0.5 * log(psi[1] / psi[0]); } else if( psi.vars().size() == 2 ) { size_t i = fg.findVar( *(psi.vars().begin()) ); VarSet::const_iterator jit = psi.vars().begin(); size_t j = fg.findVar( *(++jit) ); w[i*Nin+j] += 0.25 * log(psi[3] * psi[0] / (psi[2] * psi[1])); w[j*Nin+i] += 0.25 * log(psi[3] * psi[0] / (psi[2] * psi[1])); th[i] += 0.25 * log(psi[3] / psi[2] * psi[1] / psi[0]); th[j] += 0.25 * log(psi[3] / psi[1] * psi[2] / psi[0]); } } init(Nin, w, th); delete th; delete w; } } // end of namespace dai libDAI-0.2.4/src/factorgraph.cpp0000644000263000017630000003252211334764774015274 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include #include #include #include #include #include #include #include #include #include namespace dai { using namespace std; FactorGraph::FactorGraph( const std::vector &P ) : G(), _backup() { // add factors, obtain variables set varset; _factors.reserve( P.size() ); size_t nrEdges = 0; for( vector::const_iterator p2 = P.begin(); p2 != P.end(); p2++ ) { _factors.push_back( *p2 ); copy( p2->vars().begin(), p2->vars().end(), inserter( varset, varset.begin() ) ); nrEdges += p2->vars().size(); } // add vars _vars.reserve( varset.size() ); for( set::const_iterator p1 = varset.begin(); p1 != varset.end(); p1++ ) _vars.push_back( *p1 ); // create graph structure constructGraph( nrEdges ); } void FactorGraph::constructGraph( size_t nrEdges ) { // create a mapping for indices hash_map hashmap; for( size_t i = 0; i < vars().size(); i++ ) hashmap[var(i).label()] = i; // create edge list vector edges; edges.reserve( nrEdges ); for( size_t i2 = 0; i2 < nrFactors(); i2++ ) { const VarSet& ns = factor(i2).vars(); for( VarSet::const_iterator q = ns.begin(); q != ns.end(); q++ ) edges.push_back( Edge(hashmap[q->label()], i2) ); } // create bipartite graph G.construct( nrVars(), nrFactors(), edges.begin(), edges.end() ); } /// Writes a FactorGraph to an output stream std::ostream& operator<< ( std::ostream &os, const FactorGraph &fg ) { os << fg.nrFactors() << endl; for( size_t I = 0; I < fg.nrFactors(); I++ ) { os << endl; os << fg.factor(I).vars().size() << endl; for( VarSet::const_iterator i = fg.factor(I).vars().begin(); i != fg.factor(I).vars().end(); i++ ) os << i->label() << " "; os << endl; for( VarSet::const_iterator i = fg.factor(I).vars().begin(); i != fg.factor(I).vars().end(); i++ ) os << i->states() << " "; os << endl; size_t nr_nonzeros = 0; for( size_t k = 0; k < fg.factor(I).states(); k++ ) if( fg.factor(I)[k] != (Real)0 ) nr_nonzeros++; os << nr_nonzeros << endl; for( size_t k = 0; k < fg.factor(I).states(); k++ ) if( fg.factor(I)[k] != (Real)0 ) os << k << " " << setw(os.precision()+4) << fg.factor(I)[k] << endl; } return(os); } /// Reads a FactorGraph from an input stream std::istream& operator>> ( std::istream& is, FactorGraph &fg ) { long verbose = 0; vector facs; size_t nr_Factors; string line; while( (is.peek()) == '#' ) getline(is,line); is >> nr_Factors; if( is.fail() ) DAI_THROWE(INVALID_FACTORGRAPH_FILE,"Cannot read number of factors"); if( verbose >= 2 ) cerr << "Reading " << nr_Factors << " factors..." << endl; getline (is,line); if( is.fail() || line.size() > 0 ) DAI_THROWE(INVALID_FACTORGRAPH_FILE,"Expecting empty line"); map vardims; for( size_t I = 0; I < nr_Factors; I++ ) { if( verbose >= 3 ) cerr << "Reading factor " << I << "..." << endl; size_t nr_members; while( (is.peek()) == '#' ) getline(is,line); is >> nr_members; if( verbose >= 3 ) cerr << " nr_members: " << nr_members << endl; vector labels; for( size_t mi = 0; mi < nr_members; mi++ ) { long mi_label; while( (is.peek()) == '#' ) getline(is,line); is >> mi_label; labels.push_back(mi_label); } if( verbose >= 3 ) cerr << " labels: " << labels << endl; vector dims; for( size_t mi = 0; mi < nr_members; mi++ ) { size_t mi_dim; while( (is.peek()) == '#' ) getline(is,line); is >> mi_dim; dims.push_back(mi_dim); } if( verbose >= 3 ) cerr << " dimensions: " << dims << endl; // add the Factor vector Ivars; Ivars.reserve( nr_members ); for( size_t mi = 0; mi < nr_members; mi++ ) { map::iterator vdi = vardims.find( labels[mi] ); if( vdi != vardims.end() ) { // check whether dimensions are consistent if( vdi->second != dims[mi] ) DAI_THROWE(INVALID_FACTORGRAPH_FILE,"Variable with label " + boost::lexical_cast(labels[mi]) + " has inconsistent dimensions."); } else vardims[labels[mi]] = dims[mi]; Ivars.push_back( Var(labels[mi], dims[mi]) ); } facs.push_back( Factor( VarSet( Ivars.begin(), Ivars.end(), Ivars.size() ), (Real)0 ) ); // calculate permutation object Permute permindex( Ivars ); // read values size_t nr_nonzeros; while( (is.peek()) == '#' ) getline(is,line); is >> nr_nonzeros; if( verbose >= 3 ) cerr << " nonzeroes: " << nr_nonzeros << endl; for( size_t k = 0; k < nr_nonzeros; k++ ) { size_t li; Real val; while( (is.peek()) == '#' ) getline(is,line); is >> li; while( (is.peek()) == '#' ) getline(is,line); is >> val; // store value, but permute indices first according to internal representation facs.back()[permindex.convertLinearIndex( li )] = val; } } if( verbose >= 3 ) cerr << "factors:" << facs << endl; fg = FactorGraph(facs); return is; } VarSet FactorGraph::delta( size_t i ) const { return( Delta(i) / var(i) ); } VarSet FactorGraph::Delta( size_t i ) const { // calculate Markov Blanket VarSet Del; foreach( const Neighbor &I, nbV(i) ) // for all neighboring factors I of i foreach( const Neighbor &j, nbF(I) ) // for all neighboring variables j of I Del |= var(j); return Del; } VarSet FactorGraph::Delta( const VarSet &ns ) const { VarSet result; for( VarSet::const_iterator n = ns.begin(); n != ns.end(); n++ ) result |= Delta(findVar(*n)); return result; } void FactorGraph::makeCavity( size_t i, bool backup ) { // fills all Factors that include var(i) with ones map newFacs; foreach( const Neighbor &I, nbV(i) ) // for all neighboring factors I of i newFacs[I] = Factor( factor(I).vars(), (Real)1 ); setFactors( newFacs, backup ); } void FactorGraph::ReadFromFile( const char *filename ) { ifstream infile; infile.open( filename ); if( infile.is_open() ) { infile >> *this; infile.close(); } else DAI_THROWE(CANNOT_READ_FILE,"Cannot read from file " + std::string(filename)); } void FactorGraph::WriteToFile( const char *filename, size_t precision ) const { ofstream outfile; outfile.open( filename ); if( outfile.is_open() ) { outfile.precision( precision ); outfile << *this; outfile.close(); } else DAI_THROWE(CANNOT_WRITE_FILE,"Cannot write to file " + std::string(filename)); } void FactorGraph::printDot( std::ostream &os ) const { os << "graph G {" << endl; os << "node[shape=circle,width=0.4,fixedsize=true];" << endl; for( size_t i = 0; i < nrVars(); i++ ) os << "\tv" << var(i).label() << ";" << endl; os << "node[shape=box,width=0.3,height=0.3,fixedsize=true];" << endl; for( size_t I = 0; I < nrFactors(); I++ ) os << "\tf" << I << ";" << endl; for( size_t i = 0; i < nrVars(); i++ ) foreach( const Neighbor &I, nbV(i) ) // for all neighboring factors I of i os << "\tv" << var(i).label() << " -- f" << I << ";" << endl; os << "}" << endl; } vector FactorGraph::Cliques() const { vector result; for( size_t I = 0; I < nrFactors(); I++ ) { bool maximal = true; for( size_t J = 0; (J < nrFactors()) && maximal; J++ ) if( (factor(J).vars() >> factor(I).vars()) && (factor(J).vars() != factor(I).vars()) ) maximal = false; if( maximal ) result.push_back( factor(I).vars() ); } return result; } void FactorGraph::clamp( size_t i, size_t x, bool backup ) { DAI_ASSERT( x <= var(i).states() ); Factor mask( var(i), (Real)0 ); mask[x] = (Real)1; map newFacs; foreach( const Neighbor &I, nbV(i) ) newFacs[I] = factor(I) * mask; setFactors( newFacs, backup ); return; } void FactorGraph::clampVar( size_t i, const vector &is, bool backup ) { Var n = var(i); Factor mask_n( n, (Real)0 ); foreach( size_t i, is ) { DAI_ASSERT( i <= n.states() ); mask_n[i] = (Real)1; } map newFacs; foreach( const Neighbor &I, nbV(i) ) newFacs[I] = factor(I) * mask_n; setFactors( newFacs, backup ); } void FactorGraph::clampFactor( size_t I, const vector &is, bool backup ) { size_t st = factor(I).states(); Factor newF( factor(I).vars(), (Real)0 ); foreach( size_t i, is ) { DAI_ASSERT( i <= st ); newF[i] = factor(I)[i]; } setFactor( I, newF, backup ); } void FactorGraph::backupFactor( size_t I ) { map::iterator it = _backup.find( I ); if( it != _backup.end() ) DAI_THROW(MULTIPLE_UNDO); _backup[I] = factor(I); } void FactorGraph::restoreFactor( size_t I ) { map::iterator it = _backup.find( I ); if( it != _backup.end() ) { setFactor(I, it->second); _backup.erase(it); } } void FactorGraph::backupFactors( const VarSet &ns ) { for( size_t I = 0; I < nrFactors(); I++ ) if( factor(I).vars().intersects( ns ) ) backupFactor( I ); } void FactorGraph::restoreFactors( const VarSet &ns ) { map facs; for( map::iterator uI = _backup.begin(); uI != _backup.end(); ) { if( factor(uI->first).vars().intersects( ns ) ) { facs.insert( *uI ); _backup.erase(uI++); } else uI++; } setFactors( facs ); } void FactorGraph::restoreFactors() { setFactors( _backup ); _backup.clear(); } void FactorGraph::backupFactors( const std::set & facs ) { for( std::set::const_iterator fac = facs.begin(); fac != facs.end(); fac++ ) backupFactor( *fac ); } bool FactorGraph::isPairwise() const { bool pairwise = true; for( size_t I = 0; I < nrFactors() && pairwise; I++ ) if( factor(I).vars().size() > 2 ) pairwise = false; return pairwise; } bool FactorGraph::isBinary() const { bool binary = true; for( size_t i = 0; i < nrVars() && binary; i++ ) if( var(i).states() > 2 ) binary = false; return binary; } FactorGraph FactorGraph::clamped( size_t i, size_t state ) const { Var v = var( i ); Real zeroth_order = (Real)1; vector clamped_facs; for( size_t I = 0; I < nrFactors(); I++ ) { VarSet v_I = factor(I).vars(); Factor new_factor; if( v_I.intersects( v ) ) new_factor = factor(I).slice( v, state ); else new_factor = factor(I); if( new_factor.vars().size() != 0 ) { size_t J = 0; // if it can be merged with a previous one, do that for( J = 0; J < clamped_facs.size(); J++ ) if( clamped_facs[J].vars() == new_factor.vars() ) { clamped_facs[J] *= new_factor; break; } // otherwise, push it back if( J == clamped_facs.size() || clamped_facs.size() == 0 ) clamped_facs.push_back( new_factor ); } else zeroth_order *= new_factor[0]; } *(clamped_facs.begin()) *= zeroth_order; return FactorGraph( clamped_facs ); } FactorGraph FactorGraph::maximalFactors() const { vector maxfac( nrFactors() ); map newindex; size_t nrmax = 0; for( size_t I = 0; I < nrFactors(); I++ ) { maxfac[I] = I; VarSet maxfacvars = factor(maxfac[I]).vars(); for( size_t J = 0; J < nrFactors(); J++ ) { VarSet Jvars = factor(J).vars(); if( Jvars >> maxfacvars && (Jvars != maxfacvars) ) { maxfac[I] = J; maxfacvars = factor(maxfac[I]).vars(); } } if( maxfac[I] == I ) newindex[I] = nrmax++; } vector facs( nrmax ); for( size_t I = 0; I < nrFactors(); I++ ) facs[newindex[maxfac[I]]] *= factor(I); return FactorGraph( facs.begin(), facs.end(), vars().begin(), vars().end(), facs.size(), nrVars() ); } } // end of namespace dai libDAI-0.2.4/src/properties.cpp0000644000263000017630000000643011334764774015167 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include namespace dai { std::ostream& operator<< (std::ostream & os, const Property & p) { os << p.first << "="; if( p.second.type() == typeid(size_t) ) os << boost::any_cast(p.second); else if( p.second.type() == typeid(std::string) ) os << boost::any_cast(p.second); else if( p.second.type() == typeid(double) ) os << boost::any_cast(p.second); else if( p.second.type() == typeid(long double) ) os << boost::any_cast(p.second); else if( p.second.type() == typeid(bool) ) os << boost::any_cast(p.second); else if( p.second.type() == typeid(PropertySet) ) os << boost::any_cast(p.second); else DAI_THROW(UNKNOWN_PROPERTY_TYPE); return( os ); } /// Writes a PropertySet object to an output stream std::ostream& operator<< (std::ostream & os, const PropertySet & ps) { os << "["; for( PropertySet::const_iterator p = ps.begin(); p != ps.end(); p++ ) { if( p != ps.begin() ) os << ","; os << (Property)*p; } os << "]"; return os; } /// Reads a PropertySet object from an input stream, storing values as strings std::istream& operator>> (std::istream& is, PropertySet & ps) { ps = PropertySet(); std::string s; is >> s; // Check whether s is of the form "[.*]" if( (s.length() < 2) || (s.at(0) != '[') || (s.at(s.length()-1)) != ']' ) DAI_THROWE(MALFORMED_PROPERTY,"Malformed PropertySet: " + s); size_t N = s.length() - 1; for( size_t token_start = 1; token_start < N; ) { size_t token_end; // scan until '=' is found for( token_end = token_start + 1; token_end < N; token_end++ ) if( s[token_end] == '=' ) break; // we found a key std::string key = s.substr(token_start, token_end - token_start); if( token_end == N ) DAI_THROWE(MALFORMED_PROPERTY,"Malformed Property: " + key); token_start = token_end + 1; // scan until matching ',' is found int level = 0; for( token_end = token_start; token_end < N; token_end++ ) { if( s[token_end] == '[' ) level++; else if( s[token_end] == ']' ) level--; else if( (s[token_end] == ',') && (level == 0) ) break; } if( !(level == 0) ) DAI_THROWE(MALFORMED_PROPERTY,"Malformed Property: " + s.substr(token_start, token_end - token_start)); // we found a vlue std::string value = s.substr(token_start, token_end - token_start); // store the key,value pair ps.Set(key,value); // go on with the next one token_start = token_end + 1; } return is; } } // end of namespace dai libDAI-0.2.4/src/weightedgraph.cpp0000644000263000017630000000771311334764774015622 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include namespace dai { using namespace std; RootedTree::RootedTree( const GraphEL &T, size_t Root ) { if( T.size() != 0 ) { // Make a copy GraphEL Gr = T; // Nodes in the tree set nodes; // Start with the root nodes.insert( Root ); // Keep adding edges until done while( !(Gr.empty()) ) for( GraphEL::iterator e = Gr.begin(); e != Gr.end(); ) { bool e1_in_nodes = nodes.count( e->n1 ); bool e2_in_nodes = nodes.count( e->n2 ); DAI_ASSERT( !(e1_in_nodes && e2_in_nodes) ); if( e1_in_nodes ) { // Add directed edge, pointing away from the root push_back( DEdge( e->n1, e->n2 ) ); nodes.insert( e->n2 ); // Erase the edge Gr.erase( e++ ); } else if( e2_in_nodes ) { // Add directed edge, pointing away from the root push_back( DEdge( e->n2, e->n1 ) ); nodes.insert( e->n1 ); // Erase the edge Gr.erase( e++ ); } else e++; } } } GraphEL RandomDRegularGraph( size_t N, size_t d ) { DAI_ASSERT( (N * d) % 2 == 0 ); bool ready = false; std::vector G; size_t tries = 0; while( !ready ) { tries++; // Start with N*d points {0,1,...,N*d-1} (N*d even) in N groups. // Put U = {0,1,...,N*d-1}. (U denotes the set of unpaired points.) vector U; U.reserve( N * d ); for( size_t i = 0; i < N * d; i++ ) U.push_back( i ); // Repeat the following until no suitable pair can be found: Choose // two random points i and j in U, and if they are suitable, pair // i with j and delete i and j from U. G.clear(); bool finished = false; while( !finished ) { random_shuffle( U.begin(), U.end() ); size_t i1, i2; bool suit_pair_found = false; for( i1 = 0; i1 < U.size()-1 && !suit_pair_found; i1++ ) for( i2 = i1+1; i2 < U.size() && !suit_pair_found; i2++ ) if( (U[i1] / d) != (U[i2] / d) ) { // they are suitable suit_pair_found = true; G.push_back( UEdge( U[i1] / d, U[i2] / d ) ); U.erase( U.begin() + i2 ); // first remove largest U.erase( U.begin() + i1 ); // remove smallest } if( !suit_pair_found || U.empty() ) finished = true; } if( U.empty() ) { // G is a graph with edge from vertex r to vertex s if and only if // there is a pair containing points in the r'th and s'th groups. // If G is d-regular, output, otherwise return to Step 1. vector degrees; degrees.resize( N, 0 ); foreach( const UEdge &e, G ) { degrees[e.n1]++; degrees[e.n2]++; } ready = true; for( size_t n = 0; n < N; n++ ) if( degrees[n] != d ) { ready = false; break; } } else ready = false; } return GraphEL( G.begin(), G.end() ); } } // end of namespace dai libDAI-0.2.4/src/matlab/0000755000263000017630000000000011334764774013524 5ustar jorismkyblibDAI-0.2.4/src/matlab/dai_readfg.cpp0000644000263000017630000000353411334764774016302 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include "mex.h" #include #include using namespace std; using namespace dai; /* Input Arguments */ #define FILENAME_IN prhs[0] #define NR_IN 1 /* Output Arguments */ #define PSI_OUT plhs[0] #define NR_OUT 1 void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray*prhs[] ) { char *filename; // Check for proper number of arguments if ((nrhs != NR_IN) || (nlhs != NR_OUT)) { mexErrMsgTxt("Usage: [psi] = dai_readfg(filename);\n\n" "\n" "INPUT: filename = filename of a .fg file\n" "\n" "OUTPUT: psi = linear cell array containing the factors\n" " (psi{i} is a structure with a Member field\n" " and a P field, like a CPTAB).\n"); } // Get input parameters size_t buflen; buflen = mxGetN( FILENAME_IN ) + 1; filename = (char *)mxCalloc( buflen, sizeof(char) ); mxGetString( FILENAME_IN, filename, buflen ); // Read factorgraph FactorGraph fg; try { fg.ReadFromFile( filename ); } catch( std::exception &e ) { mexErrMsgTxt( e.what() ); } // Save factors vector psi; for( size_t I = 0; I < fg.nrFactors(); I++ ) psi.push_back(fg.factor(I)); // Hand over results to MATLAB PSI_OUT = Factors2mx(psi); return; } libDAI-0.2.4/src/matlab/dai.cpp0000644000263000017630000001120011334764774014757 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include "mex.h" #include #include #include using namespace std; using namespace dai; /* Input Arguments */ #define PSI_IN prhs[0] #define METHOD_IN prhs[1] #define OPTS_IN prhs[2] #define NR_IN 3 #define NR_IN_OPT 0 /* Output Arguments */ #define LOGZ_OUT plhs[0] #define Q_OUT plhs[1] #define MD_OUT plhs[2] #define QV_OUT plhs[3] #define QF_OUT plhs[4] #define QMAP_OUT plhs[5] #define NR_OUT 3 #define NR_OUT_OPT 3 void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray*prhs[] ) { size_t buflen; // Check for proper number of arguments if( ((nrhs < NR_IN) || (nrhs > NR_IN + NR_IN_OPT)) || ((nlhs < NR_OUT) || (nlhs > NR_OUT + NR_OUT_OPT)) ) { mexErrMsgTxt("Usage: [logZ,q,md,qv,qf,qmap] = dai(psi,method,opts)\n\n" "\n" "INPUT: psi = linear cell array containing the factors \n" " psi{i} should be a structure with a Member field\n" " and a P field, like a CPTAB).\n" " method = name of the method (see README)\n" " opts = string of options (see README)\n" "\n" "OUTPUT: logZ = approximation of the logarithm of the partition sum.\n" " q = linear cell array containing all final beliefs.\n" " md = maxdiff (final linf-dist between new and old single node beliefs).\n" " qv = linear cell array containing all variable beliefs.\n" " qf = linear cell array containing all factor beliefs.\n" " qmap = (V,1) array containing the MAP labeling (only for BP,JTree).\n"); } char *method; char *opts; // Get psi and construct factorgraph vector factors = mx2Factors(PSI_IN, 0); FactorGraph fg(factors); // Get method buflen = mxGetN( METHOD_IN ) + 1; method = (char *)mxCalloc( buflen, sizeof(char) ); mxGetString( METHOD_IN, method, buflen ); // Get options string buflen = mxGetN( OPTS_IN ) + 1; opts = (char *)mxCalloc( buflen, sizeof(char) ); mxGetString( OPTS_IN, opts, buflen ); // Convert to options object props stringstream ss; ss << opts; PropertySet props; ss >> props; // Construct InfAlg object, init and run InfAlg *obj = newInfAlg( method, fg, props ); obj->init(); obj->run(); // Save logZ double logZ = obj->logZ(); // Save maxdiff double maxdiff = obj->maxDiff(); // Hand over results to MATLAB LOGZ_OUT = mxCreateDoubleMatrix(1,1,mxREAL); *(mxGetPr(LOGZ_OUT)) = logZ; Q_OUT = Factors2mx(obj->beliefs()); MD_OUT = mxCreateDoubleMatrix(1,1,mxREAL); *(mxGetPr(MD_OUT)) = maxdiff; if( nlhs >= 4 ) { vector qv; qv.reserve( fg.nrVars() ); for( size_t i = 0; i < fg.nrVars(); i++ ) qv.push_back( obj->belief( fg.var(i) ) ); QV_OUT = Factors2mx( qv ); } if( nlhs >= 5 ) { vector qf; qf.reserve( fg.nrFactors() ); for( size_t I = 0; I < fg.nrFactors(); I++ ) qf.push_back( obj->belief( fg.factor(I).vars() ) ); QF_OUT = Factors2mx( qf ); } if( nlhs >= 6 ) { std::vector map_state; if( obj->identify() == "BP" ) { BP* obj_bp = dynamic_cast(obj); DAI_ASSERT( obj_bp != 0 ); map_state = obj_bp->findMaximum(); } else if( obj->identify() == "JTREE" ) { JTree* obj_jtree = dynamic_cast(obj); DAI_ASSERT( obj_jtree != 0 ); map_state = obj_jtree->findMaximum(); } else { mexErrMsgTxt("MAP state assignment works only for BP, JTree.\n"); delete obj; return; } QMAP_OUT = mxCreateNumericMatrix(map_state.size(), 1, mxUINT32_CLASS, mxREAL); uint32_T* qmap_p = reinterpret_cast(mxGetPr(QMAP_OUT)); for (size_t n = 0; n < map_state.size(); ++n) qmap_p[n] = map_state[n]; } delete obj; return; } libDAI-0.2.4/src/matlab/dai_writefg.cpp0000644000263000017630000000332011334764774016512 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include "mex.h" #include #include using namespace std; using namespace dai; /* Input Arguments */ #define PSI_IN prhs[0] #define FILENAME_IN prhs[1] #define NR_IN 2 /* Output Arguments */ #define NR_OUT 0 void mexFunction( int nlhs, mxArray * /*plhs*/[], int nrhs, const mxArray*prhs[] ) { char *filename; // Check for proper number of arguments if ((nrhs != NR_IN) || (nlhs != NR_OUT)) { mexErrMsgTxt("Usage: dai_writefg(psi,filename);\n\n" "\n" "INPUT: psi = linear cell array containing the factors\n" " (psi{i} should be a structure with a Member field\n" " and a P field, like a CPTAB).\n" " filename = filename of a .fg file\n"); } // Get input parameters vector factors = mx2Factors(PSI_IN,0); size_t buflen; buflen = mxGetN( FILENAME_IN ) + 1; filename = (char *)mxCalloc( buflen, sizeof(char) ); mxGetString( FILENAME_IN, filename, buflen ); // Construct factorgraph FactorGraph fg(factors); try { fg.WriteToFile( filename ); } catch( std::exception &e ) { mexErrMsgTxt( e.what() ); } return; } libDAI-0.2.4/src/matlab/dai_potstrength.cpp0000644000263000017630000000431611334764774017432 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include "mex.h" #include #include using namespace std; using namespace dai; /* Input Arguments */ #define PSI_IN prhs[0] #define I_IN prhs[1] #define J_IN prhs[2] #define NR_IN 3 /* Output Arguments */ #define N_OUT plhs[0] #define NR_OUT 1 void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray*prhs[] ) { size_t ilabel, jlabel; // Check for proper number of arguments if ((nrhs != NR_IN) || (nlhs != NR_OUT)) { mexErrMsgTxt("Usage: N = dai_potstrength(psi,i,j);\n\n" "\n" "INPUT: psi = structure with a Member field and a P field, like a CPTAB.\n" " i = label of a variable in psi.\n" " j = label of another variable in psi.\n" "\n" "OUTPUT: N = strength of psi in direction i->j.\n"); } // Get input parameters Factor psi = mx2Factor(PSI_IN); ilabel = (size_t)*mxGetPr(I_IN); jlabel = (size_t)*mxGetPr(J_IN); // Find variable in psi with label ilabel Var i; for( VarSet::const_iterator n = psi.vars().begin(); n != psi.vars().end(); n++ ) if( n->label() == ilabel ) { i = *n; break; } DAI_ASSERT( i.label() == ilabel ); // Find variable in psi with label jlabel Var j; for( VarSet::const_iterator n = psi.vars().begin(); n != psi.vars().end(); n++ ) if( n->label() == jlabel ) { j = *n; break; } DAI_ASSERT( j.label() == jlabel ); // Calculate N(psi,i,j); double N = psi.strength( i, j ); // Hand over result to MATLAB N_OUT = mxCreateDoubleMatrix(1,1,mxREAL); *(mxGetPr(N_OUT)) = N; return; } libDAI-0.2.4/src/matlab/matlab.cpp0000644000263000017630000001263411334764774015476 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include namespace dai { using namespace std; /* Convert vector structure to a cell vector of CPTAB-like structs */ mxArray *Factors2mx(const vector &Ps) { size_t nr = Ps.size(); mxArray *psi = mxCreateCellMatrix(nr,1); const char *fieldnames[2]; fieldnames[0] = "Member"; fieldnames[1] = "P"; size_t I_ind = 0; for( vector::const_iterator I = Ps.begin(); I != Ps.end(); I++, I_ind++ ) { mxArray *Bi = mxCreateStructMatrix(1,1,2,fieldnames); mxArray *BiMember = mxCreateDoubleMatrix(1,I->vars().size(),mxREAL); double *BiMember_data = mxGetPr(BiMember); size_t i = 0; vector dims; for( VarSet::const_iterator j = I->vars().begin(); j != I->vars().end(); j++,i++ ) { BiMember_data[i] = j->label(); dims.push_back( j->states() ); } mxArray *BiP = mxCreateNumericArray(I->vars().size(), &(*(dims.begin())), mxDOUBLE_CLASS, mxREAL); double *BiP_data = mxGetPr(BiP); for( size_t j = 0; j < I->states(); j++ ) BiP_data[j] = (*I)[j]; mxSetField(Bi,0,"Member",BiMember); mxSetField(Bi,0,"P",BiP); mxSetCell(psi, I_ind, Bi); } return( psi ); } /* Convert cell vector of CPTAB-like structs to vector */ vector mx2Factors(const mxArray *psi, long verbose) { set vars; vector factors; int n1 = mxGetM(psi); int n2 = mxGetN(psi); if( n2 != 1 && n1 != 1 ) mexErrMsgTxt("psi should be a Nx1 or 1xN cell matrix."); size_t nr_f = n1; if( n1 == 1 ) nr_f = n2; // interpret psi, linear cell array of cptabs for( size_t cellind = 0; cellind < nr_f; cellind++ ) { if( verbose >= 3 ) cerr << "reading factor " << cellind << ": " << endl; mxArray *cell = mxGetCell(psi, cellind); mxArray *mx_member = mxGetField(cell, 0, "Member"); size_t nr_mem = mxGetN(mx_member); double *members = mxGetPr(mx_member); const mwSize *dims = mxGetDimensions(mxGetField(cell,0,"P")); double *factordata = mxGetPr(mxGetField(cell, 0, "P")); // add variables VarSet factorvars; vector labels(nr_mem,0); if( verbose >= 3 ) cerr << " vars: "; for( size_t mi = 0; mi < nr_mem; mi++ ) { labels[mi] = (long)members[mi]; if( verbose >= 3 ) cerr << labels[mi] << "(" << dims[mi] << ") "; vars.insert( Var(labels[mi], dims[mi]) ); factorvars |= Var(labels[mi], dims[mi]); } factors.push_back(Factor(factorvars)); // calculate permutation matrix vector perm(nr_mem,0); VarSet::iterator j = factorvars.begin(); for( size_t mi = 0; mi < nr_mem; mi++,j++ ) { long gezocht = j->label(); vector::iterator piet = find(labels.begin(),labels.end(),gezocht); perm[mi] = piet - labels.begin(); } if( verbose >= 3 ) { cerr << endl << " perm: "; for( vector::iterator r=perm.begin(); r!=perm.end(); r++ ) cerr << *r << " "; cerr << endl; } // read Factor vector di(nr_mem,0); size_t prod = 1; for( size_t k = 0; k < nr_mem; k++ ) { di[k] = dims[k]; prod *= dims[k]; } Permute permindex( di, perm ); for( size_t li = 0; li < prod; li++ ) factors.back()[permindex.convertLinearIndex(li)] = factordata[li]; } if( verbose >= 3 ) { for(vector::const_iterator I=factors.begin(); I!=factors.end(); I++ ) cerr << *I << endl; } return( factors ); } /* Convert CPTAB-like struct to Factor */ Factor mx2Factor(const mxArray *psi) { mxArray *mx_member = mxGetField(psi, 0, "Member"); size_t nr_mem = mxGetN(mx_member); double *members = mxGetPr(mx_member); const mwSize *dims = mxGetDimensions(mxGetField(psi,0,"P")); double *factordata = mxGetPr(mxGetField(psi, 0, "P")); // add variables VarSet vars; vector labels(nr_mem,0); for( size_t mi = 0; mi < nr_mem; mi++ ) { labels[mi] = (long)members[mi]; vars |= Var(labels[mi], dims[mi]); } Factor factor(vars); // calculate permutation matrix vector perm(nr_mem,0); VarSet::iterator j = vars.begin(); for( size_t mi = 0; mi < nr_mem; mi++,j++ ) { long gezocht = j->label(); vector::iterator piet = find(labels.begin(),labels.end(),gezocht); perm[mi] = piet - labels.begin(); } // read Factor vector di(nr_mem,0); size_t prod = 1; for( size_t k = 0; k < nr_mem; k++ ) { di[k] = dims[k]; prod *= dims[k]; } Permute permindex( di, perm ); for( size_t li = 0; li < prod; li++ ) factor[permindex.convertLinearIndex(li)] = factordata[li]; return( factor ); } } libDAI-0.2.4/src/gibbs.cpp0000644000263000017630000001446011334764774014063 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2008 Frederik Eaton [frederik at ofb dot net] * Copyright (C) 2008-2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include #include #include #include #include #include namespace dai { using namespace std; const char *Gibbs::Name = "GIBBS"; void Gibbs::setProperties( const PropertySet &opts ) { DAI_ASSERT( opts.hasKey("iters") ); props.iters = opts.getStringAs("iters"); if( opts.hasKey("burnin") ) props.burnin = opts.getStringAs("burnin"); else props.burnin = 0; if( opts.hasKey("verbose") ) props.verbose = opts.getStringAs("verbose"); else props.verbose = 0; } PropertySet Gibbs::getProperties() const { PropertySet opts; opts.Set( "iters", props.iters ); opts.Set( "burnin", props.burnin ); opts.Set( "verbose", props.verbose ); return opts; } string Gibbs::printProperties() const { stringstream s( stringstream::out ); s << "["; s << "iters=" << props.iters << ","; s << "burnin=" << props.burnin << ","; s << "verbose=" << props.verbose << "]"; return s.str(); } void Gibbs::construct() { _var_counts.clear(); _var_counts.reserve( nrVars() ); for( size_t i = 0; i < nrVars(); i++ ) _var_counts.push_back( _count_t( var(i).states(), 0 ) ); _factor_counts.clear(); _factor_counts.reserve( nrFactors() ); for( size_t I = 0; I < nrFactors(); I++ ) _factor_counts.push_back( _count_t( factor(I).states(), 0 ) ); _sample_count = 0; _state.clear(); _state.resize( nrVars(), 0 ); } void Gibbs::updateCounts() { _sample_count++; if( _sample_count > props.burnin ) { for( size_t i = 0; i < nrVars(); i++ ) _var_counts[i][_state[i]]++; for( size_t I = 0; I < nrFactors(); I++ ) _factor_counts[I][getFactorEntry(I)]++; } } inline size_t Gibbs::getFactorEntry( size_t I ) { size_t f_entry = 0; for( int _j = nbF(I).size() - 1; _j >= 0; _j-- ) { // note that iterating over nbF(I) yields the same ordering // of variables as iterating over factor(I).vars() size_t j = nbF(I)[_j]; f_entry *= var(j).states(); f_entry += _state[j]; } return f_entry; } inline size_t Gibbs::getFactorEntryDiff( size_t I, size_t i ) { size_t skip = 1; for( size_t _j = 0; _j < nbF(I).size(); _j++ ) { // note that iterating over nbF(I) yields the same ordering // of variables as iterating over factor(I).vars() size_t j = nbF(I)[_j]; if( i == j ) break; else skip *= var(j).states(); } return skip; } Prob Gibbs::getVarDist( size_t i ) { DAI_ASSERT( i < nrVars() ); size_t i_states = var(i).states(); Prob i_given_MB( i_states, 1.0 ); // use Markov blanket of var(i) to calculate distribution foreach( const Neighbor &I, nbV(i) ) { const Factor &f_I = factor(I); size_t I_skip = getFactorEntryDiff( I, i ); size_t I_entry = getFactorEntry(I) - (_state[i] * I_skip); for( size_t st_i = 0; st_i < i_states; st_i++ ) { i_given_MB[st_i] *= f_I[I_entry]; I_entry += I_skip; } } if( i_given_MB.sum() == 0.0 ) // If no state of i is allowed, use uniform distribution // FIXME is that indeed the right thing to do? i_given_MB = Prob( i_states ); else i_given_MB.normalize(); return i_given_MB; } inline void Gibbs::resampleVar( size_t i ) { _state[i] = getVarDist(i).draw(); } void Gibbs::randomizeState() { for( size_t i = 0; i < nrVars(); i++ ) _state[i] = rnd( var(i).states() ); } void Gibbs::init() { for( size_t i = 0; i < nrVars(); i++ ) fill( _var_counts[i].begin(), _var_counts[i].end(), 0 ); for( size_t I = 0; I < nrFactors(); I++ ) fill( _factor_counts[I].begin(), _factor_counts[I].end(), 0 ); _sample_count = 0; } Real Gibbs::run() { if( props.verbose >= 1 ) cerr << "Starting " << identify() << "..."; if( props.verbose >= 3 ) cerr << endl; double tic = toc(); randomizeState(); for( size_t iter = 0; iter < props.iters; iter++ ) { for( size_t j = 0; j < nrVars(); j++ ) resampleVar( j ); updateCounts(); } if( props.verbose >= 3 ) { for( size_t i = 0; i < nrVars(); i++ ) { cerr << "belief for variable " << var(i) << ": " << beliefV(i) << endl; cerr << "counts for variable " << var(i) << ": " << Prob( _var_counts[i] ) << endl; } } if( props.verbose >= 3 ) cerr << Name << "::run: ran " << props.iters << " passes (" << toc() - tic << " clocks)." << endl; return 0.0; } Factor Gibbs::beliefV( size_t i ) const { return Factor( var(i), _var_counts[i] ).normalized(); } Factor Gibbs::beliefF( size_t I ) const { return Factor( factor(I).vars(), _factor_counts[I] ).normalized(); } vector Gibbs::beliefs() const { vector result; for( size_t i = 0; i < nrVars(); ++i ) result.push_back( beliefV(i) ); for( size_t I = 0; I < nrFactors(); ++I ) result.push_back( beliefF(I) ); return result; } Factor Gibbs::belief( const VarSet &ns ) const { if( ns.size() == 0 ) return Factor(); else if( ns.size() == 1 ) return beliefV( findVar( *(ns.begin()) ) ); else { size_t I; for( I = 0; I < nrFactors(); I++ ) if( factor(I).vars() >> ns ) break; if( I == nrFactors() ) DAI_THROW(BELIEF_NOT_AVAILABLE); return beliefF(I).marginal(ns); } } std::vector getGibbsState( const FactorGraph &fg, size_t iters ) { PropertySet gibbsProps; gibbsProps.Set("iters", iters); gibbsProps.Set("burnin", size_t(0)); gibbsProps.Set("verbose", size_t(0)); Gibbs gibbs( fg, gibbsProps ); gibbs.run(); return gibbs.state(); } } // end of namespace dai libDAI-0.2.4/src/hak.cpp0000644000263000017630000004622611334764774013545 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include namespace dai { using namespace std; const char *HAK::Name = "HAK"; /// Sets factor entries that lie between 0 and \a epsilon to \a epsilon template TFactor& makePositive( TFactor &f, T epsilon ) { for( size_t t = 0; t < f.states(); t++ ) if( (0 < f[t]) && (f[t] < epsilon) ) f[t] = epsilon; return f; } /// Sets factor entries that are smaller (in absolute value) than \a epsilon to 0 template TFactor& makeZero( TFactor &f, T epsilon ) { for( size_t t = 0; t < f.states(); t++ ) if( f[t] < epsilon && f[t] > -epsilon ) f[t] = 0; return f; } void HAK::setProperties( const PropertySet &opts ) { DAI_ASSERT( opts.hasKey("tol") ); DAI_ASSERT( opts.hasKey("maxiter") ); DAI_ASSERT( opts.hasKey("verbose") ); DAI_ASSERT( opts.hasKey("doubleloop") ); DAI_ASSERT( opts.hasKey("clusters") ); props.tol = opts.getStringAs("tol"); props.maxiter = opts.getStringAs("maxiter"); props.verbose = opts.getStringAs("verbose"); props.doubleloop = opts.getStringAs("doubleloop"); props.clusters = opts.getStringAs("clusters"); if( opts.hasKey("loopdepth") ) props.loopdepth = opts.getStringAs("loopdepth"); else DAI_ASSERT( props.clusters != Properties::ClustersType::LOOP ); if( opts.hasKey("damping") ) props.damping = opts.getStringAs("damping"); else props.damping = 0.0; if( opts.hasKey("init") ) props.init = opts.getStringAs("init"); else props.init = Properties::InitType::UNIFORM; } PropertySet HAK::getProperties() const { PropertySet opts; opts.Set( "tol", props.tol ); opts.Set( "maxiter", props.maxiter ); opts.Set( "verbose", props.verbose ); opts.Set( "doubleloop", props.doubleloop ); opts.Set( "clusters", props.clusters ); opts.Set( "init", props.init ); opts.Set( "loopdepth", props.loopdepth ); opts.Set( "damping", props.damping ); return opts; } string HAK::printProperties() const { stringstream s( stringstream::out ); s << "["; s << "tol=" << props.tol << ","; s << "maxiter=" << props.maxiter << ","; s << "verbose=" << props.verbose << ","; s << "doubleloop=" << props.doubleloop << ","; s << "clusters=" << props.clusters << ","; s << "init=" << props.init << ","; s << "loopdepth=" << props.loopdepth << ","; s << "damping=" << props.damping << "]"; return s.str(); } void HAK::construct() { // Create outer beliefs _Qa.clear(); _Qa.reserve(nrORs()); for( size_t alpha = 0; alpha < nrORs(); alpha++ ) _Qa.push_back( Factor( OR(alpha) ) ); // Create inner beliefs _Qb.clear(); _Qb.reserve(nrIRs()); for( size_t beta = 0; beta < nrIRs(); beta++ ) _Qb.push_back( Factor( IR(beta) ) ); // Create messages _muab.clear(); _muab.reserve( nrORs() ); _muba.clear(); _muba.reserve( nrORs() ); for( size_t alpha = 0; alpha < nrORs(); alpha++ ) { _muab.push_back( vector() ); _muba.push_back( vector() ); _muab[alpha].reserve( nbOR(alpha).size() ); _muba[alpha].reserve( nbOR(alpha).size() ); foreach( const Neighbor &beta, nbOR(alpha) ) { _muab[alpha].push_back( Factor( IR(beta) ) ); _muba[alpha].push_back( Factor( IR(beta) ) ); } } } HAK::HAK( const RegionGraph &rg, const PropertySet &opts ) : DAIAlgRG(rg), _Qa(), _Qb(), _muab(), _muba(), _maxdiff(0.0), _iters(0U), props() { setProperties( opts ); construct(); } void HAK::findLoopClusters( const FactorGraph & fg, std::set &allcl, VarSet newcl, const Var & root, size_t length, VarSet vars ) { for( VarSet::const_iterator in = vars.begin(); in != vars.end(); in++ ) { VarSet ind = fg.delta( fg.findVar( *in ) ); if( (newcl.size()) >= 2 && ind.contains( root ) ) allcl.insert( newcl | *in ); else if( length > 1 ) findLoopClusters( fg, allcl, newcl | *in, root, length - 1, ind / newcl ); } } HAK::HAK(const FactorGraph & fg, const PropertySet &opts) : DAIAlgRG(), _Qa(), _Qb(), _muab(), _muba(), _maxdiff(0.0), _iters(0U), props() { setProperties( opts ); vector cl; if( props.clusters == Properties::ClustersType::MIN ) { cl = fg.Cliques(); constructCVM( fg, cl ); } else if( props.clusters == Properties::ClustersType::DELTA ) { cl.reserve( fg.nrVars() ); for( size_t i = 0; i < fg.nrVars(); i++ ) cl.push_back( fg.Delta(i) ); constructCVM( fg, cl ); } else if( props.clusters == Properties::ClustersType::LOOP ) { cl = fg.Cliques(); set scl; for( size_t i0 = 0; i0 < fg.nrVars(); i0++ ) { VarSet i0d = fg.delta(i0); if( props.loopdepth > 1 ) findLoopClusters( fg, scl, fg.var(i0), fg.var(i0), props.loopdepth - 1, fg.delta(i0) ); } for( set::const_iterator c = scl.begin(); c != scl.end(); c++ ) cl.push_back(*c); if( props.verbose >= 3 ) { cerr << Name << " uses the following clusters: " << endl; for( vector::const_iterator cli = cl.begin(); cli != cl.end(); cli++ ) cerr << *cli << endl; } constructCVM( fg, cl ); } else if( props.clusters == Properties::ClustersType::BETHE ) { // build outer regions (the cliques) cl = fg.Cliques(); size_t nrEdges = 0; for( size_t c = 0; c < cl.size(); c++ ) nrEdges += cl[c].size(); // build inner regions (single variables) vector irs; irs.reserve( fg.nrVars() ); for( size_t i = 0; i < fg.nrVars(); i++ ) irs.push_back( Region( fg.var(i), 1.0 ) ); // build edges (an outer and inner region are connected if the outer region contains the inner one) // and calculate counting number for inner regions vector > edges; edges.reserve( nrEdges ); for( size_t c = 0; c < cl.size(); c++ ) for( size_t i = 0; i < irs.size(); i++ ) if( cl[c] >> irs[i] ) { edges.push_back( make_pair( c, i ) ); irs[i].c() -= 1.0; } // build region graph RegionGraph::construct( fg, cl, irs, edges ); } else DAI_THROW(UNKNOWN_ENUM_VALUE); construct(); if( props.verbose >= 3 ) cerr << Name << " regiongraph: " << *this << endl; } string HAK::identify() const { return string(Name) + printProperties(); } void HAK::init( const VarSet &ns ) { for( size_t alpha = 0; alpha < nrORs(); alpha++ ) if( _Qa[alpha].vars().intersects( ns ) ) { if( props.init == Properties::InitType::UNIFORM ) _Qa[alpha].setUniform(); else _Qa[alpha].randomize(); _Qa[alpha] *= OR(alpha); _Qa[alpha].normalize(); } for( size_t beta = 0; beta < nrIRs(); beta++ ) if( IR(beta).intersects( ns ) ) { if( props.init == Properties::InitType::UNIFORM ) _Qb[beta].fill( 1.0 ); else _Qb[beta].randomize(); foreach( const Neighbor &alpha, nbIR(beta) ) { size_t _beta = alpha.dual; if( props.init == Properties::InitType::UNIFORM ) { muab( alpha, _beta ).fill( 1.0 ); muba( alpha, _beta ).fill( 1.0 ); } else { muab( alpha, _beta ).randomize(); muba( alpha, _beta ).randomize(); } } } } void HAK::init() { for( size_t alpha = 0; alpha < nrORs(); alpha++ ) { if( props.init == Properties::InitType::UNIFORM ) _Qa[alpha].setUniform(); else _Qa[alpha].randomize(); _Qa[alpha] *= OR(alpha); _Qa[alpha].normalize(); } for( size_t beta = 0; beta < nrIRs(); beta++ ) if( props.init == Properties::InitType::UNIFORM ) _Qb[beta].setUniform(); else _Qb[beta].randomize(); for( size_t alpha = 0; alpha < nrORs(); alpha++ ) foreach( const Neighbor &beta, nbOR(alpha) ) { size_t _beta = beta.iter; if( props.init == Properties::InitType::UNIFORM ) { muab( alpha, _beta ).setUniform(); muba( alpha, _beta ).setUniform(); } else { muab( alpha, _beta ).randomize(); muba( alpha, _beta ).randomize(); } } } Real HAK::doGBP() { if( props.verbose >= 1 ) cerr << "Starting " << identify() << "..."; if( props.verbose >= 3) cerr << endl; double tic = toc(); // Check whether counting numbers won't lead to problems for( size_t beta = 0; beta < nrIRs(); beta++ ) DAI_ASSERT( nbIR(beta).size() + IR(beta).c() != 0.0 ); // Keep old beliefs to check convergence vector oldBeliefsV; oldBeliefsV.reserve( nrVars() ); for( size_t i = 0; i < nrVars(); i++ ) oldBeliefsV.push_back( beliefV(i) ); vector oldBeliefsF; oldBeliefsF.reserve( nrFactors() ); for( size_t I = 0; I < nrFactors(); I++ ) oldBeliefsF.push_back( beliefF(I) ); // do several passes over the network until maximum number of iterations has // been reached or until the maximum belief difference is smaller than tolerance Real maxDiff = INFINITY; for( _iters = 0; _iters < props.maxiter && maxDiff > props.tol; _iters++ ) { for( size_t beta = 0; beta < nrIRs(); beta++ ) { foreach( const Neighbor &alpha, nbIR(beta) ) { size_t _beta = alpha.dual; muab( alpha, _beta ) = _Qa[alpha].marginal(IR(beta)) / muba(alpha,_beta); /* TODO: INVESTIGATE THIS PROBLEM * * In some cases, the muab's can have very large entries because the muba's have very * small entries. This may cause NANs later on (e.g., multiplying large quantities may * result in +inf; normalization then tries to calculate inf / inf which is NAN). * A fix of this problem would consist in normalizing the messages muab. * However, it is not obvious whether this is a real solution, because it has a * negative performance impact and the NAN's seem to be a symptom of a fundamental * numerical unstability. */ muab(alpha,_beta).normalize(); } Factor Qb_new; foreach( const Neighbor &alpha, nbIR(beta) ) { size_t _beta = alpha.dual; Qb_new *= muab(alpha,_beta) ^ (1 / (nbIR(beta).size() + IR(beta).c())); } Qb_new.normalize(); if( Qb_new.hasNaNs() ) { // TODO: WHAT TO DO IN THIS CASE? cerr << Name << "::doGBP: Qb_new has NaNs!" << endl; return 1.0; } /* TODO: WHAT IS THE PURPOSE OF THE FOLLOWING CODE? * * _Qb[beta] = Qb_new.makeZero(1e-100); */ if( props.doubleloop || props.damping == 0.0 ) _Qb[beta] = Qb_new; // no damping for double loop else _Qb[beta] = (Qb_new^(1.0 - props.damping)) * (_Qb[beta]^props.damping); foreach( const Neighbor &alpha, nbIR(beta) ) { size_t _beta = alpha.dual; muba(alpha,_beta) = _Qb[beta] / muab(alpha,_beta); /* TODO: INVESTIGATE WHETHER THIS HACK (INVENTED BY KEES) TO PREVENT NANS MAKES SENSE * * muba(beta,*alpha).makePositive(1e-100); * */ Factor Qa_new = OR(alpha); foreach( const Neighbor &gamma, nbOR(alpha) ) Qa_new *= muba(alpha,gamma.iter); Qa_new ^= (1.0 / OR(alpha).c()); Qa_new.normalize(); if( Qa_new.hasNaNs() ) { cerr << Name << "::doGBP: Qa_new has NaNs!" << endl; return 1.0; } /* TODO: WHAT IS THE PURPOSE OF THE FOLLOWING CODE? * * _Qb[beta] = Qb_new.makeZero(1e-100); */ if( props.doubleloop || props.damping == 0.0 ) _Qa[alpha] = Qa_new; // no damping for double loop else // FIXME: GEOMETRIC DAMPING IS SLOW! _Qa[alpha] = (Qa_new^(1.0 - props.damping)) * (_Qa[alpha]^props.damping); } } // Calculate new single variable beliefs and compare with old ones maxDiff = -INFINITY; for( size_t i = 0; i < nrVars(); ++i ) { Factor b = beliefV(i); maxDiff = std::max( maxDiff, dist( b, oldBeliefsV[i], Prob::DISTLINF ) ); oldBeliefsV[i] = b; } for( size_t I = 0; I < nrFactors(); ++I ) { Factor b = beliefF(I); maxDiff = std::max( maxDiff, dist( b, oldBeliefsF[I], Prob::DISTLINF ) ); oldBeliefsF[I] = b; } if( props.verbose >= 3 ) cerr << Name << "::doGBP: maxdiff " << maxDiff << " after " << _iters+1 << " passes" << endl; } if( maxDiff > _maxdiff ) _maxdiff = maxDiff; if( props.verbose >= 1 ) { if( maxDiff > props.tol ) { if( props.verbose == 1 ) cerr << endl; cerr << Name << "::doGBP: WARNING: not converged within " << props.maxiter << " passes (" << toc() - tic << " seconds)...final maxdiff:" << maxDiff << endl; } else { if( props.verbose >= 2 ) cerr << Name << "::doGBP: "; cerr << "converged in " << _iters << " passes (" << toc() - tic << " seconds)." << endl; } } return maxDiff; } Real HAK::doDoubleLoop() { if( props.verbose >= 1 ) cerr << "Starting " << identify() << "..."; if( props.verbose >= 3) cerr << endl; double tic = toc(); // Save original outer regions vector org_ORs = ORs; // Save original inner counting numbers and set negative counting numbers to zero vector org_IR_cs( nrIRs(), 0.0 ); for( size_t beta = 0; beta < nrIRs(); beta++ ) { org_IR_cs[beta] = IR(beta).c(); if( IR(beta).c() < 0.0 ) IR(beta).c() = 0.0; } // Keep old beliefs to check convergence vector oldBeliefsV; oldBeliefsV.reserve( nrVars() ); for( size_t i = 0; i < nrVars(); i++ ) oldBeliefsV.push_back( beliefV(i) ); vector oldBeliefsF; oldBeliefsF.reserve( nrFactors() ); for( size_t I = 0; I < nrFactors(); I++ ) oldBeliefsF.push_back( beliefF(I) ); size_t outer_maxiter = props.maxiter; Real outer_tol = props.tol; size_t outer_verbose = props.verbose; Real org_maxdiff = _maxdiff; // Set parameters for inner loop props.maxiter = 5; props.verbose = outer_verbose ? outer_verbose - 1 : 0; size_t outer_iter = 0; size_t total_iter = 0; Real maxDiff = INFINITY; for( outer_iter = 0; outer_iter < outer_maxiter && maxDiff > outer_tol; outer_iter++ ) { // Calculate new outer regions for( size_t alpha = 0; alpha < nrORs(); alpha++ ) { OR(alpha) = org_ORs[alpha]; foreach( const Neighbor &beta, nbOR(alpha) ) OR(alpha) *= _Qb[beta] ^ ((IR(beta).c() - org_IR_cs[beta]) / nbIR(beta).size()); } // Inner loop if( isnan( doGBP() ) ) return 1.0; // Calculate new single variable beliefs and compare with old ones maxDiff = -INFINITY; for( size_t i = 0; i < nrVars(); ++i ) { Factor b = beliefV(i); maxDiff = std::max( maxDiff, dist( b, oldBeliefsV[i], Prob::DISTLINF ) ); oldBeliefsV[i] = b; } for( size_t I = 0; I < nrFactors(); ++I ) { Factor b = beliefF(I); maxDiff = std::max( maxDiff, dist( b, oldBeliefsF[I], Prob::DISTLINF ) ); oldBeliefsF[I] = b; } total_iter += Iterations(); if( props.verbose >= 3 ) cerr << Name << "::doDoubleLoop: maxdiff " << maxDiff << " after " << total_iter << " passes" << endl; } // restore _maxiter, _verbose and _maxdiff props.maxiter = outer_maxiter; props.verbose = outer_verbose; _maxdiff = org_maxdiff; _iters = total_iter; if( maxDiff > _maxdiff ) _maxdiff = maxDiff; // Restore original outer regions ORs = org_ORs; // Restore original inner counting numbers for( size_t beta = 0; beta < nrIRs(); ++beta ) IR(beta).c() = org_IR_cs[beta]; if( props.verbose >= 1 ) { if( maxDiff > props.tol ) { if( props.verbose == 1 ) cerr << endl; cerr << Name << "::doDoubleLoop: WARNING: not converged within " << outer_maxiter << " passes (" << toc() - tic << " seconds)...final maxdiff:" << maxDiff << endl; } else { if( props.verbose >= 3 ) cerr << Name << "::doDoubleLoop: "; cerr << "converged in " << total_iter << " passes (" << toc() - tic << " seconds)." << endl; } } return maxDiff; } Real HAK::run() { if( props.doubleloop ) return doDoubleLoop(); else return doGBP(); } Factor HAK::belief( const VarSet &ns ) const { vector::const_iterator beta; for( beta = _Qb.begin(); beta != _Qb.end(); beta++ ) if( beta->vars() >> ns ) break; if( beta != _Qb.end() ) return( beta->marginal(ns) ); else { vector::const_iterator alpha; for( alpha = _Qa.begin(); alpha != _Qa.end(); alpha++ ) if( alpha->vars() >> ns ) break; if( alpha == _Qa.end() ) DAI_THROW(BELIEF_NOT_AVAILABLE); return( alpha->marginal(ns) ); } } vector HAK::beliefs() const { vector result; for( size_t beta = 0; beta < nrIRs(); beta++ ) result.push_back( Qb(beta) ); for( size_t alpha = 0; alpha < nrORs(); alpha++ ) result.push_back( Qa(alpha) ); return result; } Real HAK::logZ() const { Real s = 0.0; for( size_t beta = 0; beta < nrIRs(); beta++ ) s += IR(beta).c() * Qb(beta).entropy(); for( size_t alpha = 0; alpha < nrORs(); alpha++ ) { s += OR(alpha).c() * Qa(alpha).entropy(); s += (OR(alpha).log(true) * Qa(alpha)).sum(); } return s; } } // end of namespace dai libDAI-0.2.4/src/trwbp.cpp0000644000263000017630000000757511334764774014144 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #define DAI_TRWBP_FAST 1 namespace dai { using namespace std; const char *TRWBP::Name = "TRWBP"; string TRWBP::identify() const { return string(Name) + printProperties(); } // This code has been copied from bp.cpp, except where comments indicate TRWBP-specific behaviour Real TRWBP::logZ() const { Real sum = 0.0; for( size_t I = 0; I < nrFactors(); I++ ) { sum += (beliefF(I) * factor(I).log(true)).sum(); // TRWBP/FBP sum += Weight(I) * beliefF(I).entropy(); // TRWBP/FBP } for( size_t i = 0; i < nrVars(); ++i ) { Real c_i = 0.0; foreach( const Neighbor &I, nbV(i) ) c_i += Weight(I); sum += (1.0 - c_i) * beliefV(i).entropy(); // TRWBP/FBP } return sum; } // This code has been copied from bp.cpp, except where comments indicate TRWBP-specific behaviour Prob TRWBP::calcIncomingMessageProduct( size_t I, bool without_i, size_t i ) const { Real c_I = Weight(I); // TRWBP: c_I Factor Fprod( factor(I) ); Prob &prod = Fprod.p(); if( props.logdomain ) { prod.takeLog(); prod /= c_I; // TRWBP } else prod ^= (1.0 / c_I); // TRWBP // Calculate product of incoming messages and factor I foreach( const Neighbor &j, nbF(I) ) if( !(without_i && (j == i)) ) { const Var &v_j = var(j); // prod_j will be the product of messages coming into j // TRWBP: corresponds to messages n_jI Prob prod_j( v_j.states(), props.logdomain ? 0.0 : 1.0 ); foreach( const Neighbor &J, nbV(j) ) { Real c_J = Weight(J); // TRWBP if( J != I ) { // for all J in nb(j) \ I if( props.logdomain ) prod_j += message( j, J.iter ) * c_J; else prod_j *= message( j, J.iter ) ^ c_J; } else { // TRWBP: multiply by m_Ij^(c_I-1) if( props.logdomain ) prod_j += message( j, J.iter ) * (c_J - 1.0); else prod_j *= message( j, J.iter ) ^ (c_J - 1.0); } } // multiply prod with prod_j if( !DAI_TRWBP_FAST ) { // UNOPTIMIZED (SIMPLE TO READ, BUT SLOW) VERSION if( props.logdomain ) Fprod += Factor( v_j, prod_j ); else Fprod *= Factor( v_j, prod_j ); } else { // OPTIMIZED VERSION size_t _I = j.dual; // ind is the precalculated IndexFor(j,I) i.e. to x_I == k corresponds x_j == ind[k] const ind_t &ind = index(j, _I); for( size_t r = 0; r < prod.size(); ++r ) { if( props.logdomain ) prod[r] += prod_j[ind[r]]; else prod[r] *= prod_j[ind[r]]; } } } return prod; } // This code has been copied from bp.cpp, except where comments indicate TRWBP-specific behaviour void TRWBP::calcBeliefV( size_t i, Prob &p ) const { p = Prob( var(i).states(), props.logdomain ? 0.0 : 1.0 ); foreach( const Neighbor &I, nbV(i) ) { Real c_I = Weight(I); if( props.logdomain ) p += newMessage( i, I.iter ) * c_I; else p *= newMessage( i, I.iter ) ^ c_I; } } void TRWBP::construct() { BP::construct(); _weight.resize( nrFactors(), 1.0 ); } } // end of namespace dai libDAI-0.2.4/src/factor.cpp0000644000263000017630000000320011334764774014241 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include namespace dai { using namespace std; Factor createFactorIsing( const Var &n, Real h ) { DAI_ASSERT( n.states() == 2 ); Real buf[2]; buf[0] = std::exp(-h); buf[1] = std::exp(h); return Factor(n, &buf[0]); } Factor createFactorIsing( const Var &n1, const Var &n2, Real J ) { DAI_ASSERT( n1.states() == 2 ); DAI_ASSERT( n2.states() == 2 ); DAI_ASSERT( n1 != n2 ); Real buf[4]; buf[0] = (buf[3] = std::exp(J)); buf[1] = (buf[2] = std::exp(-J)); return Factor( VarSet(n1, n2), &buf[0] ); } Factor createFactorExpGauss( const VarSet &ns, Real beta ) { Factor fac( ns ); for( size_t t = 0; t < fac.states(); t++ ) fac[t] = std::exp(rnd_stdnormal() * beta); return fac; } Factor createFactorPotts( const Var &n1, const Var &n2, Real J ) { Factor fac( VarSet( n1, n2 ), 1.0 ); DAI_ASSERT( n1.states() == n2.states() ); for( size_t s = 0; s < n1.states(); s++ ) fac[ s * (n1.states() + 1) ] = std::exp(J); return fac; } Factor createFactorDelta( const Var &v, size_t state ) { Factor fac( v, 0.0 ); DAI_ASSERT( state < v.states() ); fac[state] = 1.0; return fac; } } // end of namespace dai libDAI-0.2.4/src/alldai.cpp0000644000263000017630000001115511334764774014221 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include namespace dai { using namespace std; InfAlg *newInfAlg( const std::string &name, const FactorGraph &fg, const PropertySet &opts ) { if( name == ExactInf::Name ) return new ExactInf (fg, opts); #ifdef DAI_WITH_BP if( name == BP::Name ) return new BP (fg, opts); #endif #ifdef DAI_WITH_FBP if( name == FBP::Name ) return new FBP (fg, opts); #endif #ifdef DAI_WITH_TRWBP if( name == TRWBP::Name ) return new TRWBP (fg, opts); #endif #ifdef DAI_WITH_MF if( name == MF::Name ) return new MF (fg, opts); #endif #ifdef DAI_WITH_HAK if( name == HAK::Name ) return new HAK (fg, opts); #endif #ifdef DAI_WITH_LC if( name == LC::Name ) return new LC (fg, opts); #endif #ifdef DAI_WITH_TREEEP if( name == TreeEP::Name ) return new TreeEP (fg, opts); #endif #ifdef DAI_WITH_JTREE if( name == JTree::Name ) return new JTree (fg, opts); #endif #ifdef DAI_WITH_MR if( name == MR::Name ) return new MR (fg, opts); #endif #ifdef DAI_WITH_GIBBS if( name == Gibbs::Name ) return new Gibbs (fg, opts); #endif #ifdef DAI_WITH_CBP if( name == CBP::Name ) return new CBP (fg, opts); #endif DAI_THROWE(UNKNOWN_DAI_ALGORITHM,"Unknown libDAI algorithm: " + name); } InfAlg *newInfAlgFromString( const std::string &nameOpts, const FactorGraph &fg ) { pair no = parseNameProperties( nameOpts ); return newInfAlg( no.first, fg, no.second ); } InfAlg *newInfAlgFromString( const std::string &nameOpts, const FactorGraph &fg, const std::map &aliases ) { pair no = parseNameProperties( nameOpts, aliases ); return newInfAlg( no.first, fg, no.second ); } std::pair parseNameProperties( const std::string &s ) { string::size_type pos = s.find_first_of('['); string name; PropertySet opts; if( pos == string::npos ) { name = s; } else { name = s.substr(0,pos); stringstream ss; ss << s.substr(pos,s.length()); ss >> opts; } return make_pair(name,opts); } std::pair parseNameProperties( const std::string &s, const std::map &aliases ) { // break string into method[properties] pair ps = parseNameProperties(s); bool looped = false; // as long as 'method' is an alias, update: while( aliases.find(ps.first) != aliases.end() && !looped ) { string astr = aliases.find(ps.first)->second; pair aps = parseNameProperties(astr); if( aps.first == ps.first ) looped = true; // override aps properties by ps properties aps.second.Set( ps.second ); // replace ps by aps ps = aps; // repeat until method name == alias name ('looped'), or // there is no longer an alias 'method' } return ps; } std::map readAliasesFile( const std::string &filename ) { // Read aliases map result; ifstream infile; infile.open( filename.c_str() ); if( infile.is_open() ) { while( true ) { string line; getline( infile,line ); if( infile.fail() ) break; if( (!line.empty()) && (line[0] != '#') ) { string::size_type pos = line.find(':',0); if( pos == string::npos ) DAI_THROWE(INVALID_ALIAS,"Invalid alias '" + line + "'"); else { string::size_type posl = line.substr(0, pos).find_last_not_of(" \t"); string key = line.substr(0, posl + 1); string::size_type posr = line.substr(pos + 1, line.length()).find_first_not_of(" \t"); string val = line.substr(pos + 1 + posr, line.length()); result[key] = val; } } } infile.close(); } else DAI_THROWE(CANNOT_READ_FILE,"Error opening aliases file " + filename); return result; } } // end of namespace dai libDAI-0.2.4/src/graph.cpp0000644000263000017630000002310011334764774014065 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include namespace dai { using namespace std; void GraphAL::addEdge( size_t n1, size_t n2, bool check ) { DAI_ASSERT( n1 < nrNodes() ); DAI_ASSERT( n2 < nrNodes() ); bool exists = false; if( check ) { // Check whether the edge already exists foreach( const Neighbor &n, nb(n1) ) if( n == n2 ) { exists = true; break; } } if( !exists ) { // Add edge Neighbor nb_1( nb(n1).size(), n2, nb(n2).size() ); Neighbor nb_2( nb_1.dual, n1, nb_1.iter ); nb(n1).push_back( nb_1 ); nb(n2).push_back( nb_2 ); } } void GraphAL::eraseNode( size_t n ) { DAI_ASSERT( n < nrNodes() ); // Erase neighbor entry of node n _nb.erase( _nb.begin() + n ); // Adjust neighbor entries of nodes for( size_t n2 = 0; n2 < nrNodes(); n2++ ) { for( size_t iter = 0; iter < nb(n2).size(); ) { Neighbor &m = nb(n2, iter); if( m.node == n ) { // delete this entry, because it points to the deleted node nb(n2).erase( nb(n2).begin() + iter ); } else if( m.node > n ) { // update this entry and the corresponding dual of the neighboring node m.iter = iter; m.node--; nb( m.node, m.dual ).dual = iter; iter++; } else { // skip iter++; } } } } void GraphAL::eraseEdge( size_t n1, size_t n2 ) { DAI_ASSERT( n1 < nrNodes() ); DAI_ASSERT( n2 < nrNodes() ); size_t iter; // Search for edge among neighbors of n1 for( iter = 0; iter < nb(n1).size(); iter++ ) if( nb(n1, iter).node == n2 ) { // Remove it nb(n1).erase( nb(n1).begin() + iter ); break; } // Change the iter and dual values of the subsequent neighbors for( ; iter < nb(n1).size(); iter++ ) { Neighbor &m = nb( n1, iter ); m.iter = iter; nb( m.node, m.dual ).dual = iter; } // Search for edge among neighbors of n2 for( iter = 0; iter < nb(n2).size(); iter++ ) if( nb(n2, iter).node == n1 ) { // Remove it nb(n2).erase( nb(n2).begin() + iter ); break; } // Change the iter and node values of the subsequent neighbors for( ; iter < nb(n2).size(); iter++ ) { Neighbor &m = nb( n2, iter ); m.iter = iter; nb( m.node, m.dual ).dual = iter; } } bool GraphAL::isConnected() const { if( nrNodes() == 0 ) { return true; } else { std::vector incomponent( nrNodes(), false ); incomponent[0] = true; bool found_new_nodes; do { found_new_nodes = false; // For all nodes, check if they are connected with the (growing) component for( size_t n1 = 0; n1 < nrNodes(); n1++ ) if( !incomponent[n1] ) { foreach( const Neighbor &n2, nb(n1) ) { if( incomponent[n2] ) { found_new_nodes = true; incomponent[n1] = true; break; } } } } while( found_new_nodes ); // Check if there are remaining nodes (not in the component) bool all_connected = true; for( size_t n1 = 0; (n1 < nrNodes()) && all_connected; n1++ ) if( !incomponent[n1] ) all_connected = false; return all_connected; // BGL implementation is slower... /* using namespace boost; typedef adjacency_list< vecS, vecS, undirectedS, property > boostGraphAL; typedef pair E; // Copy graph structure into boostGraphAL object vector edges; edges.reserve( nrEdges() ); for( size_t n1 = 0; n1 < nrNodes(); n1++ ) foreach( const Neighbor &n2, nb(n1) ) if( n1 < n2 ) edges.push_back( E( n1, n2 ) ); boostGraphAL g( edges.begin(), edges.end(), nrNodes() ); // Construct connected components using Boost GraphAL Library std::vector component( num_vertices( g ) ); int num_comp = connected_components( g, make_iterator_property_map(component.begin(), get(vertex_index, g)) ); return (num_comp == 1); */ } } bool GraphAL::isTree() const { using namespace std; vector levels; bool foundCycle = false; size_t Nr = 0; if( nrNodes() == 0 ) return true; else { levelType newLevel; do { newLevel.clear(); if( levels.size() == 0 ) { size_t n1 = 0; // add n1 newLevel = vector( 1, n1 ); } else { const levelType &prevLevel = levels.back(); // build newLevel foreach( size_t n2, prevLevel ) { // for all n2 in the previous level foreach( const Neighbor &n1, nb(n2) ) { // for all neighbors n1 of n2 if( find( prevLevel.begin(), prevLevel.end(), n1 ) == prevLevel.end() ) { // n1 not in previous level if( find( newLevel.begin(), newLevel.end(), n1 ) != newLevel.end() ) foundCycle = true; // n1 already in new level: we found a cycle else newLevel.push_back( n1 ); // add n1 to new level } if( foundCycle ) break; } if( foundCycle ) break; } } levels.push_back( newLevel ); Nr += newLevel.size(); } while( (newLevel.size() != 0) && !foundCycle ); if( Nr == nrNodes() && !foundCycle ) return true; else return false; } } void GraphAL::printDot( std::ostream& os ) const { using namespace std; os << "graph G {" << endl; os << "node[shape=circle,width=0.4,fixedsize=true];" << endl; for( size_t n = 0; n < nrNodes(); n++ ) os << "\tx" << n << ";" << endl; for( size_t n1 = 0; n1 < nrNodes(); n1++ ) foreach( const Neighbor &n2, nb(n1) ) os << "\tx" << n1 << " -- y" << n2 << ";" << endl; os << "}" << endl; } void GraphAL::checkConsistency() const { size_t N = nrNodes(); for( size_t n1 = 0; n1 < N; n1++ ) { size_t iter = 0; foreach( const Neighbor &n2, nb(n1) ) { DAI_ASSERT( n2.iter == iter ); DAI_ASSERT( n2.node < N ); DAI_ASSERT( n2.dual < nb(n2).size() ); DAI_ASSERT( nb(n2, n2.dual) == n1 ); iter++; } } for( size_t n2 = 0; n2 < N; n2++ ) { size_t iter = 0; foreach( const Neighbor &n1, nb(n2) ) { DAI_ASSERT( n1.iter == iter ); DAI_ASSERT( n1.node < N ); DAI_ASSERT( n1.dual < nb(n1).size() ); DAI_ASSERT( nb(n1, n1.dual) == n2 ); iter++; } } } GraphAL createGraphFull( size_t N ) { GraphAL result( N ); for( size_t i = 0; i < N; i++ ) for( size_t j = i+1; j < N; j++ ) result.addEdge( i, j, false ); return result; } GraphAL createGraphGrid( size_t n1, size_t n2, bool periodic ) { GraphAL result( n1*n2 ); for( size_t i1 = 0; i1 < n1; i1++ ) for( size_t i2 = 0; i2 < n2; i2++ ) { if( i1+1 < n1 || periodic ) result.addEdge( i1*n2 + i2, ((i1+1)%n1)*n2 + i2, n1 <= 2 ); if( i2+1 < n2 || periodic ) result.addEdge( i1*n2 + i2, i1*n2 + ((i2+1)%n2), n2 <= 2 ); } return result; } GraphAL createGraphGrid3D( size_t n1, size_t n2, size_t n3, bool periodic ) { GraphAL result( n1*n2*n3 ); for( size_t i1 = 0; i1 < n1; i1++ ) for( size_t i2 = 0; i2 < n2; i2++ ) for( size_t i3 = 0; i3 < n3; i3++ ) { if( i1+1 < n1 || periodic ) result.addEdge( i1*n2*n3 + i2*n3 + i3, ((i1+1)%n1)*n2*n3 + i2*n3 + i3, n1 <= 2 ); if( i2+1 < n2 || periodic ) result.addEdge( i1*n2*n3 + i2*n3 + i3, i1*n2*n3 + ((i2+1)%n2)*n3 + i3, n2 <= 2 ); if( i3+1 < n2 || periodic ) result.addEdge( i1*n2*n3 + i2*n3 + i3, i1*n2*n3 + i2*n3 + ((i3+1)%n3), n3 <= 2 ); } return result; } GraphAL createGraphLoop( size_t N ) { GraphAL result( N ); for( size_t i = 0; i < N; i++ ) result.addEdge( i, (i+1)%N, N <= 2 ); return result; } GraphAL createGraphTree( size_t N ) { GraphAL result( N ); for( size_t i = 1; i < N; i++ ) { size_t j = rnd_int( 0, i-1 ); result.addEdge( i, j, false ); } return result; } GraphAL createGraphRegular( size_t N, size_t d ) { GraphEL g = RandomDRegularGraph( N, d ); return GraphAL( N, g.begin(), g.end() ); } } // end of namespace dai libDAI-0.2.4/src/bp_dual.cpp0000644000263000017630000001050511334764774014377 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Frederik Eaton [frederik at ofb dot net] */ #include #include #include #include #include #include namespace dai { using namespace std; typedef BipartiteGraph::Neighbor Neighbor; void BP_dual::init() { regenerateMessages(); regenerateBeliefs(); calcMessages(); calcBeliefs(); } void BP_dual::regenerateMessages() { size_t nv = fg().nrVars(); _msgs.Zn.resize(nv); _msgs.Zm.resize(nv); _msgs.m.resize(nv); _msgs.n.resize(nv); for( size_t i = 0; i < nv; i++ ) { size_t nvf = fg().nbV(i).size(); _msgs.Zn[i].resize(nvf, 1.0); _msgs.Zm[i].resize(nvf, 1.0); size_t states = fg().var(i).states(); _msgs.n[i].resize(nvf, Prob(states)); _msgs.m[i].resize(nvf, Prob(states)); } } void BP_dual::regenerateBeliefs() { _beliefs.b1.clear(); _beliefs.b1.reserve(fg().nrVars()); _beliefs.Zb1.resize(fg().nrVars(), 1.0); _beliefs.b2.clear(); _beliefs.b2.reserve(fg().nrFactors()); _beliefs.Zb2.resize(fg().nrFactors(), 1.0); for( size_t i = 0; i < fg().nrVars(); i++ ) _beliefs.b1.push_back( Prob( fg().var(i).states() ) ); for( size_t I = 0; I < fg().nrFactors(); I++ ) _beliefs.b2.push_back( Prob( fg().factor(I).states() ) ); } void BP_dual::calcMessages() { // calculate 'n' messages from "factor marginal / factor" for( size_t I = 0; I < fg().nrFactors(); I++ ) { Factor f = _ia->beliefF(I) / fg().factor(I); foreach( const Neighbor &i, fg().nbF(I) ) msgN(i, i.dual) = f.marginal( fg().var(i) ).p(); } // calculate 'm' messages and normalizers from 'n' messages for( size_t i = 0; i < fg().nrVars(); i++ ) foreach( const Neighbor &I, fg().nbV(i) ) calcNewM( i, I.iter ); // recalculate 'n' messages and normalizers from 'm' messages for( size_t i = 0; i < fg().nrVars(); i++ ) foreach( const Neighbor &I, fg().nbV(i) ) calcNewN(i, I.iter); } void BP_dual::calcNewM( size_t i, size_t _I ) { // calculate updated message I->i const Neighbor &I = fg().nbV(i)[_I]; Prob prod( fg().factor(I).p() ); foreach( const Neighbor &j, fg().nbF(I) ) if( j != i ) { // for all j in I \ i Prob &n = msgN(j,j.dual); IndexFor ind( fg().var(j), fg().factor(I).vars() ); for( size_t x = 0; ind.valid(); x++, ++ind ) prod[x] *= n[ind]; } // Marginalize onto i Prob marg( fg().var(i).states(), 0.0 ); // ind is the precalculated Index(i,I) i.e. to x_I == k corresponds x_i == ind[k] IndexFor ind( fg().var(i), fg().factor(I).vars() ); for( size_t x = 0; ind.valid(); x++, ++ind ) marg[ind] += prod[x]; _msgs.Zm[i][_I] = marg.normalize(); _msgs.m[i][_I] = marg; } void BP_dual::calcNewN( size_t i, size_t _I ) { // calculate updated message i->I const Neighbor &I = fg().nbV(i)[_I]; Prob prod( fg().var(i).states(), 1.0 ); foreach( const Neighbor &J, fg().nbV(i) ) if( J.node != I.node ) // for all J in i \ I prod *= msgM(i,J.iter); _msgs.Zn[i][_I] = prod.normalize(); _msgs.n[i][_I] = prod; } void BP_dual::calcBeliefs() { for( size_t i = 0; i < fg().nrVars(); i++ ) calcBeliefV(i); // calculate b_i for( size_t I = 0; I < fg().nrFactors(); I++ ) calcBeliefF(I); // calculate b_I } void BP_dual::calcBeliefV( size_t i ) { Prob prod( fg().var(i).states(), 1.0 ); foreach( const Neighbor &I, fg().nbV(i) ) prod *= msgM(i,I.iter); _beliefs.Zb1[i] = prod.normalize(); _beliefs.b1[i] = prod; } void BP_dual::calcBeliefF( size_t I ) { Prob prod( fg().factor(I).p() ); foreach( const Neighbor &j, fg().nbF(I) ) { IndexFor ind( fg().var(j), fg().factor(I).vars() ); Prob n( msgN(j,j.dual) ); for( size_t x = 0; ind.valid(); x++, ++ind ) prod[x] *= n[ind]; } _beliefs.Zb2[I] = prod.normalize(); _beliefs.b2[I] = prod; } } // end of namespace dai libDAI-0.2.4/src/exceptions.cpp0000644000263000017630000000250711334764774015155 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include namespace dai { std::string Exception::ErrorStrings[NUM_ERRORS] = { "Feature not implemented", "Assertion failed", "Impossible typecast", "Requested object not found", "Requested belief not available", "Unknown ENUM value", "Unknown DAI algorithm", "Unrecognized parameter estimation method", "Unknown Property type", "Unknown Property", "Malformed Property", "Not all mandatory Properties specified", "Invalid alias", "Cannot read file", "Cannot write file", "Invalid FactorGraph file", "Invalid Evidence file", "Invalid Expectation-Maximization file", "Quantity not normalizable", "Multiple undo levels unsupported", "FactorGraph is not connected", "Internal error", "Runtime error" }; } libDAI-0.2.4/src/clustergraph.cpp0000644000263000017630000000770211334764774015501 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include #include namespace dai { using namespace std; ClusterGraph::ClusterGraph( const std::vector & cls ) : G(), vars(), clusters() { // construct vars, clusters and edge list vector edges; foreach( const VarSet &cl, cls ) { if( find( clusters.begin(), clusters.end(), cl ) == clusters.end() ) { // add cluster size_t n2 = clusters.size(); clusters.push_back( cl ); for( VarSet::const_iterator n = cl.begin(); n != cl.end(); n++ ) { size_t n1 = find( vars.begin(), vars.end(), *n ) - vars.begin(); if( n1 == vars.size() ) // add variable vars.push_back( *n ); edges.push_back( Edge( n1, n2 ) ); } } // disregard duplicate clusters } // Create bipartite graph G.construct( vars.size(), clusters.size(), edges.begin(), edges.end() ); } size_t ClusterGraph::eliminationCost( size_t i ) const { return eliminationCost_MinFill( *this, i ); } ClusterGraph ClusterGraph::VarElim( const std::vector &ElimSeq ) const { return VarElim( sequentialVariableElimination( ElimSeq ) ); } ClusterGraph ClusterGraph::VarElim_MinFill() const { return VarElim( greedyVariableElimination( &eliminationCost_MinFill ) ); } size_t sequentialVariableElimination::operator()( const ClusterGraph &cl, const std::set &/*remainingVars*/ ) { return cl.findVar( seq.at(i++) ); } size_t greedyVariableElimination::operator()( const ClusterGraph &cl, const std::set &remainingVars ) { set::const_iterator lowest = remainingVars.end(); size_t lowest_cost = -1UL; for( set::const_iterator i = remainingVars.begin(); i != remainingVars.end(); i++ ) { size_t cost = heuristic( cl, *i ); if( lowest == remainingVars.end() || lowest_cost > cost ) { lowest = i; lowest_cost = cost; } } return *lowest; } size_t eliminationCost_MinNeighbors( const ClusterGraph &cl, size_t i ) { std::vector id_n = cl.G.delta1( i ); return id_n.size(); } size_t eliminationCost_MinWeight( const ClusterGraph &cl, size_t i ) { std::vector id_n = cl.G.delta1( i ); size_t cost = 1; for( size_t _i = 0; _i < id_n.size(); _i++ ) cost *= cl.vars[id_n[_i]].states(); return cost; } size_t eliminationCost_MinFill( const ClusterGraph &cl, size_t i ) { std::vector id_n = cl.G.delta1( i ); size_t cost = 0; // for each unordered pair {i1,i2} adjacent to n for( size_t _i1 = 0; _i1 < id_n.size(); _i1++ ) for( size_t _i2 = _i1 + 1; _i2 < id_n.size(); _i2++ ) { // if i1 and i2 are not adjacent, eliminating n would make them adjacent if( !cl.adj(id_n[_i1], id_n[_i2]) ) cost++; } return cost; } size_t eliminationCost_WeightedMinFill( const ClusterGraph &cl, size_t i ) { std::vector id_n = cl.G.delta1( i ); size_t cost = 0; // for each unordered pair {i1,i2} adjacent to n for( size_t _i1 = 0; _i1 < id_n.size(); _i1++ ) for( size_t _i2 = _i1 + 1; _i2 < id_n.size(); _i2++ ) { // if i1 and i2 are not adjacent, eliminating n would make them adjacent if( !cl.adj(id_n[_i1], id_n[_i2]) ) cost += cl.vars[id_n[_i1]].states() * cl.vars[id_n[_i2]].states(); } return cost; } } // end of namespace dai libDAI-0.2.4/src/varset.cpp0000644000263000017630000000232611334764774014277 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2002-2007 Radboud University Nijmegen, The Netherlands */ #include namespace dai { using namespace std; size_t calcLinearState( const VarSet &vs, const std::map &state ) { size_t prod = 1; size_t st = 0; for( VarSet::const_iterator v = vs.begin(); v != vs.end(); v++ ) { std::map::const_iterator m = state.find( *v ); if( m != state.end() ) st += prod * m->second; prod *= v->states(); } return st; } std::map calcState( const VarSet &vs, size_t linearState ) { std::map state; for( VarSet::const_iterator v = vs.begin(); v != vs.end(); v++ ) { state[*v] = linearState % v->states(); linearState /= v->states(); } DAI_ASSERT( linearState == 0 ); return state; } } // end of namespace dai libDAI-0.2.4/src/bbp.cpp0000644000263000017630000012173011334764774013537 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Frederik Eaton [frederik at ofb dot net] */ #include #include #include #include #include namespace dai { using namespace std; /// Convenience typedef typedef BipartiteGraph::Neighbor Neighbor; /// Returns the entry of the I'th factor corresponding to a global state size_t getFactorEntryForState( const FactorGraph &fg, size_t I, const vector &state ) { size_t f_entry = 0; for( int _j = fg.nbF(I).size() - 1; _j >= 0; _j-- ) { // note that iterating over nbF(I) yields the same ordering // of variables as iterating over factor(I).vars() size_t j = fg.nbF(I)[_j]; f_entry *= fg.var(j).states(); f_entry += state[j]; } return f_entry; } bool BBPCostFunction::needGibbsState() const { switch( (size_t)(*this) ) { case CFN_GIBBS_B: case CFN_GIBBS_B2: case CFN_GIBBS_EXP: case CFN_GIBBS_B_FACTOR: case CFN_GIBBS_B2_FACTOR: case CFN_GIBBS_EXP_FACTOR: return true; default: return false; } } Real BBPCostFunction::evaluate( const InfAlg &ia, const vector *stateP ) const { Real cf = 0.0; const FactorGraph &fg = ia.fg(); switch( (size_t)(*this) ) { case CFN_BETHE_ENT: // ignores state cf = -ia.logZ(); break; case CFN_VAR_ENT: // ignores state for( size_t i = 0; i < fg.nrVars(); i++ ) cf += -ia.beliefV(i).entropy(); break; case CFN_FACTOR_ENT: // ignores state for( size_t I = 0; I < fg.nrFactors(); I++ ) cf += -ia.beliefF(I).entropy(); break; case CFN_GIBBS_B: case CFN_GIBBS_B2: case CFN_GIBBS_EXP: { DAI_ASSERT( stateP != NULL ); vector state = *stateP; DAI_ASSERT( state.size() == fg.nrVars() ); for( size_t i = 0; i < fg.nrVars(); i++ ) { Real b = ia.beliefV(i)[state[i]]; switch( (size_t)(*this) ) { case CFN_GIBBS_B: cf += b; break; case CFN_GIBBS_B2: cf += b * b / 2.0; break; case CFN_GIBBS_EXP: cf += exp( b ); break; default: DAI_THROW(UNKNOWN_ENUM_VALUE); } } break; } case CFN_GIBBS_B_FACTOR: case CFN_GIBBS_B2_FACTOR: case CFN_GIBBS_EXP_FACTOR: { DAI_ASSERT( stateP != NULL ); vector state = *stateP; DAI_ASSERT( state.size() == fg.nrVars() ); for( size_t I = 0; I < fg.nrFactors(); I++ ) { size_t x_I = getFactorEntryForState( fg, I, state ); Real b = ia.beliefF(I)[x_I]; switch( (size_t)(*this) ) { case CFN_GIBBS_B_FACTOR: cf += b; break; case CFN_GIBBS_B2_FACTOR: cf += b * b / 2.0; break; case CFN_GIBBS_EXP_FACTOR: cf += exp( b ); break; default: DAI_THROW(UNKNOWN_ENUM_VALUE); } } break; } default: DAI_THROWE(UNKNOWN_ENUM_VALUE, "Unknown cost function " + std::string(*this)); } return cf; } #define LOOP_ij(body) { \ size_t i_states = _fg->var(i).states(); \ size_t j_states = _fg->var(j).states(); \ if(_fg->var(i) > _fg->var(j)) { \ size_t xij=0; \ for(size_t xi=0; xi _ind_t; // std::vector > _indices; _indices.resize( _fg->nrVars() ); for( size_t i = 0; i < _fg->nrVars(); i++ ) { _indices[i].clear(); _indices[i].reserve( _fg->nbV(i).size() ); foreach( const Neighbor &I, _fg->nbV(i) ) { _ind_t index; index.reserve( _fg->factor(I).states() ); for( IndexFor k(_fg->var(i), _fg->factor(I).vars()); k.valid(); ++k ) index.push_back( k ); _indices[i].push_back( index ); } } } void BBP::RegenerateT() { // _Tmsg[i][_I] _Tmsg.resize( _fg->nrVars() ); for( size_t i = 0; i < _fg->nrVars(); i++ ) { _Tmsg[i].resize( _fg->nbV(i).size() ); foreach( const Neighbor &I, _fg->nbV(i) ) { Prob prod( _fg->var(i).states(), 1.0 ); foreach( const Neighbor &J, _fg->nbV(i) ) if( J.node != I.node ) prod *= _bp_dual.msgM( i, J.iter ); _Tmsg[i][I.iter] = prod; } } } void BBP::RegenerateU() { // _Umsg[I][_i] _Umsg.resize( _fg->nrFactors() ); for( size_t I = 0; I < _fg->nrFactors(); I++ ) { _Umsg[I].resize( _fg->nbF(I).size() ); foreach( const Neighbor &i, _fg->nbF(I) ) { Prob prod( _fg->factor(I).states(), 1.0 ); foreach( const Neighbor &j, _fg->nbF(I) ) if( i.node != j.node ) { Prob n_jI( _bp_dual.msgN( j, j.dual ) ); const _ind_t &ind = _index( j, j.dual ); // multiply prod by n_jI for( size_t x_I = 0; x_I < prod.size(); x_I++ ) prod[x_I] *= n_jI[ind[x_I]]; } _Umsg[I][i.iter] = prod; } } } void BBP::RegenerateS() { // _Smsg[i][_I][_j] _Smsg.resize( _fg->nrVars() ); for( size_t i = 0; i < _fg->nrVars(); i++ ) { _Smsg[i].resize( _fg->nbV(i).size() ); foreach( const Neighbor &I, _fg->nbV(i) ) { _Smsg[i][I.iter].resize( _fg->nbF(I).size() ); foreach( const Neighbor &j, _fg->nbF(I) ) if( i != j ) { Factor prod( _fg->factor(I) ); foreach( const Neighbor &k, _fg->nbF(I) ) { if( k != i && k.node != j.node ) { const _ind_t &ind = _index( k, k.dual ); Prob p( _bp_dual.msgN( k, k.dual ) ); for( size_t x_I = 0; x_I < prod.states(); x_I++ ) prod.p()[x_I] *= p[ind[x_I]]; } } // "Marginalize" onto i|j (unnormalized) Prob marg; marg = prod.marginal( VarSet(_fg->var(i), _fg->var(j)), false ).p(); _Smsg[i][I.iter][j.iter] = marg; } } } } void BBP::RegenerateR() { // _Rmsg[I][_i][_J] _Rmsg.resize( _fg->nrFactors() ); for( size_t I = 0; I < _fg->nrFactors(); I++ ) { _Rmsg[I].resize( _fg->nbF(I).size() ); foreach( const Neighbor &i, _fg->nbF(I) ) { _Rmsg[I][i.iter].resize( _fg->nbV(i).size() ); foreach( const Neighbor &J, _fg->nbV(i) ) { if( I != J ) { Prob prod( _fg->var(i).states(), 1.0 ); foreach( const Neighbor &K, _fg->nbV(i) ) if( K.node != I && K.node != J.node ) prod *= _bp_dual.msgM( i, K.iter ); _Rmsg[I][i.iter][J.iter] = prod; } } } } } void BBP::RegenerateInputs() { _adj_b_V_unnorm.clear(); _adj_b_V_unnorm.reserve( _fg->nrVars() ); for( size_t i = 0; i < _fg->nrVars(); i++ ) _adj_b_V_unnorm.push_back( unnormAdjoint( _bp_dual.beliefV(i).p(), _bp_dual.beliefVZ(i), _adj_b_V[i] ) ); _adj_b_F_unnorm.clear(); _adj_b_F_unnorm.reserve( _fg->nrFactors() ); for( size_t I = 0; I < _fg->nrFactors(); I++ ) _adj_b_F_unnorm.push_back( unnormAdjoint( _bp_dual.beliefF(I).p(), _bp_dual.beliefFZ(I), _adj_b_F[I] ) ); } void BBP::RegeneratePsiAdjoints() { _adj_psi_V.clear(); _adj_psi_V.reserve( _fg->nrVars() ); for( size_t i = 0; i < _fg->nrVars(); i++ ) { Prob p( _adj_b_V_unnorm[i] ); DAI_ASSERT( p.size() == _fg->var(i).states() ); foreach( const Neighbor &I, _fg->nbV(i) ) p *= _bp_dual.msgM( i, I.iter ); p += _init_adj_psi_V[i]; _adj_psi_V.push_back( p ); } _adj_psi_F.clear(); _adj_psi_F.reserve( _fg->nrFactors() ); for( size_t I = 0; I < _fg->nrFactors(); I++ ) { Prob p( _adj_b_F_unnorm[I] ); DAI_ASSERT( p.size() == _fg->factor(I).states() ); foreach( const Neighbor &i, _fg->nbF(I) ) { Prob n_iI( _bp_dual.msgN( i, i.dual ) ); const _ind_t& ind = _index( i, i.dual ); // multiply prod with n_jI for( size_t x_I = 0; x_I < p.size(); x_I++ ) p[x_I] *= n_iI[ind[x_I]]; } p += _init_adj_psi_F[I]; _adj_psi_F.push_back( p ); } } void BBP::RegenerateParMessageAdjoints() { size_t nv = _fg->nrVars(); _adj_n.resize( nv ); _adj_m.resize( nv ); _adj_n_unnorm.resize( nv ); _adj_m_unnorm.resize( nv ); _new_adj_n.resize( nv ); _new_adj_m.resize( nv ); for( size_t i = 0; i < _fg->nrVars(); i++ ) { size_t n_i = _fg->nbV(i).size(); _adj_n[i].resize( n_i ); _adj_m[i].resize( n_i ); _adj_n_unnorm[i].resize( n_i ); _adj_m_unnorm[i].resize( n_i ); _new_adj_n[i].resize( n_i ); _new_adj_m[i].resize( n_i ); foreach( const Neighbor &I, _fg->nbV(i) ) { { // calculate adj_n Prob prod( _fg->factor(I).p() ); prod *= _adj_b_F_unnorm[I]; foreach( const Neighbor &j, _fg->nbF(I) ) if( i != j ) { Prob n_jI( _bp_dual.msgN( j, j.dual ) ); const _ind_t &ind = _index( j, j.dual ); // multiply prod with n_jI for( size_t x_I = 0; x_I < prod.size(); x_I++ ) prod[x_I] *= n_jI[ind[x_I]]; } Prob marg( _fg->var(i).states(), 0.0 ); const _ind_t &ind = _index( i, I.iter ); for( size_t r = 0; r < prod.size(); r++ ) marg[ind[r]] += prod[r]; _new_adj_n[i][I.iter] = marg; upMsgN( i, I.iter ); } { // calculate adj_m Prob prod( _adj_b_V_unnorm[i] ); DAI_ASSERT( prod.size() == _fg->var(i).states() ); foreach( const Neighbor &J, _fg->nbV(i) ) if( J.node != I.node ) prod *= _bp_dual.msgM(i,J.iter); _new_adj_m[i][I.iter] = prod; upMsgM( i, I.iter ); } } } } void BBP::RegenerateSeqMessageAdjoints() { size_t nv = _fg->nrVars(); _adj_m.resize( nv ); _adj_m_unnorm.resize( nv ); _new_adj_m.resize( nv ); for( size_t i = 0; i < _fg->nrVars(); i++ ) { size_t n_i = _fg->nbV(i).size(); _adj_m[i].resize( n_i ); _adj_m_unnorm[i].resize( n_i ); _new_adj_m[i].resize( n_i ); foreach( const Neighbor &I, _fg->nbV(i) ) { // calculate adj_m Prob prod( _adj_b_V_unnorm[i] ); DAI_ASSERT( prod.size() == _fg->var(i).states() ); foreach( const Neighbor &J, _fg->nbV(i) ) if( J.node != I.node ) prod *= _bp_dual.msgM( i, J.iter ); _adj_m[i][I.iter] = prod; calcUnnormMsgM( i, I.iter ); _new_adj_m[i][I.iter] = Prob( _fg->var(i).states(), 0.0 ); } } for( size_t i = 0; i < _fg->nrVars(); i++ ) { foreach( const Neighbor &I, _fg->nbV(i) ) { // calculate adj_n Prob prod( _fg->factor(I).p() ); prod *= _adj_b_F_unnorm[I]; foreach( const Neighbor &j, _fg->nbF(I) ) if( i != j ) { Prob n_jI( _bp_dual.msgN( j, j.dual) ); const _ind_t& ind = _index( j, j.dual ); // multiply prod with n_jI for( size_t x_I = 0; x_I < prod.size(); x_I++ ) prod[x_I] *= n_jI[ind[x_I]]; } Prob marg( _fg->var(i).states(), 0.0 ); const _ind_t &ind = _index( i, I.iter ); for( size_t r = 0; r < prod.size(); r++ ) marg[ind[r]] += prod[r]; sendSeqMsgN( i, I.iter,marg ); } } } void BBP::Regenerate() { RegenerateInds(); RegenerateT(); RegenerateU(); RegenerateS(); RegenerateR(); RegenerateInputs(); RegeneratePsiAdjoints(); if( props.updates == Properties::UpdateType::PAR ) RegenerateParMessageAdjoints(); else RegenerateSeqMessageAdjoints(); _iters = 0; } void BBP::calcNewN( size_t i, size_t _I ) { _adj_psi_V[i] += T(i,_I) * _adj_n_unnorm[i][_I]; Prob &new_adj_n_iI = _new_adj_n[i][_I]; new_adj_n_iI = Prob( _fg->var(i).states(), 0.0 ); size_t I = _fg->nbV(i)[_I]; foreach( const Neighbor &j, _fg->nbF(I) ) if( j != i ) { const Prob &p = _Smsg[i][_I][j.iter]; const Prob &_adj_m_unnorm_jI = _adj_m_unnorm[j][j.dual]; LOOP_ij( new_adj_n_iI[xi] += p[xij] * _adj_m_unnorm_jI[xj]; ); /* THE FOLLOWING WOULD BE ABOUT TWICE AS SLOW: Var vi = _fg->var(i); Var vj = _fg->var(j); new_adj_n_iI = (Factor(VarSet(vi, vj), p) * Factor(vj,_adj_m_unnorm_jI)).marginal(vi,false).p(); */ } } void BBP::calcNewM( size_t i, size_t _I ) { const Neighbor &I = _fg->nbV(i)[_I]; Prob p( U(I, I.dual) ); const Prob &adj = _adj_m_unnorm[i][_I]; const _ind_t &ind = _index(i,_I); for( size_t x_I = 0; x_I < p.size(); x_I++ ) p[x_I] *= adj[ind[x_I]]; _adj_psi_F[I] += p; /* THE FOLLOWING WOULD BE SLIGHTLY SLOWER: _adj_psi_F[I] += (Factor( _fg->factor(I).vars(), U(I, I.dual) ) * Factor( _fg->var(i), _adj_m_unnorm[i][_I] )).p(); */ _new_adj_m[i][_I] = Prob( _fg->var(i).states(), 0.0 ); foreach( const Neighbor &J, _fg->nbV(i) ) if( J != I ) _new_adj_m[i][_I] += _Rmsg[I][I.dual][J.iter] * _adj_n_unnorm[i][J.iter]; } void BBP::calcUnnormMsgN( size_t i, size_t _I ) { _adj_n_unnorm[i][_I] = unnormAdjoint( _bp_dual.msgN(i,_I), _bp_dual.zN(i,_I), _adj_n[i][_I] ); } void BBP::calcUnnormMsgM( size_t i, size_t _I ) { _adj_m_unnorm[i][_I] = unnormAdjoint( _bp_dual.msgM(i,_I), _bp_dual.zM(i,_I), _adj_m[i][_I] ); } void BBP::upMsgN( size_t i, size_t _I ) { _adj_n[i][_I] = _new_adj_n[i][_I]; calcUnnormMsgN( i, _I ); } void BBP::upMsgM( size_t i, size_t _I ) { _adj_m[i][_I] = _new_adj_m[i][_I]; calcUnnormMsgM( i, _I ); } void BBP::doParUpdate() { for( size_t i = 0; i < _fg->nrVars(); i++ ) foreach( const Neighbor &I, _fg->nbV(i) ) { calcNewM( i, I.iter ); calcNewN( i, I.iter ); } for( size_t i = 0; i < _fg->nrVars(); i++ ) foreach( const Neighbor &I, _fg->nbV(i) ) { upMsgM( i, I.iter ); upMsgN( i, I.iter ); } } void BBP::incrSeqMsgM( size_t i, size_t _I, const Prob &p ) { /* if( props.clean_updates ) _new_adj_m[i][_I] += p; else {*/ _adj_m[i][_I] += p; calcUnnormMsgM(i, _I); // } } #if 0 Real pv_thresh=1000; #endif /* void BBP::updateSeqMsgM( size_t i, size_t _I ) { if( props.clean_updates ) { #if 0 if(_new_adj_m[i][_I].sumAbs() > pv_thresh || _adj_m[i][_I].sumAbs() > pv_thresh) { DAI_DMSG("in updateSeqMsgM"); DAI_PV(i); DAI_PV(_I); DAI_PV(_adj_m[i][_I]); DAI_PV(_new_adj_m[i][_I]); } #endif _adj_m[i][_I] += _new_adj_m[i][_I]; calcUnnormMsgM( i, _I ); _new_adj_m[i][_I].fill( 0.0 ); } } */ void BBP::setSeqMsgM( size_t i, size_t _I, const Prob &p ) { _adj_m[i][_I] = p; calcUnnormMsgM( i, _I ); } void BBP::sendSeqMsgN( size_t i, size_t _I, const Prob &f ) { Prob f_unnorm = unnormAdjoint( _bp_dual.msgN(i,_I), _bp_dual.zN(i,_I), f ); const Neighbor &I = _fg->nbV(i)[_I]; DAI_ASSERT( I.iter == _I ); _adj_psi_V[i] += f_unnorm * T( i, _I ); #if 0 if(f_unnorm.sumAbs() > pv_thresh) { DAI_DMSG("in sendSeqMsgN"); DAI_PV(i); DAI_PV(I); DAI_PV(_I); DAI_PV(_bp_dual.msgN(i,_I)); DAI_PV(_bp_dual.zN(i,_I)); DAI_PV(_bp_dual.msgM(i,_I)); DAI_PV(_bp_dual.zM(i,_I)); DAI_PV(_fg->factor(I).p()); } #endif foreach( const Neighbor &J, _fg->nbV(i) ) { if( J.node != I.node ) { #if 0 if(f_unnorm.sumAbs() > pv_thresh) { DAI_DMSG("in sendSeqMsgN loop"); DAI_PV(J); DAI_PV(f_unnorm); DAI_PV(_Rmsg[J][J.dual][_I]); DAI_PV(f_unnorm * _Rmsg[J][J.dual][_I]); } #endif incrSeqMsgM( i, J.iter, f_unnorm * R(J, J.dual, _I) ); } } } void BBP::sendSeqMsgM( size_t j, size_t _I ) { const Neighbor &I = _fg->nbV(j)[_I]; // DAI_PV(j); // DAI_PV(I); // DAI_PV(_adj_m_unnorm_jI); // DAI_PV(_adj_m[j][_I]); // DAI_PV(_bp_dual.zM(j,_I)); size_t _j = I.dual; const Prob &_adj_m_unnorm_jI = _adj_m_unnorm[j][_I]; Prob um( U(I, _j) ); const _ind_t &ind = _index(j, _I); for( size_t x_I = 0; x_I < um.size(); x_I++ ) um[x_I] *= _adj_m_unnorm_jI[ind[x_I]]; um *= 1 - props.damping; _adj_psi_F[I] += um; /* THE FOLLOWING WOULD BE SLIGHTLY SLOWER: _adj_psi_F[I] += (Factor( _fg->factor(I).vars(), U(I, _j) ) * Factor( _fg->var(j), _adj_m_unnorm[j][_I] )).p() * (1.0 - props.damping); */ // DAI_DMSG("in sendSeqMsgM"); // DAI_PV(j); // DAI_PV(I); // DAI_PV(_I); // DAI_PV(_fg->nbF(I).size()); foreach( const Neighbor &i, _fg->nbF(I) ) { if( i.node != j ) { const Prob &S = _Smsg[i][i.dual][_j]; Prob msg( _fg->var(i).states(), 0.0 ); LOOP_ij( msg[xi] += S[xij] * _adj_m_unnorm_jI[xj]; ); msg *= 1.0 - props.damping; /* THE FOLLOWING WOULD BE ABOUT TWICE AS SLOW: Var vi = _fg->var(i); Var vj = _fg->var(j); msg = (Factor(VarSet(vi,vj), S) * Factor(vj,_adj_m_unnorm_jI)).marginal(vi,false).p() * (1.0 - props.damping); */ #if 0 if(msg.sumAbs() > pv_thresh) { DAI_DMSG("in sendSeqMsgM loop"); DAI_PV(j); DAI_PV(I); DAI_PV(_I); DAI_PV(_fg->nbF(I).size()); DAI_PV(_fg->factor(I).p()); DAI_PV(_Smsg[i][i.dual][_j]); DAI_PV(i); DAI_PV(i.dual); DAI_PV(msg); DAI_PV(_fg->nbV(i).size()); } #endif DAI_ASSERT( _fg->nbV(i)[i.dual].node == I ); sendSeqMsgN( i, i.dual, msg ); } } setSeqMsgM( j, _I, _adj_m[j][_I] * props.damping ); } Prob BBP::unnormAdjoint( const Prob &w, Real Z_w, const Prob &adj_w ) { DAI_ASSERT( w.size() == adj_w.size() ); Prob adj_w_unnorm( w.size(), 0.0 ); Real s = 0.0; for( size_t i = 0; i < w.size(); i++ ) s += w[i] * adj_w[i]; for( size_t i = 0; i < w.size(); i++ ) adj_w_unnorm[i] = (adj_w[i] - s) / Z_w; return adj_w_unnorm; // THIS WOULD BE ABOUT 50% SLOWER: return (adj_w - (w * adj_w).sum()) / Z_w; } Real BBP::getUnMsgMag() { Real s = 0.0; size_t e = 0; for( size_t i = 0; i < _fg->nrVars(); i++ ) foreach( const Neighbor &I, _fg->nbV(i) ) { s += _adj_m_unnorm[i][I.iter].sumAbs(); s += _adj_n_unnorm[i][I.iter].sumAbs(); e++; } return s / e; } void BBP::getMsgMags( Real &s, Real &new_s ) { s = 0.0; new_s = 0.0; size_t e = 0; for( size_t i = 0; i < _fg->nrVars(); i++ ) foreach( const Neighbor &I, _fg->nbV(i) ) { s += _adj_m[i][I.iter].sumAbs(); s += _adj_n[i][I.iter].sumAbs(); new_s += _new_adj_m[i][I.iter].sumAbs(); new_s += _new_adj_n[i][I.iter].sumAbs(); e++; } s /= e; new_s /= e; } // tuple BBP::getArgMaxPsi1Adj() { // size_t argmax_var=0; // size_t argmax_var_state=0; // Real max_var=0; // for( size_t i = 0; i < _fg->nrVars(); i++ ) { // pair argmax_state = adj_psi_V(i).argmax(); // if(i==0 || argmax_state.second>max_var) { // argmax_var = i; // max_var = argmax_state.second; // argmax_var_state = argmax_state.first; // } // } // DAI_ASSERT(/*0 <= argmax_var_state &&*/ // argmax_var_state < _fg->var(argmax_var).states()); // return tuple(argmax_var,argmax_var_state,max_var); // } void BBP::getArgmaxMsgM( size_t &out_i, size_t &out__I, Real &mag ) { bool found = false; for( size_t i = 0; i < _fg->nrVars(); i++ ) foreach( const Neighbor &I, _fg->nbV(i) ) { Real thisMag = _adj_m[i][I.iter].sumAbs(); if( !found || mag < thisMag ) { found = true; mag = thisMag; out_i = i; out__I = I.iter; } } DAI_ASSERT( found ); } Real BBP::getMaxMsgM() { size_t dummy; Real mag; getArgmaxMsgM( dummy, dummy, mag ); return mag; } Real BBP::getTotalMsgM() { Real mag = 0.0; for( size_t i = 0; i < _fg->nrVars(); i++ ) foreach( const Neighbor &I, _fg->nbV(i) ) mag += _adj_m[i][I.iter].sumAbs(); return mag; } Real BBP::getTotalNewMsgM() { Real mag = 0.0; for( size_t i = 0; i < _fg->nrVars(); i++ ) foreach( const Neighbor &I, _fg->nbV(i) ) mag += _new_adj_m[i][I.iter].sumAbs(); return mag; } Real BBP::getTotalMsgN() { Real mag = 0.0; for( size_t i = 0; i < _fg->nrVars(); i++ ) foreach( const Neighbor &I, _fg->nbV(i) ) mag += _adj_n[i][I.iter].sumAbs(); return mag; } std::vector BBP::getZeroAdjF( const FactorGraph &fg ) { vector adj_2; adj_2.reserve( fg.nrFactors() ); for( size_t I = 0; I < fg.nrFactors(); I++ ) adj_2.push_back( Prob( fg.factor(I).states(), 0.0 ) ); return adj_2; } std::vector BBP::getZeroAdjV( const FactorGraph &fg ) { vector adj_1; adj_1.reserve( fg.nrVars() ); for( size_t i = 0; i < fg.nrVars(); i++ ) adj_1.push_back( Prob( fg.var(i).states(), 0.0 ) ); return adj_1; } void BBP::initCostFnAdj( const BBPCostFunction &cfn, const vector *stateP ) { const FactorGraph &fg = _ia->fg(); switch( (size_t)cfn ) { case BBPCostFunction::CFN_BETHE_ENT: { vector b1_adj; vector b2_adj; vector psi1_adj; vector psi2_adj; b1_adj.reserve( fg.nrVars() ); psi1_adj.reserve( fg.nrVars() ); b2_adj.reserve( fg.nrFactors() ); psi2_adj.reserve( fg.nrFactors() ); for( size_t i = 0; i < fg.nrVars(); i++ ) { size_t dim = fg.var(i).states(); int c = fg.nbV(i).size(); Prob p(dim,0.0); for( size_t xi = 0; xi < dim; xi++ ) p[xi] = (1 - c) * (1 + log( _ia->beliefV(i)[xi] )); b1_adj.push_back( p ); for( size_t xi = 0; xi < dim; xi++ ) p[xi] = -_ia->beliefV(i)[xi]; psi1_adj.push_back( p ); } for( size_t I = 0; I < fg.nrFactors(); I++ ) { size_t dim = fg.factor(I).states(); Prob p( dim, 0.0 ); for( size_t xI = 0; xI < dim; xI++ ) p[xI] = 1 + log( _ia->beliefF(I)[xI] / fg.factor(I).p()[xI] ); b2_adj.push_back( p ); for( size_t xI = 0; xI < dim; xI++ ) p[xI] = -_ia->beliefF(I)[xI] / fg.factor(I).p()[xI]; psi2_adj.push_back( p ); } init( b1_adj, b2_adj, psi1_adj, psi2_adj ); break; } case BBPCostFunction::CFN_FACTOR_ENT: { vector b2_adj; b2_adj.reserve( fg.nrFactors() ); for( size_t I = 0; I < fg.nrFactors(); I++ ) { size_t dim = fg.factor(I).states(); Prob p( dim, 0.0 ); for( size_t xI = 0; xI < dim; xI++ ) { Real bIxI = _ia->beliefF(I)[xI]; if( bIxI < 1.0e-15 ) p[xI] = -1.0e10; else p[xI] = 1 + log( bIxI ); } b2_adj.push_back(p); } init_F( b2_adj ); break; } case BBPCostFunction::CFN_VAR_ENT: { vector b1_adj; b1_adj.reserve( fg.nrVars() ); for( size_t i = 0; i < fg.nrVars(); i++ ) { size_t dim = fg.var(i).states(); Prob p( dim, 0.0 ); for( size_t xi = 0; xi < fg.var(i).states(); xi++ ) { Real bixi = _ia->beliefV(i)[xi]; if( bixi < 1.0e-15 ) p[xi] = -1.0e10; else p[xi] = 1 + log( bixi ); } b1_adj.push_back( p ); } init_V( b1_adj ); break; } case BBPCostFunction::CFN_GIBBS_B: case BBPCostFunction::CFN_GIBBS_B2: case BBPCostFunction::CFN_GIBBS_EXP: { // cost functions that use Gibbs sample, summing over variable marginals vector state; if( stateP == NULL ) state = getGibbsState( _ia->fg(), 2*_ia->Iterations() ); else state = *stateP; DAI_ASSERT( state.size() == fg.nrVars() ); vector b1_adj; b1_adj.reserve(fg.nrVars()); for( size_t i = 0; i < state.size(); i++ ) { size_t n = fg.var(i).states(); Prob delta( n, 0.0 ); DAI_ASSERT(/*0<=state[i] &&*/ state[i] < n); Real b = _ia->beliefV(i)[state[i]]; switch( (size_t)cfn ) { case BBPCostFunction::CFN_GIBBS_B: delta[state[i]] = 1.0; break; case BBPCostFunction::CFN_GIBBS_B2: delta[state[i]] = b; break; case BBPCostFunction::CFN_GIBBS_EXP: delta[state[i]] = exp(b); break; default: DAI_THROW(UNKNOWN_ENUM_VALUE); } b1_adj.push_back( delta ); } init_V( b1_adj ); break; } case BBPCostFunction::CFN_GIBBS_B_FACTOR: case BBPCostFunction::CFN_GIBBS_B2_FACTOR: case BBPCostFunction::CFN_GIBBS_EXP_FACTOR: { // cost functions that use Gibbs sample, summing over factor marginals vector state; if( stateP == NULL ) state = getGibbsState( _ia->fg(), 2*_ia->Iterations() ); else state = *stateP; DAI_ASSERT( state.size() == fg.nrVars() ); vector b2_adj; b2_adj.reserve( fg.nrVars() ); for( size_t I = 0; I < fg.nrFactors(); I++ ) { size_t n = fg.factor(I).states(); Prob delta( n, 0.0 ); size_t x_I = getFactorEntryForState( fg, I, state ); DAI_ASSERT(/*0<=x_I &&*/ x_I < n); Real b = _ia->beliefF(I)[x_I]; switch( (size_t)cfn ) { case BBPCostFunction::CFN_GIBBS_B_FACTOR: delta[x_I] = 1.0; break; case BBPCostFunction::CFN_GIBBS_B2_FACTOR: delta[x_I] = b; break; case BBPCostFunction::CFN_GIBBS_EXP_FACTOR: delta[x_I] = exp( b ); break; default: DAI_THROW(UNKNOWN_ENUM_VALUE); } b2_adj.push_back( delta ); } init_F( b2_adj ); break; } default: DAI_THROW(UNKNOWN_ENUM_VALUE); } } void BBP::run() { typedef BBP::Properties::UpdateType UT; Real tol = props.tol; UT &updates = props.updates; Real tic = toc(); switch( (size_t)updates ) { case UT::SEQ_MAX: { size_t i, _I; Real mag; do { _iters++; getArgmaxMsgM( i, _I, mag ); sendSeqMsgM( i, _I ); } while( mag > tol && _iters < props.maxiter ); if( _iters >= props.maxiter ) if( props.verbose >= 1 ) cerr << "Warning: BBP didn't converge in " << _iters << " iterations (greatest message magnitude = " << mag << ")" << endl; break; } case UT::SEQ_FIX: { Real mag; do { _iters++; mag = getTotalMsgM(); if( mag < tol ) break; for( size_t i = 0; i < _fg->nrVars(); i++ ) foreach( const Neighbor &I, _fg->nbV(i) ) sendSeqMsgM( i, I.iter ); /* for( size_t i = 0; i < _fg->nrVars(); i++ ) foreach( const Neighbor &I, _fg->nbV(i) ) updateSeqMsgM( i, I.iter );*/ } while( mag > tol && _iters < props.maxiter ); if( _iters >= props.maxiter ) if( props.verbose >= 1 ) cerr << "Warning: BBP didn't converge in " << _iters << " iterations (greatest message magnitude = " << mag << ")" << endl; break; } case UT::SEQ_BP_REV: case UT::SEQ_BP_FWD: { const BP *bp = static_cast(_ia); vector > sentMessages = bp->getSentMessages(); size_t totalMessages = sentMessages.size(); if( totalMessages == 0 ) DAI_THROWE(INTERNAL_ERROR, "Asked for updates=" + std::string(updates) + " but no BP messages; did you forget to set recordSentMessages?"); if( updates==UT::SEQ_BP_FWD ) reverse( sentMessages.begin(), sentMessages.end() ); // DAI_PV(sentMessages.size()); // DAI_PV(_iters); // DAI_PV(props.maxiter); while( sentMessages.size() > 0 && _iters < props.maxiter ) { // DAI_PV(sentMessages.size()); // DAI_PV(_iters); _iters++; pair e = sentMessages.back(); sentMessages.pop_back(); size_t i = e.first, _I = e.second; sendSeqMsgM( i, _I ); } if( _iters >= props.maxiter ) if( props.verbose >= 1 ) cerr << "Warning: BBP updates limited to " << props.maxiter << " iterations, but using UpdateType " << updates << " with " << totalMessages << " messages" << endl; break; } case UT::PAR: { do { _iters++; doParUpdate(); } while( (_iters < 2 || getUnMsgMag() > tol) && _iters < props.maxiter ); if( _iters == props.maxiter ) { Real s, new_s; getMsgMags( s, new_s ); if( props.verbose >= 1 ) cerr << "Warning: BBP didn't converge in " << _iters << " iterations (unnorm message magnitude = " << getUnMsgMag() << ", norm message mags = " << s << " -> " << new_s << ")" << endl; } break; } } if( props.verbose >= 3 ) cerr << "BBP::run() took " << toc()-tic << " seconds " << Iterations() << " iterations" << endl; } Real numericBBPTest( const InfAlg &bp, const std::vector *state, const PropertySet &bbp_props, const BBPCostFunction &cfn, Real h ) { BBP bbp( &bp, bbp_props ); // calculate the value of the unperturbed cost function Real cf0 = cfn.evaluate( bp, state ); // run BBP to estimate adjoints bbp.initCostFnAdj( cfn, state ); bbp.run(); Real d = 0; const FactorGraph& fg = bp.fg(); if( 1 ) { // verify bbp.adj_psi_V // for each variable i for( size_t i = 0; i < fg.nrVars(); i++ ) { vector adj_est; // for each value xi for( size_t xi = 0; xi < fg.var(i).states(); xi++ ) { // Clone 'bp' (which may be any InfAlg) InfAlg *bp_prb = bp.clone(); // perturb it size_t n = bp_prb->fg().var(i).states(); Prob psi_1_prb( n, 1.0 ); psi_1_prb[xi] += h; // psi_1_prb.normalize(); size_t I = bp_prb->fg().nbV(i)[0]; // use first factor in list of neighbors of i bp_prb->fg().factor(I) *= Factor( bp_prb->fg().var(i), psi_1_prb ); // call 'init' on the perturbed variables bp_prb->init( bp_prb->fg().var(i) ); // run copy to convergence bp_prb->run(); // calculate new value of cost function Real cf_prb = cfn.evaluate( *bp_prb, state ); // use to estimate adjoint for i adj_est.push_back( (cf_prb - cf0) / h ); // free cloned InfAlg delete bp_prb; } Prob p_adj_est( adj_est ); // compare this numerical estimate to the BBP estimate; sum the distances cout << "i: " << i << ", p_adj_est: " << p_adj_est << ", bbp.adj_psi_V(i): " << bbp.adj_psi_V(i) << endl; d += dist( p_adj_est, bbp.adj_psi_V(i), Prob::DISTL1 ); } } /* if(1) { // verify bbp.adj_n and bbp.adj_m // We actually want to check the responsiveness of objective // function to changes in the final messages. But at the end of a // BBP run, the message adjoints are for the initial messages (and // they should be close to zero, see paper). So this resets the // BBP adjoints to the refer to the desired final messages bbp.RegenerateMessageAdjoints(); // for each variable i for(size_t i=0; i adj_n_est; // for each value xi for(size_t xi=0; xi adj_m_est; // for each value xi for(size_t xi=0; xi adj_b_V_est; // for each value xi for(size_t xi=0; xi &keys = opts.keys(); std::string errormsg; for( std::set::const_iterator i = keys.begin(); i != keys.end(); i++ ) { if( *i == "verbose" ) continue; if( *i == "maxiter" ) continue; if( *i == "tol" ) continue; if( *i == "damping" ) continue; if( *i == "updates" ) continue; errormsg = errormsg + "BBP: Unknown property " + *i + "\n"; } if( !errormsg.empty() ) DAI_THROWE(UNKNOWN_PROPERTY, errormsg); if( !opts.hasKey("verbose") ) errormsg = errormsg + "BBP: Missing property \"verbose\" for method \"BBP\"\n"; if( !opts.hasKey("maxiter") ) errormsg = errormsg + "BBP: Missing property \"maxiter\" for method \"BBP\"\n"; if( !opts.hasKey("tol") ) errormsg = errormsg + "BBP: Missing property \"tol\" for method \"BBP\"\n"; if( !opts.hasKey("damping") ) errormsg = errormsg + "BBP: Missing property \"damping\" for method \"BBP\"\n"; if( !opts.hasKey("updates") ) errormsg = errormsg + "BBP: Missing property \"updates\" for method \"BBP\"\n"; if( !errormsg.empty() ) DAI_THROWE(NOT_ALL_PROPERTIES_SPECIFIED,errormsg); verbose = opts.getStringAs("verbose"); maxiter = opts.getStringAs("maxiter"); tol = opts.getStringAs("tol"); damping = opts.getStringAs("damping"); updates = opts.getStringAs("updates"); } PropertySet BBP::Properties::get() const { PropertySet opts; opts.Set("verbose", verbose); opts.Set("maxiter", maxiter); opts.Set("tol", tol); opts.Set("damping", damping); opts.Set("updates", updates); return opts; } string BBP::Properties::toString() const { stringstream s(stringstream::out); s << "["; s << "verbose=" << verbose << ","; s << "maxiter=" << maxiter << ","; s << "tol=" << tol << ","; s << "damping=" << damping << ","; s << "updates=" << updates; s << "]"; return s.str(); } } // end of namespace dai /* }}} END OF GENERATED CODE */ libDAI-0.2.4/src/daialg.cpp0000644000263000017630000001666011334764774014222 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include namespace dai { using namespace std; Factor calcMarginal( const InfAlg &obj, const VarSet &vs, bool reInit ) { Factor Pvs (vs); InfAlg *clamped = obj.clone(); if( !reInit ) clamped->init(); map varindices; for( VarSet::const_iterator n = vs.begin(); n != vs.end(); n++ ) varindices[*n] = obj.fg().findVar( *n ); Real logZ0 = -INFINITY; for( State s(vs); s.valid(); s++ ) { // save unclamped factors connected to vs clamped->backupFactors( vs ); // set clamping Factors to delta functions for( VarSet::const_iterator n = vs.begin(); n != vs.end(); n++ ) clamped->clamp( varindices[*n], s(*n) ); // run DAIAlg, calc logZ, store in Pvs if( reInit ) clamped->init(); else clamped->init(vs); Real logZ; try { clamped->run(); logZ = clamped->logZ(); } catch( Exception &e ) { if( e.code() == Exception::NOT_NORMALIZABLE ) logZ = -INFINITY; else throw; } if( logZ0 == -INFINITY ) if( logZ != -INFINITY ) logZ0 = logZ; if( logZ == -INFINITY ) Pvs[s] = 0; else Pvs[s] = exp(logZ - logZ0); // subtract logZ0 to avoid very large numbers // restore clamped factors clamped->restoreFactors( vs ); } delete clamped; return( Pvs.normalized() ); } vector calcPairBeliefs( const InfAlg & obj, const VarSet& vs, bool reInit, bool accurate ) { vector result; size_t N = vs.size(); result.reserve( N * (N - 1) / 2 ); InfAlg *clamped = obj.clone(); if( !reInit ) clamped->init(); map varindices; for( VarSet::const_iterator v = vs.begin(); v != vs.end(); v++ ) varindices[*v] = obj.fg().findVar( *v ); if( accurate ) { Real logZ0 = 0.0; VarSet::const_iterator nj = vs.begin(); for( long j = 0; j < (long)N - 1; j++, nj++ ) { size_t k = 0; for( VarSet::const_iterator nk = nj; (++nk) != vs.end(); k++ ) { Factor pairbelief( VarSet(*nj, *nk) ); // clamp Vars j and k to their possible values for( size_t j_val = 0; j_val < nj->states(); j_val++ ) for( size_t k_val = 0; k_val < nk->states(); k_val++ ) { // save unclamped factors connected to vs clamped->backupFactors( vs ); clamped->clamp( varindices[*nj], j_val ); clamped->clamp( varindices[*nk], k_val ); if( reInit ) clamped->init(); else clamped->init(vs); Real logZ; try { clamped->run(); logZ = clamped->logZ(); } catch( Exception &e ) { if( e.code() == Exception::NOT_NORMALIZABLE ) logZ = -INFINITY; else throw; } if( logZ0 == -INFINITY ) if( logZ != -INFINITY ) logZ0 = logZ; Real Z_xj; if( logZ == -INFINITY ) Z_xj = 0; else Z_xj = exp(logZ - logZ0); // subtract logZ0 to avoid very large numbers // we assume that j.label() < k.label() // i.e. we make an assumption here about the indexing pairbelief[j_val + (k_val * nj->states())] = Z_xj; // restore clamped factors clamped->restoreFactors( vs ); } result.push_back( pairbelief.normalized() ); } } } else { // convert vs to vector vector vvs( vs.begin(), vs.end() ); vector pairbeliefs; pairbeliefs.reserve( N * N ); for( size_t j = 0; j < N; j++ ) for( size_t k = 0; k < N; k++ ) if( j == k ) pairbeliefs.push_back( Factor() ); else pairbeliefs.push_back( Factor( VarSet(vvs[j], vvs[k]) ) ); Real logZ0 = -INFINITY; for( size_t j = 0; j < N; j++ ) { // clamp Var j to its possible values for( size_t j_val = 0; j_val < vvs[j].states(); j_val++ ) { clamped->clamp( varindices[vvs[j]], j_val, true ); if( reInit ) clamped->init(); else clamped->init(vs); Real logZ; try { clamped->run(); logZ = clamped->logZ(); } catch( Exception &e ) { if( e.code() == Exception::NOT_NORMALIZABLE ) logZ = -INFINITY; else throw; } if( logZ0 == -INFINITY ) if( logZ != -INFINITY ) logZ0 = logZ; Real Z_xj; if( logZ == -INFINITY ) Z_xj = 0; else Z_xj = exp(logZ - logZ0); // subtract logZ0 to avoid very large numbers for( size_t k = 0; k < N; k++ ) if( k != j ) { Factor b_k = clamped->belief(vvs[k]); for( size_t k_val = 0; k_val < vvs[k].states(); k_val++ ) if( vvs[j].label() < vvs[k].label() ) pairbeliefs[j * N + k][j_val + (k_val * vvs[j].states())] = Z_xj * b_k[k_val]; else pairbeliefs[j * N + k][k_val + (j_val * vvs[k].states())] = Z_xj * b_k[k_val]; } // restore clamped factors clamped->restoreFactors( vs ); } } // Calculate result by taking the geometric average for( size_t j = 0; j < N; j++ ) for( size_t k = j+1; k < N; k++ ) result.push_back( ((pairbeliefs[j * N + k] * pairbeliefs[k * N + j]) ^ 0.5).normalized() ); } delete clamped; return result; } std::vector calcPairBeliefsNew( const InfAlg& obj, const VarSet& vs, bool reInit ) { return calcPairBeliefs( obj, vs, reInit, true ); } Factor calcMarginal2ndO( const InfAlg & obj, const VarSet& vs, bool reInit ) { vector pairbeliefs = calcPairBeliefs( obj, vs, reInit ); Factor Pvs (vs); for( size_t ij = 0; ij < pairbeliefs.size(); ij++ ) Pvs *= pairbeliefs[ij]; return( Pvs.normalized() ); } } // end of namespace dai libDAI-0.2.4/src/fbp.cpp0000644000263000017630000001201111334764774013532 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Frederik Eaton [frederik at ofb dot net] * Copyright (C) 2009-2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #define DAI_FBP_FAST 1 namespace dai { using namespace std; const char *FBP::Name = "FBP"; string FBP::identify() const { return string(Name) + printProperties(); } // This code has been copied from bp.cpp, except where comments indicate FBP-specific behaviour Real FBP::logZ() const { Real sum = 0.0; for( size_t I = 0; I < nrFactors(); I++ ) { sum += (beliefF(I) * factor(I).log(true)).sum(); // FBP sum += Weight(I) * beliefF(I).entropy(); // FBP } for( size_t i = 0; i < nrVars(); ++i ) { Real c_i = 0.0; foreach( const Neighbor &I, nbV(i) ) c_i += Weight(I); sum += (1.0 - c_i) * beliefV(i).entropy(); // FBP } return sum; } // This code has been copied from bp.cpp, except where comments indicate FBP-specific behaviour Prob FBP::calcIncomingMessageProduct( size_t I, bool without_i, size_t i ) const { Real c_I = Weight(I); // FBP: c_I Factor Fprod( factor(I) ); Prob &prod = Fprod.p(); if( props.logdomain ) { prod.takeLog(); prod /= c_I; // FBP } else prod ^= (1.0 / c_I); // FBP // Calculate product of incoming messages and factor I foreach( const Neighbor &j, nbF(I) ) if( !(without_i && (j == i)) ) { // prod_j will be the product of messages coming into j // FBP: corresponds to messages n_jI Prob prod_j( var(j).states(), props.logdomain ? 0.0 : 1.0 ); foreach( const Neighbor &J, nbV(j) ) if( J != I ) { // for all J in nb(j) \ I if( props.logdomain ) prod_j += message( j, J.iter ); else prod_j *= message( j, J.iter ); } else { // FBP: multiply by m_Ij^(1-1/c_I) if( props.logdomain ) prod_j += newMessage( j, J.iter) * (1.0 - 1.0 / c_I); else prod_j *= newMessage( j, J.iter) ^ (1.0 - 1.0 / c_I); } // multiply prod with prod_j if( !DAI_FBP_FAST ) { // UNOPTIMIZED (SIMPLE TO READ, BUT SLOW) VERSION if( props.logdomain ) Fprod += Factor( var(j), prod_j ); else Fprod *= Factor( var(j), prod_j ); } else { // OPTIMIZED VERSION size_t _I = j.dual; // ind is the precalculated IndexFor(j,I) i.e. to x_I == k corresponds x_j == ind[k] const ind_t &ind = index(j, _I); for( size_t r = 0; r < prod.size(); ++r ) if( props.logdomain ) prod[r] += prod_j[ind[r]]; else prod[r] *= prod_j[ind[r]]; } } return prod; } // This code has been copied from bp.cpp, except where comments indicate FBP-specific behaviour void FBP::calcNewMessage( size_t i, size_t _I ) { // calculate updated message I->i size_t I = nbV(i,_I); Real c_I = Weight(I); // FBP: c_I Factor Fprod( factor(I) ); Prob &prod = Fprod.p(); prod = calcIncomingMessageProduct( I, true, i ); if( props.logdomain ) { prod -= prod.max(); prod.takeExp(); } // Marginalize onto i Prob marg; if( !DAI_FBP_FAST ) { // UNOPTIMIZED (SIMPLE TO READ, BUT SLOW) VERSION if( props.inference == Properties::InfType::SUMPROD ) marg = Fprod.marginal( var(i) ).p(); else marg = Fprod.maxMarginal( var(i) ).p(); } else { // OPTIMIZED VERSION marg = Prob( var(i).states(), 0.0 ); // ind is the precalculated IndexFor(i,I) i.e. to x_I == k corresponds x_i == ind[k] const ind_t ind = index(i,_I); if( props.inference == Properties::InfType::SUMPROD ) for( size_t r = 0; r < prod.size(); ++r ) marg[ind[r]] += prod[r]; else for( size_t r = 0; r < prod.size(); ++r ) if( prod[r] > marg[ind[r]] ) marg[ind[r]] = prod[r]; marg.normalize(); } // FBP marg ^= c_I; // Store result if( props.logdomain ) newMessage(i,_I) = marg.log(); else newMessage(i,_I) = marg; // Update the residual if necessary if( props.updates == Properties::UpdateType::SEQMAX ) updateResidual( i, _I , dist( newMessage( i, _I ), message( i, _I ), Prob::DISTLINF ) ); } void FBP::construct() { BP::construct(); _weight.resize( nrFactors(), 1.0 ); } } // end of namespace dai libDAI-0.2.4/src/treeep.cpp0000644000263000017630000003155111334764774014261 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include #include #include namespace dai { using namespace std; const char *TreeEP::Name = "TREEEP"; void TreeEP::setProperties( const PropertySet &opts ) { DAI_ASSERT( opts.hasKey("tol") ); DAI_ASSERT( opts.hasKey("maxiter") ); DAI_ASSERT( opts.hasKey("verbose") ); DAI_ASSERT( opts.hasKey("type") ); props.tol = opts.getStringAs("tol"); props.maxiter = opts.getStringAs("maxiter"); props.verbose = opts.getStringAs("verbose"); props.type = opts.getStringAs("type"); } PropertySet TreeEP::getProperties() const { PropertySet opts; opts.Set( "tol", props.tol ); opts.Set( "maxiter", props.maxiter ); opts.Set( "verbose", props.verbose ); opts.Set( "type", props.type ); return opts; } string TreeEP::printProperties() const { stringstream s( stringstream::out ); s << "["; s << "tol=" << props.tol << ","; s << "maxiter=" << props.maxiter << ","; s << "verbose=" << props.verbose << ","; s << "type=" << props.type << "]"; return s.str(); } TreeEP::TreeEP( const FactorGraph &fg, const PropertySet &opts ) : JTree(fg, opts("updates",string("HUGIN")), false), _maxdiff(0.0), _iters(0), props(), _Q() { setProperties( opts ); if( !isConnected() ) DAI_THROW(FACTORGRAPH_NOT_CONNECTED); if( opts.hasKey("tree") ) { construct( opts.GetAs("tree") ); } else { if( props.type == Properties::TypeType::ORG || props.type == Properties::TypeType::ALT ) { // ORG: construct weighted graph with as weights a crude estimate of the // mutual information between the nodes // ALT: construct weighted graph with as weights an upper bound on the // effective interaction strength between pairs of nodes WeightedGraph wg; for( size_t i = 0; i < nrVars(); ++i ) { Var v_i = var(i); VarSet di = delta(i); for( VarSet::const_iterator j = di.begin(); j != di.end(); j++ ) if( v_i < *j ) { VarSet ij(v_i,*j); Factor piet; for( size_t I = 0; I < nrFactors(); I++ ) { VarSet Ivars = factor(I).vars(); if( props.type == Properties::TypeType::ORG ) { if( (Ivars == v_i) || (Ivars == *j) ) piet *= factor(I); else if( Ivars >> ij ) piet *= factor(I).marginal( ij ); } else { if( Ivars >> ij ) piet *= factor(I); } } if( props.type == Properties::TypeType::ORG ) { if( piet.vars() >> ij ) { piet = piet.marginal( ij ); Factor pietf = piet.marginal(v_i) * piet.marginal(*j); wg[UEdge(i,findVar(*j))] = dist( piet, pietf, Prob::DISTKL ); } else wg[UEdge(i,findVar(*j))] = 0; } else { wg[UEdge(i,findVar(*j))] = piet.strength(v_i, *j); } } } // find maximal spanning tree construct( MaxSpanningTreePrims( wg ) ); } else DAI_THROW(UNKNOWN_ENUM_VALUE); } } void TreeEP::construct( const RootedTree &tree ) { vector cl; for( size_t i = 0; i < tree.size(); i++ ) cl.push_back( VarSet( var(tree[i].n1), var(tree[i].n2) ) ); // If no outer region can be found subsuming that factor, label the // factor as off-tree. JTree::construct( cl, false ); if( props.verbose >= 1 ) cerr << "TreeEP::construct: The tree has size " << JTree::RTree.size() << endl; if( props.verbose >= 3 ) cerr << " it is " << JTree::RTree << " with cliques " << cl << endl; // Create factor approximations _Q.clear(); size_t PreviousRoot = (size_t)-1; // Second repetition: previous root of first off-tree factor should be the root of the last off-tree factor for( size_t repeats = 0; repeats < 2; repeats++ ) for( size_t I = 0; I < nrFactors(); I++ ) if( offtree(I) ) { // find efficient subtree RootedTree subTree; size_t subTreeSize = findEfficientTree( factor(I).vars(), subTree, PreviousRoot ); PreviousRoot = subTree[0].n1; subTree.resize( subTreeSize ); if( props.verbose >= 1 ) cerr << "Subtree " << I << " has size " << subTreeSize << endl; if( props.verbose >= 3 ) cerr << " it is " << subTree << endl; _Q[I] = TreeEPSubTree( subTree, RTree, Qa, Qb, &factor(I) ); if( repeats == 1 ) break; } if( props.verbose >= 3 ) cerr << "Resulting regiongraph: " << *this << endl; } string TreeEP::identify() const { return string(Name) + printProperties(); } void TreeEP::init() { runHUGIN(); // Init factor approximations for( size_t I = 0; I < nrFactors(); I++ ) if( offtree(I) ) _Q[I].init(); } Real TreeEP::run() { if( props.verbose >= 1 ) cerr << "Starting " << identify() << "..."; if( props.verbose >= 3 ) cerr << endl; double tic = toc(); vector oldBeliefs = beliefs(); // do several passes over the network until maximum number of iterations has // been reached or until the maximum belief difference is smaller than tolerance Real maxDiff = INFINITY; for( _iters = 0; _iters < props.maxiter && maxDiff > props.tol; _iters++ ) { for( size_t I = 0; I < nrFactors(); I++ ) if( offtree(I) ) { _Q[I].InvertAndMultiply( Qa, Qb ); _Q[I].HUGIN_with_I( Qa, Qb ); _Q[I].InvertAndMultiply( Qa, Qb ); } // calculate new beliefs and compare with old ones vector newBeliefs = beliefs(); maxDiff = -INFINITY; for( size_t t = 0; t < oldBeliefs.size(); t++ ) maxDiff = std::max( maxDiff, dist( newBeliefs[t], oldBeliefs[t], Prob::DISTLINF ) ); swap( newBeliefs, oldBeliefs ); if( props.verbose >= 3 ) cerr << Name << "::run: maxdiff " << maxDiff << " after " << _iters+1 << " passes" << endl; } if( maxDiff > _maxdiff ) _maxdiff = maxDiff; if( props.verbose >= 1 ) { if( maxDiff > props.tol ) { if( props.verbose == 1 ) cerr << endl; cerr << Name << "::run: WARNING: not converged within " << props.maxiter << " passes (" << toc() - tic << " seconds)...final maxdiff:" << maxDiff << endl; } else { if( props.verbose >= 3 ) cerr << Name << "::run: "; cerr << "converged in " << _iters << " passes (" << toc() - tic << " seconds)." << endl; } } return maxDiff; } Real TreeEP::logZ() const { Real s = 0.0; // entropy of the tree for( size_t beta = 0; beta < nrIRs(); beta++ ) s -= Qb[beta].entropy(); for( size_t alpha = 0; alpha < nrORs(); alpha++ ) s += Qa[alpha].entropy(); // energy of the on-tree factors for( size_t alpha = 0; alpha < nrORs(); alpha++ ) s += (OR(alpha).log(true) * Qa[alpha]).sum(); // energy of the off-tree factors for( size_t I = 0; I < nrFactors(); I++ ) if( offtree(I) ) s += (_Q.find(I))->second.logZ( Qa, Qb ); return s; } TreeEP::TreeEPSubTree::TreeEPSubTree( const RootedTree &subRTree, const RootedTree &jt_RTree, const std::vector &jt_Qa, const std::vector &jt_Qb, const Factor *I ) : _Qa(), _Qb(), _RTree(), _a(), _b(), _I(I), _ns(), _nsrem(), _logZ(0.0) { _ns = _I->vars(); // Make _Qa, _Qb, _a and _b corresponding to the subtree _b.reserve( subRTree.size() ); _Qb.reserve( subRTree.size() ); _RTree.reserve( subRTree.size() ); for( size_t i = 0; i < subRTree.size(); i++ ) { size_t alpha1 = subRTree[i].n1; // old index 1 size_t alpha2 = subRTree[i].n2; // old index 2 size_t beta; // old sep index for( beta = 0; beta < jt_RTree.size(); beta++ ) if( UEdge( jt_RTree[beta].n1, jt_RTree[beta].n2 ) == UEdge( alpha1, alpha2 ) ) break; DAI_ASSERT( beta != jt_RTree.size() ); size_t newalpha1 = find(_a.begin(), _a.end(), alpha1) - _a.begin(); if( newalpha1 == _a.size() ) { _Qa.push_back( Factor( jt_Qa[alpha1].vars(), 1.0 ) ); _a.push_back( alpha1 ); // save old index in index conversion table } size_t newalpha2 = find(_a.begin(), _a.end(), alpha2) - _a.begin(); if( newalpha2 == _a.size() ) { _Qa.push_back( Factor( jt_Qa[alpha2].vars(), 1.0 ) ); _a.push_back( alpha2 ); // save old index in index conversion table } _RTree.push_back( DEdge( newalpha1, newalpha2 ) ); _Qb.push_back( Factor( jt_Qb[beta].vars(), 1.0 ) ); _b.push_back( beta ); } // Find remaining variables (which are not in the new root) _nsrem = _ns / _Qa[0].vars(); } void TreeEP::TreeEPSubTree::init() { for( size_t alpha = 0; alpha < _Qa.size(); alpha++ ) _Qa[alpha].fill( 1.0 ); for( size_t beta = 0; beta < _Qb.size(); beta++ ) _Qb[beta].fill( 1.0 ); } void TreeEP::TreeEPSubTree::InvertAndMultiply( const std::vector &Qa, const std::vector &Qb ) { for( size_t alpha = 0; alpha < _Qa.size(); alpha++ ) _Qa[alpha] = Qa[_a[alpha]] / _Qa[alpha]; for( size_t beta = 0; beta < _Qb.size(); beta++ ) _Qb[beta] = Qb[_b[beta]] / _Qb[beta]; } void TreeEP::TreeEPSubTree::HUGIN_with_I( std::vector &Qa, std::vector &Qb ) { // Backup _Qa and _Qb vector _Qa_old(_Qa); vector _Qb_old(_Qb); // Clear Qa and Qb for( size_t alpha = 0; alpha < _Qa.size(); alpha++ ) Qa[_a[alpha]].fill( 0.0 ); for( size_t beta = 0; beta < _Qb.size(); beta++ ) Qb[_b[beta]].fill( 0.0 ); // For all states of _nsrem for( State s(_nsrem); s.valid(); s++ ) { // Multiply root with slice of I _Qa[0] *= _I->slice( _nsrem, s ); // CollectEvidence for( size_t i = _RTree.size(); (i--) != 0; ) { // clamp variables in nsrem for( VarSet::const_iterator n = _nsrem.begin(); n != _nsrem.end(); n++ ) if( _Qa[_RTree[i].n2].vars() >> *n ) { Factor delta( *n, 0.0 ); delta[s(*n)] = 1.0; _Qa[_RTree[i].n2] *= delta; } Factor new_Qb = _Qa[_RTree[i].n2].marginal( _Qb[i].vars(), false ); _Qa[_RTree[i].n1] *= new_Qb / _Qb[i]; _Qb[i] = new_Qb; } // DistributeEvidence for( size_t i = 0; i < _RTree.size(); i++ ) { Factor new_Qb = _Qa[_RTree[i].n1].marginal( _Qb[i].vars(), false ); _Qa[_RTree[i].n2] *= new_Qb / _Qb[i]; _Qb[i] = new_Qb; } // Store Qa's and Qb's for( size_t alpha = 0; alpha < _Qa.size(); alpha++ ) Qa[_a[alpha]].p() += _Qa[alpha].p(); for( size_t beta = 0; beta < _Qb.size(); beta++ ) Qb[_b[beta]].p() += _Qb[beta].p(); // Restore _Qa and _Qb _Qa = _Qa_old; _Qb = _Qb_old; } // Normalize Qa and Qb _logZ = 0.0; for( size_t alpha = 0; alpha < _Qa.size(); alpha++ ) { _logZ += log(Qa[_a[alpha]].sum()); Qa[_a[alpha]].normalize(); } for( size_t beta = 0; beta < _Qb.size(); beta++ ) { _logZ -= log(Qb[_b[beta]].sum()); Qb[_b[beta]].normalize(); } } Real TreeEP::TreeEPSubTree::logZ( const std::vector &Qa, const std::vector &Qb ) const { Real s = 0.0; for( size_t alpha = 0; alpha < _Qa.size(); alpha++ ) s += (Qa[_a[alpha]] * _Qa[alpha].log(true)).sum(); for( size_t beta = 0; beta < _Qb.size(); beta++ ) s -= (Qb[_b[beta]] * _Qb[beta].log(true)).sum(); return s + _logZ; } } // end of namespace dai libDAI-0.2.4/src/jtree.cpp0000644000263000017630000005201511334764774014104 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include namespace dai { using namespace std; const char *JTree::Name = "JTREE"; void JTree::setProperties( const PropertySet &opts ) { DAI_ASSERT( opts.hasKey("verbose") ); DAI_ASSERT( opts.hasKey("updates") ); props.verbose = opts.getStringAs("verbose"); props.updates = opts.getStringAs("updates"); if( opts.hasKey("inference") ) props.inference = opts.getStringAs("inference"); else props.inference = Properties::InfType::SUMPROD; if( opts.hasKey("heuristic") ) props.heuristic = opts.getStringAs("heuristic"); else props.heuristic = Properties::HeuristicType::MINFILL; } PropertySet JTree::getProperties() const { PropertySet opts; opts.Set( "verbose", props.verbose ); opts.Set( "updates", props.updates ); opts.Set( "inference", props.inference ); opts.Set( "heuristic", props.heuristic ); return opts; } string JTree::printProperties() const { stringstream s( stringstream::out ); s << "["; s << "verbose=" << props.verbose << ","; s << "updates=" << props.updates << ","; s << "heuristic=" << props.heuristic << ","; s << "inference=" << props.inference << "]"; return s.str(); } JTree::JTree( const FactorGraph &fg, const PropertySet &opts, bool automatic ) : DAIAlgRG(fg), _mes(), _logZ(), RTree(), Qa(), Qb(), props() { setProperties( opts ); if( !isConnected() ) DAI_THROW(FACTORGRAPH_NOT_CONNECTED); if( automatic ) { // Create ClusterGraph which contains factors as clusters vector cl; cl.reserve( fg.nrFactors() ); for( size_t I = 0; I < nrFactors(); I++ ) cl.push_back( factor(I).vars() ); ClusterGraph _cg( cl ); if( props.verbose >= 3 ) cerr << "Initial clusters: " << _cg << endl; // Retain only maximal clusters _cg.eraseNonMaximal(); if( props.verbose >= 3 ) cerr << "Maximal clusters: " << _cg << endl; // Use heuristic to guess optimal elimination sequence greedyVariableElimination::eliminationCostFunction ec(NULL); switch( (size_t)props.heuristic ) { case Properties::HeuristicType::MINNEIGHBORS: ec = eliminationCost_MinNeighbors; break; case Properties::HeuristicType::MINWEIGHT: ec = eliminationCost_MinWeight; break; case Properties::HeuristicType::MINFILL: ec = eliminationCost_MinFill; break; case Properties::HeuristicType::WEIGHTEDMINFILL: ec = eliminationCost_WeightedMinFill; break; default: DAI_THROW(UNKNOWN_ENUM_VALUE); } vector ElimVec = _cg.VarElim( greedyVariableElimination( ec ) ).eraseNonMaximal().toVector(); if( props.verbose >= 3 ) cerr << "VarElim result: " << ElimVec << endl; // Generate the junction tree corresponding to the elimination sequence GenerateJT( ElimVec ); } } void JTree::construct( const std::vector &cl, bool verify ) { // Construct a weighted graph (each edge is weighted with the cardinality // of the intersection of the nodes, where the nodes are the elements of cl). WeightedGraph JuncGraph; for( size_t i = 0; i < cl.size(); i++ ) for( size_t j = i+1; j < cl.size(); j++ ) { size_t w = (cl[i] & cl[j]).size(); if( w ) JuncGraph[UEdge(i,j)] = w; } // Construct maximal spanning tree using Prim's algorithm RTree = MaxSpanningTreePrims( JuncGraph ); // Construct corresponding region graph // Create outer regions ORs.clear(); ORs.reserve( cl.size() ); for( size_t i = 0; i < cl.size(); i++ ) ORs.push_back( FRegion( Factor(cl[i], 1.0), 1.0 ) ); // For each factor, find an outer region that subsumes that factor. // Then, multiply the outer region with that factor. fac2OR.clear(); fac2OR.resize( nrFactors(), -1U ); for( size_t I = 0; I < nrFactors(); I++ ) { size_t alpha; for( alpha = 0; alpha < nrORs(); alpha++ ) if( OR(alpha).vars() >> factor(I).vars() ) { fac2OR[I] = alpha; break; } if( verify ) DAI_ASSERT( alpha != nrORs() ); } RecomputeORs(); // Create inner regions and edges IRs.clear(); IRs.reserve( RTree.size() ); vector edges; edges.reserve( 2 * RTree.size() ); for( size_t i = 0; i < RTree.size(); i++ ) { edges.push_back( Edge( RTree[i].n1, nrIRs() ) ); edges.push_back( Edge( RTree[i].n2, nrIRs() ) ); // inner clusters have counting number -1 IRs.push_back( Region( cl[RTree[i].n1] & cl[RTree[i].n2], -1.0 ) ); } // create bipartite graph G.construct( nrORs(), nrIRs(), edges.begin(), edges.end() ); // Check counting numbers #ifdef DAI_DEBUG checkCountingNumbers(); #endif // Create beliefs Qa.clear(); Qa.reserve( nrORs() ); for( size_t alpha = 0; alpha < nrORs(); alpha++ ) Qa.push_back( OR(alpha) ); Qb.clear(); Qb.reserve( nrIRs() ); for( size_t beta = 0; beta < nrIRs(); beta++ ) Qb.push_back( Factor( IR(beta), 1.0 ) ); } void JTree::GenerateJT( const std::vector &cl ) { construct( cl, true ); // Create messages _mes.clear(); _mes.reserve( nrORs() ); for( size_t alpha = 0; alpha < nrORs(); alpha++ ) { _mes.push_back( vector() ); _mes[alpha].reserve( nbOR(alpha).size() ); foreach( const Neighbor &beta, nbOR(alpha) ) _mes[alpha].push_back( Factor( IR(beta), 1.0 ) ); } if( props.verbose >= 3 ) cerr << "Regiongraph generated by JTree::GenerateJT: " << *this << endl; } string JTree::identify() const { return string(Name) + printProperties(); } Factor JTree::belief( const VarSet &vs ) const { vector::const_iterator beta; for( beta = Qb.begin(); beta != Qb.end(); beta++ ) if( beta->vars() >> vs ) break; if( beta != Qb.end() ) return( beta->marginal(vs) ); else { vector::const_iterator alpha; for( alpha = Qa.begin(); alpha != Qa.end(); alpha++ ) if( alpha->vars() >> vs ) break; if( alpha == Qa.end() ) { DAI_THROW(BELIEF_NOT_AVAILABLE); return Factor(); } else return( alpha->marginal(vs) ); } } vector JTree::beliefs() const { vector result; for( size_t beta = 0; beta < nrIRs(); beta++ ) result.push_back( Qb[beta] ); for( size_t alpha = 0; alpha < nrORs(); alpha++ ) result.push_back( Qa[alpha] ); return result; } void JTree::runHUGIN() { for( size_t alpha = 0; alpha < nrORs(); alpha++ ) Qa[alpha] = OR(alpha); for( size_t beta = 0; beta < nrIRs(); beta++ ) Qb[beta].fill( 1.0 ); // CollectEvidence _logZ = 0.0; for( size_t i = RTree.size(); (i--) != 0; ) { // Make outer region RTree[i].n1 consistent with outer region RTree[i].n2 // IR(i) = seperator OR(RTree[i].n1) && OR(RTree[i].n2) Factor new_Qb; if( props.inference == Properties::InfType::SUMPROD ) new_Qb = Qa[RTree[i].n2].marginal( IR( i ), false ); else new_Qb = Qa[RTree[i].n2].maxMarginal( IR( i ), false ); _logZ += log(new_Qb.normalize()); Qa[RTree[i].n1] *= new_Qb / Qb[i]; Qb[i] = new_Qb; } if( RTree.empty() ) _logZ += log(Qa[0].normalize() ); else _logZ += log(Qa[RTree[0].n1].normalize()); // DistributeEvidence for( size_t i = 0; i < RTree.size(); i++ ) { // Make outer region RTree[i].n2 consistent with outer region RTree[i].n1 // IR(i) = seperator OR(RTree[i].n1) && OR(RTree[i].n2) Factor new_Qb; if( props.inference == Properties::InfType::SUMPROD ) new_Qb = Qa[RTree[i].n1].marginal( IR( i ) ); else new_Qb = Qa[RTree[i].n1].maxMarginal( IR( i ) ); Qa[RTree[i].n2] *= new_Qb / Qb[i]; Qb[i] = new_Qb; } // Normalize for( size_t alpha = 0; alpha < nrORs(); alpha++ ) Qa[alpha].normalize(); } void JTree::runShaferShenoy() { // First pass _logZ = 0.0; for( size_t e = nrIRs(); (e--) != 0; ) { // send a message from RTree[e].n2 to RTree[e].n1 // or, actually, from the seperator IR(e) to RTree[e].n1 size_t i = nbIR(e)[1].node; // = RTree[e].n2 size_t j = nbIR(e)[0].node; // = RTree[e].n1 size_t _e = nbIR(e)[0].dual; Factor msg = OR(i); foreach( const Neighbor &k, nbOR(i) ) if( k != e ) msg *= message( i, k.iter ); if( props.inference == Properties::InfType::SUMPROD ) message( j, _e ) = msg.marginal( IR(e), false ); else message( j, _e ) = msg.maxMarginal( IR(e), false ); _logZ += log( message(j,_e).normalize() ); } // Second pass for( size_t e = 0; e < nrIRs(); e++ ) { size_t i = nbIR(e)[0].node; // = RTree[e].n1 size_t j = nbIR(e)[1].node; // = RTree[e].n2 size_t _e = nbIR(e)[1].dual; Factor msg = OR(i); foreach( const Neighbor &k, nbOR(i) ) if( k != e ) msg *= message( i, k.iter ); if( props.inference == Properties::InfType::SUMPROD ) message( j, _e ) = msg.marginal( IR(e) ); else message( j, _e ) = msg.maxMarginal( IR(e) ); } // Calculate beliefs for( size_t alpha = 0; alpha < nrORs(); alpha++ ) { Factor piet = OR(alpha); foreach( const Neighbor &k, nbOR(alpha) ) piet *= message( alpha, k.iter ); if( nrIRs() == 0 ) { _logZ += log( piet.normalize() ); Qa[alpha] = piet; } else if( alpha == nbIR(0)[0].node /*RTree[0].n1*/ ) { _logZ += log( piet.normalize() ); Qa[alpha] = piet; } else Qa[alpha] = piet.normalized(); } // Only for logZ (and for belief)... for( size_t beta = 0; beta < nrIRs(); beta++ ) { if( props.inference == Properties::InfType::SUMPROD ) Qb[beta] = Qa[nbIR(beta)[0].node].marginal( IR(beta) ); else Qb[beta] = Qa[nbIR(beta)[0].node].maxMarginal( IR(beta) ); } } Real JTree::run() { if( props.updates == Properties::UpdateType::HUGIN ) runHUGIN(); else if( props.updates == Properties::UpdateType::SHSH ) runShaferShenoy(); return 0.0; } Real JTree::logZ() const { /* Real s = 0.0; for( size_t beta = 0; beta < nrIRs(); beta++ ) s += IR(beta).c() * Qb[beta].entropy(); for( size_t alpha = 0; alpha < nrORs(); alpha++ ) { s += OR(alpha).c() * Qa[alpha].entropy(); s += (OR(alpha).log(true) * Qa[alpha]).sum(); } DAI_ASSERT( abs( _logZ - s ) < 1e-8 ); return s;*/ return _logZ; } size_t JTree::findEfficientTree( const VarSet& vs, RootedTree &Tree, size_t PreviousRoot ) const { // find new root clique (the one with maximal statespace overlap with vs) size_t maxval = 0, maxalpha = 0; for( size_t alpha = 0; alpha < nrORs(); alpha++ ) { size_t val = VarSet(vs & OR(alpha).vars()).nrStates(); if( val > maxval ) { maxval = val; maxalpha = alpha; } } // reorder the tree edges such that maxalpha becomes the new root RootedTree newTree( GraphEL( RTree.begin(), RTree.end() ), maxalpha ); // identify subtree that contains all variables of vs which are not in the new root set subTree; // for each variable in vs for( VarSet::const_iterator n = vs.begin(); n != vs.end(); n++ ) { for( size_t e = 0; e < newTree.size(); e++ ) { if( OR(newTree[e].n2).vars().contains( *n ) ) { size_t f = e; subTree.insert( newTree[f] ); size_t pos = newTree[f].n1; for( ; f > 0; f-- ) if( newTree[f-1].n2 == pos ) { subTree.insert( newTree[f-1] ); pos = newTree[f-1].n1; } } } } if( PreviousRoot != (size_t)-1 && PreviousRoot != maxalpha) { // find first occurence of PreviousRoot in the tree, which is closest to the new root size_t e = 0; for( ; e != newTree.size(); e++ ) { if( newTree[e].n2 == PreviousRoot ) break; } DAI_ASSERT( e != newTree.size() ); // track-back path to root and add edges to subTree subTree.insert( newTree[e] ); size_t pos = newTree[e].n1; for( ; e > 0; e-- ) if( newTree[e-1].n2 == pos ) { subTree.insert( newTree[e-1] ); pos = newTree[e-1].n1; } } // Resulting Tree is a reordered copy of newTree // First add edges in subTree to Tree Tree.clear(); vector remTree; for( RootedTree::const_iterator e = newTree.begin(); e != newTree.end(); e++ ) if( subTree.count( *e ) ) Tree.push_back( *e ); else remTree.push_back( *e ); size_t subTreeSize = Tree.size(); // Then add remaining edges copy( remTree.begin(), remTree.end(), back_inserter( Tree ) ); return subTreeSize; } Factor JTree::calcMarginal( const VarSet& vs ) { vector::const_iterator beta; for( beta = Qb.begin(); beta != Qb.end(); beta++ ) if( beta->vars() >> vs ) break; if( beta != Qb.end() ) return( beta->marginal(vs) ); else { vector::const_iterator alpha; for( alpha = Qa.begin(); alpha != Qa.end(); alpha++ ) if( alpha->vars() >> vs ) break; if( alpha != Qa.end() ) return( alpha->marginal(vs) ); else { // Find subtree to do efficient inference RootedTree T; size_t Tsize = findEfficientTree( vs, T ); // Find remaining variables (which are not in the new root) VarSet vsrem = vs / OR(T.front().n1).vars(); Factor Pvs (vs, 0.0); // Save Qa and Qb on the subtree map Qa_old; map Qb_old; vector b(Tsize, 0); for( size_t i = Tsize; (i--) != 0; ) { size_t alpha1 = T[i].n1; size_t alpha2 = T[i].n2; size_t beta; for( beta = 0; beta < nrIRs(); beta++ ) if( UEdge( RTree[beta].n1, RTree[beta].n2 ) == UEdge( alpha1, alpha2 ) ) break; DAI_ASSERT( beta != nrIRs() ); b[i] = beta; if( !Qa_old.count( alpha1 ) ) Qa_old[alpha1] = Qa[alpha1]; if( !Qa_old.count( alpha2 ) ) Qa_old[alpha2] = Qa[alpha2]; if( !Qb_old.count( beta ) ) Qb_old[beta] = Qb[beta]; } // For all states of vsrem for( State s(vsrem); s.valid(); s++ ) { // CollectEvidence Real logZ = 0.0; for( size_t i = Tsize; (i--) != 0; ) { // Make outer region T[i].n1 consistent with outer region T[i].n2 // IR(i) = seperator OR(T[i].n1) && OR(T[i].n2) for( VarSet::const_iterator n = vsrem.begin(); n != vsrem.end(); n++ ) if( Qa[T[i].n2].vars() >> *n ) { Factor piet( *n, 0.0 ); piet[s(*n)] = 1.0; Qa[T[i].n2] *= piet; } Factor new_Qb = Qa[T[i].n2].marginal( IR( b[i] ), false ); logZ += log(new_Qb.normalize()); Qa[T[i].n1] *= new_Qb / Qb[b[i]]; Qb[b[i]] = new_Qb; } logZ += log(Qa[T[0].n1].normalize()); Factor piet( vsrem, 0.0 ); piet[s] = exp(logZ); Pvs += piet * Qa[T[0].n1].marginal( vs / vsrem, false ); // OPTIMIZE ME // Restore clamped beliefs for( map::const_iterator alpha = Qa_old.begin(); alpha != Qa_old.end(); alpha++ ) Qa[alpha->first] = alpha->second; for( map::const_iterator beta = Qb_old.begin(); beta != Qb_old.end(); beta++ ) Qb[beta->first] = beta->second; } return( Pvs.normalized() ); } } } std::pair boundTreewidth( const FactorGraph &fg, greedyVariableElimination::eliminationCostFunction fn ) { ClusterGraph _cg; // Copy factors for( size_t I = 0; I < fg.nrFactors(); I++ ) _cg.insert( fg.factor(I).vars() ); // Retain only maximal clusters _cg.eraseNonMaximal(); // Obtain elimination sequence vector ElimVec = _cg.VarElim( greedyVariableElimination( fn ) ).eraseNonMaximal().toVector(); // Calculate treewidth size_t treewidth = 0; double nrstates = 0.0; for( size_t i = 0; i < ElimVec.size(); i++ ) { if( ElimVec[i].size() > treewidth ) treewidth = ElimVec[i].size(); size_t s = ElimVec[i].nrStates(); if( s > nrstates ) nrstates = s; } return make_pair(treewidth, nrstates); } std::vector JTree::findMaximum() const { vector maximum( nrVars() ); vector visitedVars( nrVars(), false ); vector visitedFactors( nrFactors(), false ); stack scheduledFactors; for( size_t i = 0; i < nrVars(); ++i ) { if( visitedVars[i] ) continue; visitedVars[i] = true; // Maximise with respect to variable i Prob prod = beliefV(i).p(); maximum[i] = prod.argmax().first; foreach( const Neighbor &I, nbV(i) ) if( !visitedFactors[I] ) scheduledFactors.push(I); while( !scheduledFactors.empty() ){ size_t I = scheduledFactors.top(); scheduledFactors.pop(); if( visitedFactors[I] ) continue; visitedFactors[I] = true; // Evaluate if some neighboring variables still need to be fixed; if not, we're done bool allDetermined = true; foreach( const Neighbor &j, nbF(I) ) if( !visitedVars[j.node] ) { allDetermined = false; break; } if( allDetermined ) continue; // Calculate product of incoming messages on factor I Prob prod2 = beliefF(I).p(); // The allowed configuration is restrained according to the variables assigned so far: // pick the argmax amongst the allowed states Real maxProb = numeric_limits::min(); State maxState( factor(I).vars() ); for( State s( factor(I).vars() ); s.valid(); ++s ){ // First, calculate whether this state is consistent with variables that // have been assigned already bool allowedState = true; foreach( const Neighbor &j, nbF(I) ) if( visitedVars[j.node] && maximum[j.node] != s(var(j.node)) ) { allowedState = false; break; } // If it is consistent, check if its probability is larger than what we have seen so far if( allowedState && prod2[s] > maxProb ) { maxState = s; maxProb = prod2[s]; } } // Decode the argmax foreach( const Neighbor &j, nbF(I) ) { if( visitedVars[j.node] ) { // We have already visited j earlier - hopefully our state is consistent if( maximum[j.node] != maxState(var(j.node)) && props.verbose >= 1 ) cerr << "JTree::findMaximum - warning: maximum not consistent due to loops." << endl; } else { // We found a consistent state for variable j visitedVars[j.node] = true; maximum[j.node] = maxState( var(j.node) ); foreach( const Neighbor &J, nbV(j) ) if( !visitedFactors[J] ) scheduledFactors.push(J); } } } } return maximum; } } // end of namespace dai libDAI-0.2.4/src/emalg.cpp0000644000263000017630000002366111334764774014065 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Charles Vaske [cvaske at soe dot ucsc dot edu] * Copyright (C) 2009 University of California, Santa Cruz */ #include #include namespace dai { // Initialize static private member of ParameterEstimation std::map *ParameterEstimation::_registry = NULL; void ParameterEstimation::loadDefaultRegistry() { _registry = new std::map(); (*_registry)["CondProbEstimation"] = CondProbEstimation::factory; } ParameterEstimation* ParameterEstimation::construct( const std::string &method, const PropertySet &p ) { if( _registry == NULL ) loadDefaultRegistry(); std::map::iterator i = _registry->find(method); if( i == _registry->end() ) DAI_THROWE(UNKNOWN_PARAMETER_ESTIMATION_METHOD, "Unknown parameter estimation method: " + method); ParamEstFactory factory = i->second; return factory(p); } ParameterEstimation* CondProbEstimation::factory( const PropertySet &p ) { size_t target_dimension = p.getStringAs("target_dim"); size_t total_dimension = p.getStringAs("total_dim"); Real pseudo_count = 1; if( p.hasKey("pseudo_count") ) pseudo_count = p.getStringAs("pseudo_count"); return new CondProbEstimation( target_dimension, Prob( total_dimension, pseudo_count ) ); } CondProbEstimation::CondProbEstimation( size_t target_dimension, const Prob &pseudocounts ) : _target_dim(target_dimension), _stats(pseudocounts), _initial_stats(pseudocounts) { DAI_ASSERT( !(_stats.size() % _target_dim) ); } void CondProbEstimation::addSufficientStatistics( const Prob &p ) { _stats += p; } Prob CondProbEstimation::estimate() { // normalize pseudocounts for( size_t parent = 0; parent < _stats.size(); parent += _target_dim ) { // calculate norm size_t top = parent + _target_dim; Real norm = std::accumulate( &(_stats[parent]), &(_stats[parent]) + _target_dim, 0.0 ); if( norm != 0.0 ) norm = 1.0 / norm; // normalize for( size_t i = parent; i < top; ++i ) _stats[i] *= norm; } // reset _stats to _initial_stats Prob result = _stats; _stats = _initial_stats; return result; } Permute SharedParameters::calculatePermutation( const std::vector &varOrder, VarSet &outVS ) { outVS = VarSet( varOrder.begin(), varOrder.end(), varOrder.size() ); return Permute( varOrder ); } void SharedParameters::setPermsAndVarSetsFromVarOrders() { if( _varorders.size() == 0 ) return; DAI_ASSERT( _estimation != NULL ); // Construct the permutation objects and the varsets for( FactorOrientations::const_iterator foi = _varorders.begin(); foi != _varorders.end(); ++foi ) { VarSet vs; _perms[foi->first] = calculatePermutation( foi->second, vs ); _varsets[foi->first] = vs; DAI_ASSERT( _estimation->probSize() == vs.nrStates() ); } } SharedParameters::SharedParameters( const FactorOrientations &varorders, ParameterEstimation *estimation, bool ownPE ) : _varsets(), _perms(), _varorders(varorders), _estimation(estimation), _ownEstimation(ownPE) { // Calculate the necessary permutations and varsets setPermsAndVarSetsFromVarOrders(); } SharedParameters::SharedParameters( std::istream &is, const FactorGraph &fg ) : _varsets(), _perms(), _varorders(), _estimation(NULL), _ownEstimation(true) { // Read the desired parameter estimation method from the stream std::string est_method; PropertySet props; is >> est_method; is >> props; // Construct a corresponding object _estimation = ParameterEstimation::construct( est_method, props ); // Read in the factors that are to be estimated size_t num_factors; is >> num_factors; for( size_t sp_i = 0; sp_i < num_factors; ++sp_i ) { std::string line; while( line.size() == 0 && getline(is, line) ) ; std::vector fields; tokenizeString(line, fields, " \t"); // Lookup the factor in the factorgraph if( fields.size() < 1 ) DAI_THROWE(INVALID_EMALG_FILE,"Empty line unexpected"); std::istringstream iss; iss.str( fields[0] ); size_t factor; iss >> factor; const VarSet &vs = fg.factor(factor).vars(); if( fields.size() != vs.size() + 1 ) DAI_THROWE(INVALID_EMALG_FILE,"Number of fields does not match factor size"); // Construct the vector of Vars std::vector var_order; var_order.reserve( vs.size() ); for( size_t fi = 1; fi < fields.size(); ++fi ) { // Lookup a single variable by label size_t label; std::istringstream labelparse( fields[fi] ); labelparse >> label; VarSet::const_iterator vsi = vs.begin(); for( ; vsi != vs.end(); ++vsi ) if( vsi->label() == label ) break; if( vsi == vs.end() ) DAI_THROWE(INVALID_EMALG_FILE,"Specified variables do not match the factor variables"); var_order.push_back( *vsi ); } _varorders[factor] = var_order; } // Calculate the necessary permutations setPermsAndVarSetsFromVarOrders(); } void SharedParameters::collectSufficientStatistics( InfAlg &alg ) { for( std::map< FactorIndex, Permute >::iterator i = _perms.begin(); i != _perms.end(); ++i ) { Permute &perm = i->second; VarSet &vs = _varsets[i->first]; Factor b = alg.belief(vs); Prob p( b.states(), 0.0 ); for( size_t entry = 0; entry < b.states(); ++entry ) p[entry] = b[perm.convertLinearIndex(entry)]; // apply inverse permutation _estimation->addSufficientStatistics( p ); } } void SharedParameters::setParameters( FactorGraph &fg ) { Prob p = _estimation->estimate(); for( std::map::iterator i = _perms.begin(); i != _perms.end(); ++i ) { Permute &perm = i->second; VarSet &vs = _varsets[i->first]; Factor f( vs, 0.0 ); for( size_t entry = 0; entry < f.states(); ++entry ) f[perm.convertLinearIndex(entry)] = p[entry]; fg.setFactor( i->first, f ); } } MaximizationStep::MaximizationStep( std::istream &is, const FactorGraph &fg_varlookup ) : _params() { size_t num_params = -1; is >> num_params; _params.reserve( num_params ); for( size_t i = 0; i < num_params; ++i ) _params.push_back( SharedParameters( is, fg_varlookup ) ); } void MaximizationStep::addExpectations( InfAlg &alg ) { for( size_t i = 0; i < _params.size(); ++i ) _params[i].collectSufficientStatistics( alg ); } void MaximizationStep::maximize( FactorGraph &fg ) { for( size_t i = 0; i < _params.size(); ++i ) _params[i].setParameters( fg ); } const std::string EMAlg::MAX_ITERS_KEY("max_iters"); const std::string EMAlg::LOG_Z_TOL_KEY("log_z_tol"); const size_t EMAlg::MAX_ITERS_DEFAULT = 30; const Real EMAlg::LOG_Z_TOL_DEFAULT = 0.01; EMAlg::EMAlg( const Evidence &evidence, InfAlg &estep, std::istream &msteps_file ) : _evidence(evidence), _estep(estep), _msteps(), _iters(0), _lastLogZ(), _max_iters(MAX_ITERS_DEFAULT), _log_z_tol(LOG_Z_TOL_DEFAULT) { msteps_file.exceptions( std::istream::eofbit | std::istream::failbit | std::istream::badbit ); size_t num_msteps = -1; msteps_file >> num_msteps; _msteps.reserve(num_msteps); for( size_t i = 0; i < num_msteps; ++i ) _msteps.push_back( MaximizationStep( msteps_file, estep.fg() ) ); } void EMAlg::setTermConditions( const PropertySet &p ) { if( p.hasKey(MAX_ITERS_KEY) ) _max_iters = p.getStringAs(MAX_ITERS_KEY); if( p.hasKey(LOG_Z_TOL_KEY) ) _log_z_tol = p.getStringAs(LOG_Z_TOL_KEY); } bool EMAlg::hasSatisfiedTermConditions() const { if( _iters >= _max_iters ) return true; else if( _lastLogZ.size() < 3 ) // need at least 2 to calculate ratio // Also, throw away first iteration, as the parameters may not // have been normalized according to the estimation method return false; else { Real current = _lastLogZ[_lastLogZ.size() - 1]; Real previous = _lastLogZ[_lastLogZ.size() - 2]; if( previous == 0 ) return false; Real diff = current - previous; if( diff < 0 ) { std::cerr << "Error: in EM log-likehood decreased from " << previous << " to " << current << std::endl; return true; } return (diff / fabs(previous)) <= _log_z_tol; } } Real EMAlg::iterate( MaximizationStep &mstep ) { Real logZ = 0; Real likelihood = 0; _estep.run(); logZ = _estep.logZ(); // Expectation calculation for( Evidence::const_iterator e = _evidence.begin(); e != _evidence.end(); ++e ) { InfAlg* clamped = _estep.clone(); // Apply evidence for( Evidence::Observation::const_iterator i = e->begin(); i != e->end(); ++i ) clamped->clamp( clamped->fg().findVar(i->first), i->second ); clamped->init(); clamped->run(); likelihood += clamped->logZ() - logZ; mstep.addExpectations( *clamped ); delete clamped; } // Maximization of parameters mstep.maximize( _estep.fg() ); return likelihood; } Real EMAlg::iterate() { Real likelihood; for( size_t i = 0; i < _msteps.size(); ++i ) likelihood = iterate( _msteps[i] ); _lastLogZ.push_back( likelihood ); ++_iters; return likelihood; } void EMAlg::run() { while( !hasSatisfiedTermConditions() ) iterate(); } } // end of namespace dai libDAI-0.2.4/src/util.cpp0000644000263000017630000000631111334764774013746 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include #include #ifdef WINDOWS #include #include // for atanh #include // for log1p #include // for _isnan #else // Assume POSIX compliant system. We need the following for querying the system time #include #endif #ifdef CYGWIN bool isnan( double x ) { return __isnand( x ); // isnan() is a macro in Cygwin (as required by C99) } #endif #ifdef WINDOWS bool isnan( double x ) { return _isnan( x ); } double atanh( double x ) { return boost::math::atanh( x ); } double log1p( double x ) { return boost::math::log1p( x ); } #endif namespace dai { Real max( const std::vector &v ) { if( v.size() == 0 ) return INFINITY; else return *std::max_element( v.begin(), v.end() ); } // Returns user+system time in seconds double toc() { #ifdef WINDOWS SYSTEMTIME tbuf; GetSystemTime(&tbuf); return( (double)(tbuf.wSecond + (double)tbuf.wMilliseconds / 1000.0) ); #else struct timeval tv; struct timezone tz; gettimeofday( &tv, &tz ); return( (double)(tv.tv_sec + (double)tv.tv_usec / 1000000.0) ); #endif } /// Type of global random number generator typedef boost::minstd_rand _rnd_gen_type; // Try boost::mt19937 or boost::ecuyer1988 instead of boost::minstd_rand /// Global random number generator _rnd_gen_type _rnd_gen(42U); /// Uniform distribution with values between 0 and 1 (0 inclusive, 1 exclusive). boost::uniform_real _uni_dist(0,1); /// Global uniform random random number boost::variate_generator<_rnd_gen_type&, boost::uniform_real > _uni_rnd(_rnd_gen, _uni_dist); /// Normal distribution with mean 0 and standard deviation 1. boost::normal_distribution _normal_dist; /// Global random number generator with standard normal distribution boost::variate_generator<_rnd_gen_type&, boost::normal_distribution > _normal_rnd(_rnd_gen, _normal_dist); void rnd_seed( size_t seed ) { _rnd_gen.seed(seed); } Real rnd_uniform() { return _uni_rnd(); } Real rnd_stdnormal() { return _normal_rnd(); } int rnd_int( int min, int max ) { return (int)floor(_uni_rnd() * (max + 1 - min) + min); } void tokenizeString(const std::string& s, std::vector& outTokens, const std::string& delim) { size_t start = 0; while (start < s.size()) { size_t end = s.find_first_of(delim, start); if (end > s.size()) end = s.size(); outTokens.push_back(s.substr(start, end - start)); start = end + 1; } } } // end of namespace dai libDAI-0.2.4/examples/0000755000263000017630000000000011334764774013313 5ustar jorismkyblibDAI-0.2.4/examples/example_varset.cpp0000644000263000017630000000576311334764774017051 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2008-2009 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include using namespace std; using namespace dai; int main() { Var x0(0, 2); // Define binary variable x0 (with label 0) Var x1(1, 3); // Define ternary variable x1 (with label 1) // Define set X = {x0, x1} VarSet X; // empty X |= x1; // X = {x1} X |= x0; // X = {x1, x0} cout << "X = " << X << endl << endl; // Note that the elements of X are ordered according to their labels // Output some information about x0, x1 and X cout << "Var " << x0 << " has " << x0.states() << " states (possible values)." << endl; cout << "Var " << x1 << " has " << x1.states() << " states." << endl << endl; cout << "VarSet " << X << " has " << X.nrStates() << " states (joint assignments of its variables)." << endl << endl; cout << "States of VarSets correspond to states of their constituent Vars:" << endl; cout << " state of x0: state of x1: (linear) state of X:" << endl; for( size_t s1 = 0; s1 < x1.states(); s1++ ) // for all states s1 of x1 for( size_t s0 = 0; s0 < x0.states(); s0++ ) { // for all states s0 of x0 // store s0 and s1 in a map "states" map states; states[x0] = s0; states[x1] = s1; // output states of x0, x1 and corresponding state of X cout << " " << s0 << " " << s1 << " " << calcLinearState(X,states) << endl; // calcState() is the inverse of calcLinearState() DAI_ASSERT( calcState(X, calcLinearState(X, states)) == states ); } cout << endl << "And vice versa:" << endl; cout << " state of x0: state of x1: (linear) state of X:" << endl; for( size_t S = 0; S < X.nrStates(); S++ ) { // for all (joint) states of X // calculate states of x0 and x1 corresponding to state S of X map states = calcState(X,S); // output state of X and corresponding states of x0, x1 cout << " " << states[x0] << " " << states[x1] << " " << S << endl; // calcLinearState() is the inverse of calcState() DAI_ASSERT( calcLinearState(X, calcState(X,S)) == S ); } cout << endl << "Iterating over all joint states using the State class:" << endl; cout << " state of x0: state of x1: (linear) state of X: state of X (as a map):" << endl; for( State S(X); S.valid(); S++ ) { // output state of X and corresponding states of x0, x1 cout << " " << S(x0) << " " << S(x1) << " " << S << " " << S.get() << endl; } return 0; } libDAI-0.2.4/examples/example_permute.out0000644000263000017630000000234111334764774017240 0ustar jorismkybV = (x1, x2, x0) X = {x0, x1, x2} Note that the ordering of the variables in X is the canonical ordering (ascendingly according to their labels) but the ordering in V is different. The permutation between both variable orderings is sigma = (2, 0, 1), or more verbosely: sigma[0] = 2 sigma[1] = 0 sigma[2] = 1 This means that variable V[sigma[n]] should correspond with the n'th variable in X (for n=0,...,2)...OK. The states of the variables x0,x1,x2 are, according to the ordering in V: SV: x0: x1: x2: 0 0 0 0 1 0 1 0 2 0 2 0 3 0 0 1 4 0 1 1 5 0 2 1 6 1 0 0 7 1 1 0 8 1 2 0 9 1 0 1 10 1 1 1 11 1 2 1 The states of the variables x0,x1,x2 are, according to the canonical ordering in X: SX: x0: x1: x2: 0 0 0 0 1 1 0 0 2 0 1 0 3 1 1 0 4 0 2 0 5 1 2 0 6 0 0 1 7 1 0 1 8 0 1 1 9 1 1 1 10 0 2 1 11 1 2 1 The permutation sigma induces the following permutation of linear indices of joint states: SV: SX: 0 0 1 2 2 4 3 6 4 8 5 10 6 1 7 3 8 5 9 7 10 9 11 11 libDAI-0.2.4/examples/example_sprinkler_em.cpp0000644000263000017630000000423611334764774020231 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include #include using namespace std; using namespace dai; int main() { // This example program illustrates how to learn the // parameters of a Bayesian network from a sample of // the sprinkler network discussed at // http://www.cs.ubc.ca/~murphyk/Bayes/bnintro.html // // The factor graph file (sprinkler.fg) has to be generated first // by running example_sprinkler, and the data sample file // (sprinkler.tab) by running example_sprinkler_gibbs // Read the factorgraph from the file FactorGraph SprinklerNetwork; SprinklerNetwork.ReadFromFile( "sprinkler.fg" ); // Prepare junction-tree object for doing exact inference for E-step PropertySet infprops; infprops.Set( "verbose", (size_t)1 ); infprops.Set( "updates", string("HUGIN") ); InfAlg* inf = newInfAlg( "JTREE", SprinklerNetwork, infprops ); inf->init(); // Read sample from file Evidence e; ifstream estream( "sprinkler.tab" ); e.addEvidenceTabFile( estream, SprinklerNetwork ); cout << "Number of samples: " << e.nrSamples() << endl; // Read EM specification ifstream emstream( "sprinkler.em" ); EMAlg em(e, *inf, emstream); // Iterate EM until convergence while( !em.hasSatisfiedTermConditions() ) { Real l = em.iterate(); cout << "Iteration " << em.Iterations() << " likelihood: " << l <fg(); // Clean up delete inf; return 0; } libDAI-0.2.4/examples/example_sprinkler.png0000644000263000017630000004654011334764774017556 0ustar jorismkybPNG  IHDRObKGDtIME3 [ IDATxw\V?-S HT (j bDei*W Ӵ\ DPPT WDqpxx|8^79:%`1B!wB!*BHAEB"B!]}B!;!kիWT<|yyy())(((W^2dtuuajj KKK#W!-33'Onݺ999AGGC A޽!//(--C >>eee0443ϟ}T !&99۶mzٳg fffnR™3gp)`/ƟFE a/źu0gHIIݪ*:u ۶mCZZܰep΅>!MBv킋 uv qMM N!c8q"z?8o"3}BHNw/ӧBoJ*g}UVQ?ߏVH8+}BH$:t(1zhҮhF>Ҧ_}ClXXXtرc9-~~~@\\ !++ ܹsn0777}}Ҧ?~ ___c___YBCCakkY{ӡHTTT ==6l@pp0gҫ{KMy{{cYs̄aaaIӧOQTTEE:lll8+׮]Ä  555N$DЕ>!E HMM+I8OiT ijj 8kUJJJ۷ 3Oi @]]pvv-ZpN]B:2*)))ܽ[BSS8z(ƏiӦQ\\Y{*)//6l{ŋC … Xv-gqG! >!E$%%QYY٦}ȑ#8ppXNUUͿO*QPP@QQmN8.\(--嬯BOQ';ǣxyϕs!…%P(DZZx$$$ՐWI~~>a3ʕ+!--m۶qOUU>|mmmN#D\P'QVV:=11eee add;w޽{}!$$˖-CVVjjjq022⤟4TWWC__T ^xd$''#11ɸs! #GbXl a``iii@MM ~7\vwwwNjLXXYnB}B:2ܻw)))u  !-- mmm>]2vuKKK裏˗aee#3OH'PRR+## %%---zzz000f_]sttĒ%KPZZ yyy.?R)..ƥKp1"S}t|G8{,,Ximܹs=QiwTIw^رYYYmݻ7ͱvZ7cݺu8s Caa!dee===;wNt@ paa!9ܹs֭zcȑ8|0W;wĐ!CkjjM6ē'Oɓ:a߿? 0c Qa2ddddwKbŦXti0!mˋ59,,,2 Ϟ=˴ݻwcyxx0l,%%UUUv &''WWݼy׏_~=zUVVbv }v֫W/wǎ1̤e~!۸q#_ŋYbb"ovm-33ʲեKXYVVQ}ҦZ[kEDD0Դs mׯomm]ZLCC}xx8jvtvvf:Xf 366f|GiPuu5344d֭; !X-!!c*** kkkXXXCBBl'|A5x\PPP-,,`mm WWWTTT4x^gqF<{ ;Jك<_(> S6 prr`ooTUU5OԩS iHQQ{upMs |WسgCopuht ߅ n: 555,Z jv;>W\9::b={6sFnn.Yf^Q'Zyy9BBBCVV7on۷oWg>uVhjj"??G1mڴT/,,]jhhnݺs޽{!//S~~|*,,ɓѻwoٳ8>QF!::ZtM={EGذaݻ8,^.\ڵk^m;-Yεv 999?޲fř3gн{w޲QP'c BϞ=/F޶⛉ 9N>ttt)))͍.犻>} 887n=Czz:ƍ,Z;:t%TIQ{%' l8q_p!Ou&y3gV;X^]<ׯ__[gΜ1#!!G9tTI唵Ճߠ׹aؿhPߛU M !<<Θ9s&͛WgEeffbܹprr ]555"44 ?!O:#F>}Zg{~~>TTTڵkpvv4m>}`B!GGG>߇lΙ?> uf8vN8XfffѧO%%%Ezz:RRRW"''X`\]]oBBahh???ɵ%COT{}ԩS} GGGcM*EUCpp0._ddd4z`ee[[[hjj_*uIbkk oooܹsKrr2\]]qfJKK ZZZXb ӑ/Kӧ "jo[[[cڴiTIAEt:9r$K9s]CkR ~O"G:%--?s |1BHWCEҥQ'] }BHGtT !TI@EB?* OZٳgEjj*RSSs򐗗G=0tP`ׇ@ hT !5TISN}YHJJ@ ޽{CUU(--Eii) xhFJ;;;888fl+T ! c VVV5jTBʕ+ ˱b ̘1k֬QdgzO^s>ƦM0~&a(!!===XΝCVVvލ߯xBH#𓚚>|:::8u[!+;;pss]m8v/ʕ+MEB s5ӧO?٢Oo#`$''cܸqw}©BHQ:Μ9[[[{kuo?Ö-[tRGEB wQ̝;~)w$ŋ?0{~zeٳgim>ښ/A^tRl߾}q8q"\|G8|p'+}Ҧ ''6#;;bSSSc&+'.. ~-6mjQlxg[ iX[[АXAA`cc_8oںQ'b-)) 8wOwEQx!"##Qo!11}i9TX[l\TtFO/̛77nl  1ahkko9[ϟVOxGSyy9VZoF >r*#G M:~SuA?; !ݻwCZZ~)QZDGG| >&MCEJ8pK,i( i*⣤wW_})))ڵk/X*D,:u pww; !P+~~>}`ٲez, #bZZZ8}4Qi شpB_(]]]$$$`ȑ GWD\zXz5Qi]w\QQQx\\\ ӳo>̌(8p Q83w\4z ͽOǏqxyyt2۬}cccȨۯUV¢ڿ|2[FAAF{TUU1yd?~N:ͅ6Zlĉzj$''CWWЕ>+{E߾}1k,N&&&m־ ,--f}txqwʪU -- Æ  ':Tg?áV|000*._1tOF~~>~WlܸOpٙ"u]9 0j(Nڛ>}:v ???t>:Ο?N2}XXЕ>!4Grr23frWƍٳ'._:ϟ?]K7OByy9777NnBns ꈍENNh?#Z}999Ɂg9@KK ))) OZ(1UB 555ph{`` &Oɓ'DEwzwjQ'^uu5~',\jjj|!())qn@ KDd@r7PëɻfB: 8q"rZt2rH#77 HJJjFdee,=zIî]0k,hjj HHHp>I &O2"((vvv`!((4iR  _}ҡ#>>֭; !PRRBII zy~}ҥ6_LEth۷o-#\ !]WϞ=EőKSL$sssѾ1c@YY9?Ƞ{oOIW"44(1DEE!** %%%L07Ǝ[g1IIIL8gϞ!!!yChii5Ic5 'N; !D0tP;5k KKKsk@N#hѧ+}!᯿©SBq-DDDڵkGNN`nn b̘1xw s~G50MK\+W|%K`ɒ%[naΜ9 O:]vaȐ!KMňBDD"##b1n87Fha> KKO:L8q?3u'PtU%%%un޼){.B!4551vX;v, @ %\4ːic3Vk֬!##wE̟?h@ @CCYYYAϞ=abb###Xd !//Qr~999[n8}teP믿b͚5TIw^@%%%%4߿kkkhkkRSS… tԩS @aÆU&M^zARR 6lfΜ) -- 555L4 G& ^̙3HOOG^^c̜9hsZVGPPP .ť!ƍYϞ=Yqq1QH̜}V1]]]&!!zٳg{.caÆ1Ν;=y$s}o͘1޾;v 6U_~ +**wu_mM׉ Ш/<0:JV111$$$4xLEE\]]amm 7555qz˗/[:]sss45lȐ!uxꊊV9so;Jxzz}[O:/^IJeЫW/*q)^^^̄SfffPWWGll,rrrDEEEANNNU׎涷Z^ 䄌 p'n݊6l͛4 >?t ׯ_:s… ^X{@ =jjjD-R;[PPh8pΆ3԰h"7eee¢E ##;wڻ-- <_~%V\r47|555,[i'BU@T IDATUU455ҥKB0.闕`6h &++ˢ^=>c/&oK=~ݛmڴY}+o'''hjjcA(ٳgȑ#=v`ۛɓQVVPV1!44&Mjlt[G\ҷo_߿شiSIII@unbb~-˗ӨBL2#F u.}«$&&bݺu|G!]ծwJo}__tQZv\\\0sLl߾]4uZ߽#qwwǢE0k֬F߼Sii)LN:%z^m۶ [lEEEo?eHJJ111u3FLL Əh_^v-qA ,@aaaYaccKKKuԷ(pqcܹpwwurSNaԨQPVV1hР7 y&?Qa|~K}2{{6i޳;YS2 V^^s={0vڵv;33͛7 zΫtOxsN; !ѣGq%G =zfΜx&L… ަ}b׮]ETT.\~I&DkP'ѣG?vffDHgckk ooo"%%83JNN+N> gРA /""" WWWܺu~rrrcؼy3ݑ)Sp w i+W4:!o*--988p&߿[t.:UUU'O2}}} >ڵݾ}IM<==ԩSSVVf_}i c?!i1`رV#\K  |GiTLL <=="++ 5jttt޽{CYYJJJ(--EII 4$&&")) rrr1mڴFjjSA҆yyy,Z(*055+W 668z(###MMM 6 NNN%3}nJJJww&-I!BWWu* (**Baa!塨F*9r/^ʕ+B!mNBB=z@="BEH_nwƢEлwH!5TIc}6^(!55eeeu6ann+++^;u233g1!>i@bb"= ooo<{ }&OUVAQQ^.X\\TaǎOٳg?ıc0o޼:yBi_TIaaao Æ kV;)))7v ̞=RBi ?~3gރP(DHH~f|_dpttE!}Q'8v\|֜ommWҥKuiB./ƢEDN&M;w?Ƃ tRTUUYBg]Tii) v[NFF;wĄ ₌ d=J ĴiӐ0^2e iӦ3BHWCEaaΜ9HMMŵk0|p޲1׮]ݻw~"Em۶ʕ+&q7;w_|w$҅y{{wq&/^hӕHAE ƍzÇѣ3g&L333#.ԴCO"66SL2ɉ&j#FT*w;Z aaaq$%QBc022|}}C:zE۷eeeҠ۷; !n߾(+.đ#GwF>}1ӡwBxûﾋܹs|!]wVNNNPSSÁBpM|7|G!]wrׯ;,]8MrA|7Ȁqѣ???N;@`Μ9|Gis碨.]; !x"'+Nn`q6򷰰G?ܹt ={D1rH>|888@ZZ>>>&DW^; dJtżx~9s2!  8Fhh(G`DGGӈ}&J1Ҡժ RcРAo55=B:q6!oCE_"** ׯ_GDDgϞ3f f̘Çݻw300@bb"> ooo_wqɀ\BOO鈶lssstTÇH#)) 555ֆ9ϟcBGGeee8~89{֮իWc՜א0ԴM!/qqqx".^w҅Pׯ }F¤Ie3jjjolCNN|2Õ+W`nnݻ6e; Bw꣢pڵ:ͱb XXX`ԨQ*عs'& q9|W|G!M~~~|G!] }EFFnkjjbر7o,,,۪Ν> b0$$yyy;w.Qi[l1LwPo/^@dd$={n՛C]]ӾUUUMٳ9|HHGsm?Νd1,B~>bccE_7oċ/cbڵ077 ddd<ϗ_~#G"11ÇoZ֭[ Dbb"Qi[l#0m4.~+削{LL bcc))) >fff裏`nnmmm^2`޼y/:H?...; !{.Ν;___'` ${a dl̙,22mݻw988VPP~{޽{3III&--ٻ˖,Y":=xUUs :͛7޽EDD2BFFSRRbQ͔YVVQi...LOOtQmZ_mRtuu |gϞeZZZݻm7odc_~a=bݸqm߾Kt;w6;dl|G!M3IIIvq.݋~6znpp0bmLCC4Zlmm|ΤXHHH?kfggFJKK#RZZLLLԩS tZ+V` `UUU|G!]o/n<hO> j糶5\]]9[rV8qϞ=ٳQYYw$TVVb֬Y(,,ıc9'rrrcڵT?jht233Tg?`ԩ iA޽qebΜ9S^^9s 66gϞE^xBH[ڳgxb.uy\p^Vs; MMM"""'OF^^^g˃-"##!''kŋ힃VXX_~| M+MxE!!!!++͛77x۷_KCC2\~?1ڭp"++ 8<1k֬ȁ.F\\1~xY%%%m_QQV^ +++5 qqqԄ sR'Fyy9݋˗CEE8ogA(ٳgȑ#=y_ttt))) %%ٳ'Ξ=رc6l<<<8}_^^CGG8x Ξ=[痠) B'/ǎC~~>>SgMQ0}ts=MVUUitRk׮_Z)))X~=/NNNHNNŋ8Jر@@@,X@jXp!yRCo!C0 0˳խ-77`*.>Mvv6VZżX\\+**wNQQc^^^ݝ3lРAoaϞ=kr{Օ B.?!ˋIJJ{#C<}=zmWRRB@@1~xlݺPWWGQQp!_}"VcرcwBDڴo޼{555#00I㯿7g``D>|X~= -- ﾫfd@-yǿ;v,Ǝ͛7C(ѣGHKKCQQ- eee())A[[ D]s?qiKKKu@Hԡoѣ:u*bbb})V|~p ,X@HGWʕ+|G!]puuŹsD5Wrr2\]]qipy桴˖-">3#Ҡ={Q}pttȑ#_̙3-j믿F@@q:,YR^X|9ߑ'++ N?wBH,>r|:t | b >;!u8pJJJpqq; !o$6Eذah"Hx9_âOΎ;PVVggg_;!DQQBHo>;cسgΝKS>KGAii)OVIHK#)) |G!QzB#!!OOO?'O۷DݻwރQi}"֤ cccX[[jU@BZ")) |. t{ݻ666իWi>$555}6㑖GTUU===ANNN{СCaooӧ NA^^-Я_?cϟǙ3gpUA^^}t￣ >{L0Æ {ϟ?Gxx8BCC?/ V\?>!GNO> P(5DxVRR5k`С7|,_XlY >3g΄>}?eeeصkf̘6$}hhh 44PTTw$“/bذa8~8~GkB^`' i0oC[~-qH3͙3BgΜ;[ /C(M6m;!|9r$k{=~&>p ۗ8o~ 0vXӐV#]އ~Pe˖AJJ _}ߑH=z#Fe+9"#FIcĴK.ѣpuu:>ql1AaժUXfMٻw/v؁:ۥУGbŘ={v IDATk#=z!C ::GMB>T1|c%qV֭[044DJJJmL_HLLĚ5k۷/hu?0|p̜9[l=B'c%n^}rRD^^fff8z(`mii+Wp!AE"vajj 2Y  9kO;)))i~FFF9l0x=MB>!DܻwZZZm~YYh"`Ν]ރ8kW!bE(***4ֈg}())[nMB !by۵3226yb%mBk#664i)LBJ~[qqq̙3}v\~Ӷi4}BXۼGX` 9i555ի'T !b!77!!!عs'zy_#q{(~B't(1<|HHH}edd444Vyfwkkkxzz9::bܹFdd$N8qƵT`NHKP'&//wERR[nֆ!VZ###O>ػw/'oܸ7n|q>>>iuѣGCBBi*6/*wARR޽l@=̟?>|8؞>S$''CWW=?J]r| ]}B'pz_(++CWW2e  fe``ŋbUӑ(OildffÇ{3nݺԄ6Lbpqqɓ'fNl6lFwEQ' Oɓ'x)233"##x 0ôiӠ --- 2222m?ĶmQFyU]ڻ6 Ϥ&Zef7iQ2ʈH,02R0.3˔"jyH($1mTw錣Is\u^k|2, ILLfDh4޽gΜAzz:><5d4Wcc#=s\.#VZ{"&&fe2و;::p5kϟOOO\999~2j;9c…P(􄧧'ݱh"̞={יltϷt*ch48ty0Y ArssD ___aee%n߾=fׅxͨs !Dww(//ׯZß^x!<<<BӉ.QYY)jX`#n޼9OIIoRUU%rt*Ft:l2fTHXiFc@s玐墬l9^#뵷 www ^;<<|eeeB.woDnnb֭NŠtdkTHx"W^J0lܸѤy߿npLvv6ZZZpa,^8V;7",, * }}}&3ݥ jҩ˗HMMEff&lmm-I>`tQZnn.Z[[m իWSTT4y^hLa2: 55eeeNg!66[nt:D,D;[w-ڵkǜϟ(//Gbb"lll(W[[ OxܱUTT>۷t:v +++?=z{{#$%%'O48 ap+swtӷA7_wtw!""݃rtؽ{7jkkC' M5~'L&=fTTT ((_0^hii:;;l2y=跃鏸 +++\r^^^ AeeEBDDJKKjM),DB`pp_~E^^V\it~ 23338qX?$'~b!5vvv()) K.MkjjaŊSz}aΜ9A'$$`ǎPCkF}v@AAv1aI-p!$&&"!!N000g"(((//kM>\]]&dgg{zw`…Z7sqss39 j%%%x!|||pܹc'Sii)#Gt >>}29YYYhnnƁF3o<Cܽ{J?~lWRob߾}HNNN>o߾5o?nܸ 6`ӦMpvvFUURSSMzCd),$i'O[l19>** -{N777$$$ S*F%KF_j;v ={6 ߏ~:ujD0푑#66iiimې:z5| HJJJ%hZ,]t |N|֘;w.k.bݺu] I3>áhRPPP0Jmm-T*^͛7[$F&hmLwD@TǏX)))(..uoD׮]p͹6II>DI>DI>DI>DI>DI>DHyyyNâO3RLLS "Ȅ #include // Include main libDAI header file using namespace dai; using namespace std; int main( int argc, char *argv[] ) { if ( argc != 2 ) { cout << "Usage: " << argv[0] << " " << endl << endl; cout << "Reads factor graph and runs" << endl; cout << "Belief Propagation and JunctionTree on it." << endl << endl; return 1; } else { // Read FactorGraph from the file specified by the first command line argument FactorGraph fg; fg.ReadFromFile(argv[1]); // Set some constants size_t maxiter = 10000; Real tol = 1e-9; size_t verb = 1; // Store the constants in a PropertySet object PropertySet opts; opts.Set("maxiter",maxiter); // Maximum number of iterations opts.Set("tol",tol); // Tolerance for convergence opts.Set("verbose",verb); // Verbosity (amount of output generated) // Construct a JTree (junction tree) object from the FactorGraph fg // using the parameters specified by opts and an additional property // that specifies the type of updates the JTree algorithm should perform JTree jt( fg, opts("updates",string("HUGIN")) ); // Initialize junction tree algorithm jt.init(); // Run junction tree algorithm jt.run(); // Construct another JTree (junction tree) object that is used to calculate // the joint configuration of variables that has maximum probability (MAP state) JTree jtmap( fg, opts("updates",string("HUGIN"))("inference",string("MAXPROD")) ); // Initialize junction tree algorithm jtmap.init(); // Run junction tree algorithm jtmap.run(); // Calculate joint state of all variables that has maximum probability vector jtmapstate = jtmap.findMaximum(); // Construct a BP (belief propagation) object from the FactorGraph fg // using the parameters specified by opts and two additional properties, // specifying the type of updates the BP algorithm should perform and // whether they should be done in the real or in the logdomain BP bp(fg, opts("updates",string("SEQFIX"))("logdomain",false)); // Initialize belief propagation algorithm bp.init(); // Run belief propagation algorithm bp.run(); // Construct a BP (belief propagation) object from the FactorGraph fg // using the parameters specified by opts and two additional properties, // specifying the type of updates the BP algorithm should perform and // whether they should be done in the real or in the logdomain // // Note that inference is set to MAXPROD, which means that the object // will perform the max-product algorithm instead of the sum-product algorithm BP mp(fg, opts("updates",string("SEQFIX"))("logdomain",false)("inference",string("MAXPROD"))); // Initialize max-product algorithm mp.init(); // Run max-product algorithm mp.run(); // Calculate joint state of all variables that has maximum probability // based on the max-product result vector mpstate = mp.findMaximum(); // Report variable marginals for fg, calculated by the junction tree algorithm cout << "Exact variable marginals:" << endl; for( size_t i = 0; i < fg.nrVars(); i++ ) // iterate over all variables in fg cout << jt.belief(fg.var(i)) << endl; // display the "belief" of jt for that variable // Report variable marginals for fg, calculated by the belief propagation algorithm cout << "Approximate (loopy belief propagation) variable marginals:" << endl; for( size_t i = 0; i < fg.nrVars(); i++ ) // iterate over all variables in fg cout << bp.belief(fg.var(i)) << endl; // display the belief of bp for that variable // Report factor marginals for fg, calculated by the junction tree algorithm cout << "Exact factor marginals:" << endl; for( size_t I = 0; I < fg.nrFactors(); I++ ) // iterate over all factors in fg cout << jt.belief(fg.factor(I).vars()) << endl; // display the "belief" of jt for the variables in that factor // Report factor marginals for fg, calculated by the belief propagation algorithm cout << "Approximate (loopy belief propagation) factor marginals:" << endl; for( size_t I = 0; I < fg.nrFactors(); I++ ) // iterate over all factors in fg cout << bp.belief(fg.factor(I).vars()) << endl; // display the belief of bp for the variables in that factor // Report log partition sum (normalizing constant) of fg, calculated by the junction tree algorithm cout << "Exact log partition sum: " << jt.logZ() << endl; // Report log partition sum of fg, approximated by the belief propagation algorithm cout << "Approximate (loopy belief propagation) log partition sum: " << bp.logZ() << endl; // Report exact MAP variable marginals cout << "Exact MAP variable marginals:" << endl; for( size_t i = 0; i < fg.nrVars(); i++ ) cout << jtmap.belief(fg.var(i)) << endl; // Report max-product variable marginals cout << "Approximate (max-product) MAP variable marginals:" << endl; for( size_t i = 0; i < fg.nrVars(); i++ ) cout << mp.belief(fg.var(i)) << endl; // Report exact MAP factor marginals cout << "Exact MAP factor marginals:" << endl; for( size_t I = 0; I < fg.nrFactors(); I++ ) cout << jtmap.belief(fg.factor(I).vars()) << "=" << jtmap.beliefF(I) << endl; // Report max-product factor marginals cout << "Approximate (max-product) MAP factor marginals:" << endl; for( size_t I = 0; I < fg.nrFactors(); I++ ) cout << mp.belief(fg.factor(I).vars()) << "=" << mp.beliefF(I) << endl; // Report exact MAP joint state cout << "Exact MAP state:" << endl; for( size_t i = 0; i < jtmapstate.size(); i++ ) cout << fg.var(i) << ": " << jtmapstate[i] << endl; // Report max-product MAP joint state cout << "Approximate (max-product) MAP state:" << endl; for( size_t i = 0; i < mpstate.size(); i++ ) cout << fg.var(i) << ": " << mpstate[i] << endl; } return 0; } libDAI-0.2.4/examples/example_bipgraph.out0000644000263000017630000000055211334764774017355 0ustar jorismkybG has 3 nodes of type 1, 2 nodes of type 2 and 5 edges. Node 0 of type 1 has 1 neighbors: the 0'th neighbor is node 0 of type 2 Node 1 of type 1 has 2 neighbors: the 0'th neighbor is node 0 of type 2 the 1'th neighbor is node 1 of type 2 Node 2 of type 1 has 2 neighbors: the 0'th neighbor is node 0 of type 2 the 1'th neighbor is node 1 of type 2 libDAI-0.2.4/examples/sprinkler.em0000644000263000017630000000043111334764774015645 0ustar jorismkyb1 4 CondProbEstimation [target_dim=2,total_dim=2,pseudo_count=1] 1 0 0 CondProbEstimation [target_dim=2,total_dim=4,pseudo_count=1] 1 1 2 0 CondProbEstimation [target_dim=2,total_dim=4,pseudo_count=1] 1 2 1 0 CondProbEstimation [target_dim=2,total_dim=8,pseudo_count=1] 1 3 3 1 2 libDAI-0.2.4/examples/example_sprinkler.dot0000644000263000017630000000045311334764774017551 0ustar jorismkybgraph Sprinkler { node[shape=circle]; C; S; R; W; node[shape=box]; f0 [label="P (C)"]; f1 [label="P (S|C)"]; f2 [label="P (R|C)"]; f3 [label="P (W|S,R)"]; f0 -- C; f1 -- S; f1 -- C; f2 -- R; f2 -- C; f3 -- W; f3 -- S; f3 -- R; }; libDAI-0.2.4/examples/example_permute.cpp0000644000263000017630000000746011334764774017222 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2008-2009 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include #include using namespace std; using namespace dai; int main() { Var x0(0, 2); // Define binary variable x0 (with label 0) Var x1(1, 3); // Define ternary variable x1 (with label 1) Var x2(2, 2); // Define binary variable x2 (with label 2) // Define vector V = (x1, x2, x0) vector V; // Define a vector of variables V.push_back( x1 ); // V[0] = x1; V.push_back( x2 ); // V[1] = x2; V.push_back( x0 ); // V[2] = x0; cout << "V = " << V << endl; // Note that the elements of X are not necessarily ordered according to their labels // Define set X = {x0, x1, x2} VarSet X; // empty X |= x2; // X = {x2} X |= x0; // X = {x0, x2} X |= x1; // X = {x0, x1, x2} cout << "X = " << X << endl; // Note that the elements of X are ordered according to their labels cout << "Note that the ordering of the variables in X is the canonical ordering" << endl; cout << "(ascendingly according to their labels) but the ordering in V is different." << endl << endl; // N = number of variables in V (and X) size_t N = V.size(); // Define a Permute object based on the variables in V Permute sigma(V); // Each Var in V corresponds with a dimension in a multi-dimensional array. // The permutation sigma permutes these dimensions from the canonical ordering // (sorted ascendingly on the label of the variable, i.e., the same ordering as // in X) into the ordering these variables have in V. cout << "The permutation between both variable orderings is sigma = " << sigma.sigma() << ", or more verbosely:" << endl; for( size_t n = 0; n < N; n++ ) cout << " sigma[" << n << "] = " << sigma[n] << endl; cout << "This means that variable V[sigma[n]] should correspond with the n'th variable in X (for n=0,...," << (N-1) << ")..."; // Check whether the permutation works as advertised VarSet::const_iterator X_n = X.begin(); for( size_t n = 0; n < N; n++, X_n++ ) DAI_ASSERT( V[sigma[n]] == *X_n ); cout << "OK. " << endl << endl; // Iterate over the joint states of the variables, according to the ordering in V cout << "The states of the variables x0,x1,x2 are, according to the ordering in V:" << endl; cout << "SV: x0: x1: x2:" << endl; std::vector ranges; for( size_t i = 0; i < V.size(); i++ ) ranges.push_back( V[i].states() ); for( multifor SV(ranges); SV.valid(); ++SV ) cout << setw(2) << (size_t)SV << " " << SV[sigma[0]] << " " << SV[sigma[1]] << " " << SV[sigma[2]] << endl; cout << endl; // Iterate over the joint states of the variables, according to the canonical ordering in X cout << "The states of the variables x0,x1,x2 are, according to the canonical ordering in X:" << endl; cout << "SX: x0: x1: x2:" << endl; for( State SX(X); SX.valid(); SX++ ) cout << setw(2) << SX << " " << SX(x0) << " " << SX(x1) << " " << SX(x2) << endl; cout << endl; // The main functionality of the Permute object is to calculate the induced permutation of linear indices of joint states cout << "The permutation sigma induces the following permutation of linear indices of joint states:" << endl; cout << "SV: SX:" << endl; for( size_t li = 0; li < X.nrStates(); li++ ) cout << setw(2) << li << " " << setw(2) << sigma.convertLinearIndex( li ) << endl; return 0; } libDAI-0.2.4/examples/example_bipgraph.cpp0000644000263000017630000000360311334764774017330 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2008-2009 Joris Mooij [joris dot mooij at libdai dot org] */ #include using namespace std; using namespace dai; int main() { // Create a list of edges vector edges; edges.reserve( 5 ); edges.push_back( BipartiteGraph::Edge(0, 0) ); edges.push_back( BipartiteGraph::Edge(1, 0) ); edges.push_back( BipartiteGraph::Edge(2, 0) ); edges.push_back( BipartiteGraph::Edge(1, 1) ); edges.push_back( BipartiteGraph::Edge(2, 1) ); // Create a bipartite graph with 3 nodes of type 1, // 2 nodes of type 2 and edge list edges. BipartiteGraph G( 3, 2, edges.begin(), edges.end() ); // Display some information about G cout << "G has " << G.nrNodes1() << " nodes of type 1, " << G.nrNodes2() << " nodes of type 2 and " << G.nrEdges() << " edges." << endl << endl; // Iterate over all nodes n1 of type 1 for( size_t n1 = 0; n1 < G.nrNodes1(); n1++ ) { cout << "Node " << n1 << " of type 1 has " << G.nb1(n1).size() << " neighbors:" << endl; // Iterate over all neighbors n2 of n1 foreach( const BipartiteGraph::Neighbor &n2, G.nb1(n1) ) { // The n2.iter'th neighbor of n1 is n2: DAI_ASSERT( G.nb1(n1)[n2.iter] == n2 ); // The n2.dual'th neighbor of n2 is n1: DAI_ASSERT( G.nb2(n2)[n2.dual] == n1 ); // n2 can be used as an abbreviation of n2.node: DAI_ASSERT( static_cast(n2) == n2.node ); cout << " the " << n2.iter << "'th neighbor is node " << n2 << " of type 2" << endl; } cout << endl; } } libDAI-0.2.4/examples/example_sprinkler.cpp0000644000263000017630000000645011334764774017550 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2008-2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include using namespace std; using namespace dai; int main() { // This example program illustrates how to construct a factorgraph // by means of the sprinkler network example discussed at // http://www.cs.ubc.ca/~murphyk/Bayes/bnintro.html Var C(0, 2); // Define binary variable Cloudy (with label 0) Var S(1, 2); // Define binary variable Sprinkler (with label 1) Var R(2, 2); // Define binary variable Rain (with label 2) Var W(3, 2); // Define binary variable Wetgrass (with label 3) // Define probability distribution for C Factor P_C( C ); P_C[0] = 0.5; // C = 0 P_C[1] = 0.5; // C = 1 // Define conditional probability of S given C Factor P_S_given_C( VarSet( S, C ) ); P_S_given_C[0] = 0.5; // C = 0, S = 0 P_S_given_C[1] = 0.9; // C = 1, S = 0 P_S_given_C[2] = 0.5; // C = 0, S = 1 P_S_given_C[3] = 0.1; // C = 1, S = 1 // Define conditional probability of R given C Factor P_R_given_C( VarSet( R, C ) ); P_R_given_C[0] = 0.8; // C = 0, R = 0 P_R_given_C[1] = 0.2; // C = 1, R = 0 P_R_given_C[2] = 0.2; // C = 0, R = 1 P_R_given_C[3] = 0.8; // C = 1, R = 1 // Define conditional probability of W given S and R Factor P_W_given_S_R( VarSet( S, R ) | W ); P_W_given_S_R[0] = 1.0; // S = 0, R = 0, W = 0 P_W_given_S_R[1] = 0.1; // S = 1, R = 0, W = 0 P_W_given_S_R[2] = 0.1; // S = 0, R = 1, W = 0 P_W_given_S_R[3] = 0.01; // S = 1, R = 1, W = 0 P_W_given_S_R[4] = 0.0; // S = 0, R = 0, W = 1 P_W_given_S_R[5] = 0.9; // S = 1, R = 0, W = 1 P_W_given_S_R[6] = 0.9; // S = 0, R = 1, W = 1 P_W_given_S_R[7] = 0.99; // S = 1, R = 1, W = 1 // Build factor graph consisting of those four factors vector SprinklerFactors; SprinklerFactors.push_back( P_C ); SprinklerFactors.push_back( P_R_given_C ); SprinklerFactors.push_back( P_S_given_C ); SprinklerFactors.push_back( P_W_given_S_R ); FactorGraph SprinklerNetwork( SprinklerFactors ); // Write factorgraph to a file SprinklerNetwork.WriteToFile( "sprinkler.fg" ); cout << "Sprinkler network written to sprinkler.fg" << endl; // Output some information about the factorgraph cout << SprinklerNetwork.nrVars() << " variables" << endl; cout << SprinklerNetwork.nrFactors() << " factors" << endl; // Calculate joint probability of all four variables Factor P; for( size_t I = 0; I < SprinklerNetwork.nrFactors(); I++ ) P *= SprinklerNetwork.factor( I ); // P.normalize(); // Not necessary: a Bayesian network is already normalized by definition // Calculate some probabilities Real denom = P.marginal( W )[1]; cout << "P(W=1) = " << denom << endl; cout << "P(S=1 | W=1) = " << P.marginal( VarSet( S, W ) )[3] / denom << endl; cout << "P(R=1 | W=1) = " << P.marginal( VarSet( R, W ) )[3] / denom << endl; return 0; } libDAI-0.2.4/examples/example_varset.out0000644000263000017630000000135011334764774017062 0ustar jorismkybX = {x0,x1} Var x0 has 2 states (possible values). Var x1 has 3 states. VarSet {x0,x1} has 6 states (joint assignments of its variables). States of VarSets correspond to states of their constituent Vars: state of x0: state of x1: state of X: 0 0 0 1 0 1 0 1 2 1 1 3 0 2 4 1 2 5 And vice versa: state of x0: state of x1: state of X: 0 0 0 1 0 1 0 1 2 1 1 3 0 2 4 1 2 5 libDAI-0.2.4/examples/example_sprinkler_gibbs.cpp0000644000263000017630000000466211334764774020721 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include #include #include using namespace std; using namespace dai; int main() { // This example program illustrates how to use Gibbs sampling // to sample from a joint probability distribution described // by a factor graph, using the sprinkler network example discussed at // http://www.cs.ubc.ca/~murphyk/Bayes/bnintro.html // // The file sprinkler.fg has to be generated by first running // example_sprinkler // Read the factorgraph from the file FactorGraph SprinklerNetwork; SprinklerNetwork.ReadFromFile( "sprinkler.fg" ); cout << "Sprinkler network read from sprinkler.fg" << endl; // Output some information about the factorgraph cout << SprinklerNetwork.nrVars() << " variables" << endl; cout << SprinklerNetwork.nrFactors() << " factors" << endl; // Prepare a Gibbs sampler PropertySet gibbsProps; gibbsProps.Set("iters", size_t(100)); // number of Gibbs sampler iterations gibbsProps.Set("burnin", size_t(0)); gibbsProps.Set("verbose", size_t(0)); Gibbs gibbsSampler( SprinklerNetwork, gibbsProps ); // Open a .tab file for writing ofstream outfile; outfile.open( "sprinkler.tab" ); if( !outfile.is_open() ) throw "Cannot write to file!"; // Write header (consisting of variable labels) for( size_t i = 0; i < SprinklerNetwork.nrVars(); i++ ) outfile << (i == 0 ? "" : "\t") << SprinklerNetwork.var(i).label(); outfile << endl << endl; // Draw samples from joint distribution using Gibbs sampling // and write them to the .tab file size_t nrSamples = 1000; std::vector state; for( size_t t = 0; t < nrSamples; t++ ) { gibbsSampler.run(); state = gibbsSampler.state(); for( size_t i = 0; i < state.size(); i++ ) outfile << (i == 0 ? "" : "\t") << state[i]; outfile << endl; } cout << nrSamples << " samples written to sprinkler.tab" << endl; // Close the .tab file outfile.close(); return 0; } libDAI-0.2.4/include/0000755000263000017630000000000011334764774013120 5ustar jorismkyblibDAI-0.2.4/include/dai/0000755000263000017630000000000011334764775013656 5ustar jorismkyblibDAI-0.2.4/include/dai/regiongraph.h0000644000263000017630000002417011334764774016337 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines classes Region, FRegion and RegionGraph, which implement a particular subclass of region graphs. #ifndef __defined_libdai_regiongraph_h #define __defined_libdai_regiongraph_h #include #include #include #include namespace dai { /// A Region is a set of variables with a counting number class Region : public VarSet { private: /// Counting number Real _c; public: /// Default constructor Region() : VarSet(), _c(1.0) {} /// Construct from a set of variables and a counting number Region( const VarSet &x, Real c ) : VarSet(x), _c(c) {} /// Returns constant reference to counting number const Real & c() const { return _c; } /// Returns reference to counting number Real & c() { return _c; } }; /// An FRegion is a factor with a counting number class FRegion : public Factor { private: /// Counting number Real _c; public: /// Default constructor FRegion() : Factor(), _c(1.0) {} /// Constructs from a factor and a counting number FRegion( const Factor & x, Real c ) : Factor(x), _c(c) {} /// Returns constant reference to counting number const Real & c() const { return _c; } /// Returns reference to counting number Real & c() { return _c; } }; /// A RegionGraph combines a bipartite graph consisting of outer regions (type FRegion) and inner regions (type Region) with a FactorGraph /** A RegionGraph inherits from a FactorGraph and adds additional structure in the form of a "region graph". Our definition of region graph * is inspired by [\ref HAK03], which is less general than the definition given in [\ref YFW05]. * * The extra structure described by a RegionGraph over that described by a FactorGraph is: * - a set of outer regions (indexed by \f$\alpha\f$), where each outer region consists of * - a factor defined on a subset of variables * - a counting number * - a set of inner regions (indexed by \f$\beta\f$), where each inner region consists of * - a subset of variables * - a counting number * - edges between inner and outer regions * * Each factor in the factor graph belongs to an outer region; normally, the factor contents * of an outer region would be the product of all the factors that belong to that region. */ class RegionGraph : public FactorGraph { public: /// Stores the neighborhood structure BipartiteGraph G; /// The outer regions (corresponding to nodes of type 1) std::vector ORs; /// The inner regions (corresponding to nodes of type 2) std::vector IRs; /// Stores for each factor index the index of the outer region it belongs to std::vector fac2OR; public: /// \name Constructors and destructors //@{ /// Default constructor RegionGraph() : FactorGraph(), G(), ORs(), IRs(), fac2OR() {} /// Partially constructs a region graph from a factor graph RegionGraph( const FactorGraph &fg ) : FactorGraph(fg), G(), ORs(), IRs(), fac2OR() {} /// Constructs a region graph from a factor graph, a vector of outer regions, a vector of inner regions and a vector of edges /** The counting numbers for the outer regions are set to 1. */ RegionGraph( const FactorGraph &fg, const std::vector &ors, const std::vector &irs, const std::vector > &edges ) : FactorGraph(), G(), ORs(), IRs(), fac2OR() { construct( fg, ors, irs, edges ); // Check counting numbers #ifdef DAI_DEBUG checkCountingNumbers(); #endif } /// Constructs a region graph from a factor graph, a vector of outer regions, a vector of inner regions and a vector of edges /** \note The counting numbers for the outer regions need to be 1. * \deprecated Please use dai::RegionGraph::RegionGraph( const FactorGraph &, const std::vector &, const std::vector &, const std::vector > & ) instead. */ RegionGraph( const FactorGraph &fg, const std::vector &ors, const std::vector &irs, const std::vector > &edges ); /// Constructs a region graph from a factor graph and a vector of outer clusters (CVM style) /** The region graph is constructed as in the Cluster Variation Method. * * The outer regions have as variable subsets the clusters specified in \a cl. * Each factor in the factor graph \a fg is assigned to one of the outer regions. * Each outer region gets counting number 1. * * The inner regions are (repeated) intersections of outer regions. * An inner and an outer region are connected if the variables in the inner region form a * subset of the variables in the outer region. The counting numbers for the inner * regions are calculated by calcCountingNumbers() and satisfy the Moebius formula. */ RegionGraph( const FactorGraph &fg, const std::vector &cl ) : FactorGraph(), G(), ORs(), IRs(), fac2OR() { constructCVM( fg, cl ); // Check counting numbers #ifdef DAI_DEBUG checkCountingNumbers(); #endif } /// Clone \c *this (virtual copy constructor) virtual RegionGraph* clone() const { return new RegionGraph(*this); } //@} /// \name Queries //@{ /// Returns number of outer regions size_t nrORs() const { return ORs.size(); } /// Returns number of inner regions size_t nrIRs() const { return IRs.size(); } /// Returns constant reference to outer region \a alpha const FRegion & OR(size_t alpha) const { return ORs[alpha]; } /// Returns reference to outer region \a alpha FRegion & OR(size_t alpha) { return ORs[alpha]; } /// Returns constant reference to inner region \a beta const Region & IR(size_t beta) const { return IRs[beta]; } /// Returns reference to inner region \a beta Region & IR(size_t beta) { return IRs[beta]; } /// Returns constant reference to the neighbors of outer region \a alpha const Neighbors & nbOR( size_t alpha ) const { return G.nb1(alpha); } /// Returns constant reference to the neighbors of inner region \a beta const Neighbors & nbIR( size_t beta ) const { return G.nb2(beta); } /// Check whether the counting numbers are valid /** Counting numbers are said to be (variable) valid if for each variable \f$x\f$, * \f[\sum_{\alpha \ni x} c_\alpha + \sum_{\beta \ni x} c_\beta = 1\f] * or in words, if the sum of the counting numbers of the regions * that contain the variable equals one. */ bool checkCountingNumbers() const; //@} /// \name Operations //@{ /// Set the content of the \a I 'th factor and make a backup of its old content if \a backup == \c true virtual void setFactor( size_t I, const Factor &newFactor, bool backup = false ) { FactorGraph::setFactor( I, newFactor, backup ); RecomputeOR( I ); } /// Set the contents of all factors as specified by \a facs and make a backup of the old contents if \a backup == \c true virtual void setFactors( const std::map & facs, bool backup = false ) { FactorGraph::setFactors( facs, backup ); VarSet ns; for( std::map::const_iterator fac = facs.begin(); fac != facs.end(); fac++ ) ns |= fac->second.vars(); RecomputeORs( ns ); } /// Recompute all outer regions /** The factor contents of each outer region is set to the product of the factors belonging to that region. */ void RecomputeORs(); /// Recompute all outer regions involving the variables in \a vs /** The factor contents of each outer region involving at least one of the variables in \a vs is set to the product of the factors belonging to that region. */ void RecomputeORs( const VarSet &vs ); /// Recompute all outer regions involving factor \a I /** The factor contents of each outer region involving the \a I 'th factor is set to the product of the factors belonging to that region. */ void RecomputeOR( size_t I ); /// Calculates counting numbers of inner regions based upon counting numbers of outer regions /** The counting numbers of the inner regions are set using the Moebius inversion formula: * \f[ c_\beta := 1 - \sum_{\gamma \in \mathrm{an}(\beta)} c_\gamma \f] * where \f$\mathrm{an}(\beta)\f$ are the ancestors of inner region \f$\beta\f$ according to * the partial ordering induced by the subset relation (i.e., a region is a child of another * region if its variables are a subset of the variables of its parent region). */ void calcCountingNumbers(); //@} /// \name Input/output //@{ /// Writes a RegionGraph to an output stream friend std::ostream & operator << ( std::ostream & os, const RegionGraph & rg ); //@} protected: /// Helper function for constructors void construct( const FactorGraph &fg, const std::vector &ors, const std::vector &irs, const std::vector > &edges ); /// Helper function for constructors (CVM style) void constructCVM( const FactorGraph &fg, const std::vector &cl ); }; } // end of namespace dai #endif libDAI-0.2.4/include/dai/factorgraph.h0000644000263000017630000003651311334764774016336 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov random fields) #ifndef __defined_libdai_factorgraph_h #define __defined_libdai_factorgraph_h #include #include #include #include namespace dai { /// Represents a factor graph. /** Both Bayesian Networks and Markov random fields can be represented in a * unifying representation, called factor graph [\ref KFL01], * implemented in libDAI by the FactorGraph class. * * Consider a probability distribution over \f$N\f$ discrete random variables * \f$x_0,x_1,\dots,x_{N-1}\f$ that factorizes as a product of \f$M\f$ factors, each of * which depends on some subset of the variables: * \f[ * P(x_0,x_1,\dots,x_{N-1}) = \frac{1}{Z} \prod_{I=0}^{M-1} f_I(x_I), \qquad * Z = \sum_{x_0}\dots\sum_{x_{N-1}} \prod_{I=0}^{M-1} f_I(X_I). * \f] * Each factor \f$f_I\f$ is a function from an associated subset * of variables \f$X_I \subset \{x_0,x_1,\dots,x_{N-1}\}\f$ to the nonnegative * real numbers. * * For a Bayesian network, each factor corresponds to a (conditional) * probability table, whereas for a Markov random field, each factor * corresponds to a maximal clique of the undirected graph. * * Factor graphs explicitly express the factorization structure of the * corresponding probability distribution. A factor graph is a bipartite graph, * containing variable nodes and factor nodes, and an edge between a variable * node and a factor node if the corresponding factor depends on that variable. * In libDAI, this structure is represented by a BipartiteGraph. * * So basically, a FactorGraph consists of a BipartiteGraph, a vector of Var 's * and a vector of TFactor 's. * * \idea Alternative implementation of undo factor changes: the only things that have to be * undone currently are setting a factor to 1 and setting a factor to a Kronecker delta. This * could also be implemented in the TFactor itself, which could maintain its state * (ones/delta/full) and act accordingly. Update: it seems that the proposed functionality * would not be enough for CBP, for which it would make more sense to add more levels of * backup/restore. */ class FactorGraph { public: /// Stores the neighborhood structure BipartiteGraph G; /// Shorthand for BipartiteGraph::Neighbor typedef BipartiteGraph::Neighbor Neighbor; /// Shorthand for BipartiteGraph::Neighbors typedef BipartiteGraph::Neighbors Neighbors; /// Shorthand for BipartiteGraph::Edge typedef BipartiteGraph::Edge Edge; /// Iterator over factors typedef std::vector::iterator iterator; /// Constant iterator over factors typedef std::vector::const_iterator const_iterator; private: /// Stores the variables std::vector _vars; /// Stores the factors std::vector _factors; /// Stores backups of some factors std::map _backup; public: /// \name Constructors and destructors //@{ /// Default constructor FactorGraph() : G(), _vars(), _factors(), _backup() {} /// Constructs a factor graph from a vector of factors FactorGraph( const std::vector &P ); /// Constructs a factor graph from given factor and variable iterators /** \tparam FactorInputIterator Iterates over instances of type dai::Factor * \tparam VarInputIterator Iterates over instances of type Var * \pre Assumes that the set of variables in [\a var_begin, \a var_end) is the union of the variables in the factors in [\a fact_begin, \a fact_end) */ template FactorGraph(FactorInputIterator fact_begin, FactorInputIterator fact_end, VarInputIterator var_begin, VarInputIterator var_end, size_t nr_fact_hint = 0, size_t nr_var_hint = 0 ); /// Destructor virtual ~FactorGraph() {} /// Virtual copy constructor virtual FactorGraph* clone() const { return new FactorGraph(); } //@} /// \name Accessors and mutators //@{ /// Returns constant reference the \a i 'th variable const Var & var(size_t i) const { return _vars[i]; } /// Returns constant reference to all variables const std::vector & vars() const { return _vars; } /// Returns reference to \a I 'th factor Factor & factor(size_t I) { return _factors[I]; } /// Returns constant reference to \a I 'th factor const Factor & factor(size_t I) const { return _factors[I]; } /// Returns constant reference to all factors const std::vector & factors() const { return _factors; } /// Returns constant reference to neighbors of the \a i 'th variable const Neighbors & nbV( size_t i ) const { return G.nb1(i); } /// Returns constant reference to neighbors of the \a I 'th factor const Neighbors & nbF( size_t I ) const { return G.nb2(I); } /// Returns constant reference to the \a _I 'th neighbor of the \a i 'th variable const Neighbor & nbV( size_t i, size_t _I ) const { return G.nb1(i)[_I]; } /// Returns constant reference to the \a _i 'th neighbor of the \a I 'th factor const Neighbor & nbF( size_t I, size_t _i ) const { return G.nb2(I)[_i]; } //@} /// \name Iterator interface //@{ /// Returns iterator pointing to first factor iterator begin() { return _factors.begin(); } /// Returns constant iterator pointing to first factor const_iterator begin() const { return _factors.begin(); } /// Returns iterator pointing beyond last factor iterator end() { return _factors.end(); } /// Returns constant iterator pointing beyond last factor const_iterator end() const { return _factors.end(); } //@} /// \name Queries //@{ /// Returns number of variables size_t nrVars() const { return vars().size(); } /// Returns number of factors size_t nrFactors() const { return factors().size(); } /// Calculates number of edges /** \note Time complexity: O(nrVars()) */ size_t nrEdges() const { return G.nrEdges(); } /// Returns the index of a particular variable /** \note Time complexity: O(nrVars()) * \throw OBJECT_NOT_FOUND if the variable is not part of this factor graph */ size_t findVar( const Var &n ) const { size_t i = find( vars().begin(), vars().end(), n ) - vars().begin(); if( i == nrVars() ) DAI_THROW(OBJECT_NOT_FOUND); return i; } /// Returns a set of indexes corresponding to a set of variables /** \note Time complexity: O( nrVars() * ns.size() ) * \throw OBJECT_NOT_FOUND if one of the variables is not part of this factor graph */ std::set findVars( VarSet &ns ) const { std::set indexes; for( VarSet::const_iterator n = ns.begin(); n != ns.end(); n++ ) indexes.insert( findVar( *n ) ); return indexes; } /// Returns index of the first factor that depends on the variables /** \note Time complexity: O(nrFactors()) * \throw OBJECT_NOT_FOUND if no factor in this factor graph depends on those variables */ size_t findFactor( const VarSet &ns ) const { size_t I; for( I = 0; I < nrFactors(); I++ ) if( factor(I).vars() == ns ) break; if( I == nrFactors() ) DAI_THROW(OBJECT_NOT_FOUND); return I; } /// Return all variables that occur in a factor involving the \a i 'th variable, itself included VarSet Delta( size_t i ) const; /// Return all variables that occur in a factor involving some variable in \a vs, \a vs itself included VarSet Delta( const VarSet &vs ) const; /// Return all variables that occur in a factor involving the \a i 'th variable, itself excluded VarSet delta( size_t i ) const; /// Return all variables that occur in a factor involving some variable in \a vs, \a vs itself excluded VarSet delta( const VarSet &vs ) const { return Delta( vs ) / vs; } /// Returns \c true if the factor graph is connected bool isConnected() const { return G.isConnected(); } /// Returns \c true if the factor graph is a tree (i.e., has no cycles and is connected) bool isTree() const { return G.isTree(); } /// Returns \c true if each factor depends on at most two variables bool isPairwise() const; /// Returns \c true if each variable has only two possible values bool isBinary() const; /// Returns the cliques (fully connected subgraphs of the corresponding Markov graph) in this factor graph std::vector Cliques() const; //@} /// \name Backup/restore mechanism for factors //@{ /// Set the content of the \a I 'th factor and make a backup of its old content if \a backup == \c true virtual void setFactor( size_t I, const Factor &newFactor, bool backup = false ) { DAI_ASSERT( newFactor.vars() == factor(I).vars() ); if( backup ) backupFactor( I ); _factors[I] = newFactor; } /// Set the contents of all factors as specified by \a facs and make a backup of the old contents if \a backup == \c true virtual void setFactors( const std::map & facs, bool backup = false ) { for( std::map::const_iterator fac = facs.begin(); fac != facs.end(); fac++ ) { if( backup ) backupFactor( fac->first ); setFactor( fac->first, fac->second ); } } /// Makes a backup of the \a I 'th factor /** \throw MULTIPLE_UNDO if a backup already exists */ void backupFactor( size_t I ); /// Restores the \a I 'th factor from the backup (it should be backed up first) void restoreFactor( size_t I ); /// Backup the factors specified by indices in \a facs /** \throw MULTIPLE_UNDO if a backup already exists */ virtual void backupFactors( const std::set & facs ); /// Restore all factors to the backup copies virtual void restoreFactors(); /// Makes a backup of all factors connected to a set of variables /** \throw MULTIPLE_UNDO if a backup already exists */ void backupFactors( const VarSet &ns ); /// Restores all factors connected to a set of variables from their backups void restoreFactors( const VarSet &ns ); //@} /// \name Transformations //@{ /// Returns a copy of \c *this, where all factors that are subsumed by some larger factor are merged with the larger factors. FactorGraph maximalFactors() const; /// Clamp the \a i 'th variable to value \a x (i.e. multiply with a Kronecker delta \f$\delta_{x_i,x}\f$); /** \note This version changes the factor graph structure and thus returns a newly constructed FactorGraph * and keeps the current one constant, contrary to clamp() */ FactorGraph clamped( size_t i, size_t x ) const; //@} /// \name Operations //@{ /// Clamp the \a i 'th variable to value \a x (i.e. multiply with a Kronecker delta \f$\delta_{x_i, x}\f$) /** If \a backup == \c true, make a backup of all factors that are changed */ virtual void clamp( size_t i, size_t x, bool backup = false ); /// Clamp a variable in a factor graph to have one out of a list of values /** If \a backup == \c true, make a backup of all factors that are changed */ void clampVar( size_t i, const std::vector &xis, bool backup = false ); /// Clamp a factor in a factor graph to have one out of a list of values /** If \a backup == \c true, make a backup of all factors that are changed */ void clampFactor( size_t I, const std::vector &xIs, bool backup = false ); /// Set all factors interacting with the \a i 'th variable to 1 /** If \a backup == \c true, make a backup of all factors that are changed */ virtual void makeCavity( size_t i, bool backup = false ); //@} /// \name Input/Output //@{ /// Reads a factor graph from a file /** \see \ref fileformats-factorgraph * \throw CANNOT_READ_FILE if the file cannot be opened * \throw INVALID_FACTORGRAPH_FILE if the file is not valid */ void ReadFromFile( const char *filename ); /// Writes a factor graph to a file /** \see \ref fileformats-factorgraph * \throw CANNOT_WRITE_FILE if the file cannot be written */ void WriteToFile( const char *filename, size_t precision=15 ) const; /// Writes a factor graph to an output stream /** \see \ref fileformats-factorgraph */ friend std::ostream& operator<< (std::ostream &os, const FactorGraph &fg ); /// Reads a factor graph from an input stream /** \see \ref fileformats-factorgraph * \throw INVALID_FACTORGRAPH_FILE if the input stream is not valid */ friend std::istream& operator>> (std::istream &is, FactorGraph &fg ); /// Writes a factor graph to a GraphViz .dot file void printDot( std::ostream& os ) const; //@} private: /// Part of constructors (creates edges, neighbors and adjacency matrix) void constructGraph( size_t nrEdges ); }; template FactorGraph::FactorGraph(FactorInputIterator fact_begin, FactorInputIterator fact_end, VarInputIterator var_begin, VarInputIterator var_end, size_t nr_fact_hint, size_t nr_var_hint ) : G(), _backup() { // add factors size_t nrEdges = 0; _factors.reserve( nr_fact_hint ); for( FactorInputIterator p2 = fact_begin; p2 != fact_end; ++p2 ) { _factors.push_back( *p2 ); nrEdges += p2->vars().size(); } // add variables _vars.reserve( nr_var_hint ); for( VarInputIterator p1 = var_begin; p1 != var_end; ++p1 ) _vars.push_back( *p1 ); // create graph structure constructGraph( nrEdges ); } /** \example example.cpp * This example illustrates how to read a factor graph from a file and how to * run several inference algorithms (junction tree, loopy belief propagation, * and the max-product algorithm) on it. */ /** \example example_sprinkler.cpp * This example illustrates how to manually construct a factor graph and * write it to a file. */ } // end of namespace dai #endif libDAI-0.2.4/include/dai/mr.h0000644000263000017630000001756711334764774014464 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2007 Bastian Wemmenhove * Copyright (C) 2007-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines class MR, which implements loop corrections as proposed by Montanari and Rizzo #ifndef __defined_libdai_mr_h #define __defined_libdai_mr_h #include #include #include #include #include #include #include #include namespace dai { /// Approximate inference algorithm by Montanari and Rizzo [\ref MoR05] /** \author Bastian Wemmenhove wrote the original implementation before it was merged into libDAI * \todo Clean up code (use a BipartiteGraph-like implementation for the graph structure, and BBP for response propagation). */ class MR : public DAIAlgFG { private: /// Is the underlying factor graph supported? bool supported; /// con[i] = connectivity of spin \a i std::vector con; /// nb[i] are the neighbours of spin \a i std::vector > nb; /// tJ[i][_j] is the hyperbolic tangent of the interaction between spin \a i and its neighbour nb[i][_j] std::vector > tJ; /// theta[i] is the local field on spin \a i std::vector theta; /// M[i][_j] is \f$ M^{(i)}_j \f$ std::vector > M; /// The \a _j 'th neighbour of spin \a i has spin \a i as its kindex[i][_j]'th neighbour std::vector > kindex; /// Cavity correlations std::vector > > cors; /// Maximum connectivity static const size_t kmax = 31; /// Type used for managing a subset of neighbors typedef boost::dynamic_bitset<> sub_nb; /// Number of variables (spins) size_t N; /// Magnetizations std::vector Mag; /// Maximum difference encountered so far Real _maxdiff; /// Number of iterations needed size_t _iters; public: /// Parameters for MR struct Properties { /// Enumeration of different types of update equations /** The possible update equations are: * - FULL full updates, slow but accurate * - LINEAR linearized updates, faster but less accurate */ DAI_ENUM(UpdateType,FULL,LINEAR); /// Enumeration of different ways of initializing the cavity correlations /** The possible cavity initializations are: * - RESPPROP using response propagation ("linear response") * - CLAMPING using clamping and BP * - EXACT using JunctionTree */ DAI_ENUM(InitType,RESPPROP,CLAMPING,EXACT); /// Verbosity (amount of output sent to stderr) size_t verbose; /// Tolerance for convergence test Real tol; /// Update equations UpdateType updates; /// How to initialize the cavity correlations InitType inits; } props; /// Name of this inference method static const char *Name; public: /// Default constructor MR() : DAIAlgFG(), supported(), con(), nb(), tJ(), theta(), M(), kindex(), cors(), N(), Mag(), _maxdiff(), _iters(), props() {} /// Construct from FactorGraph \a fg and PropertySet \a opts /** \param opts Parameters @see Properties * \note This implementation only deals with binary variables and pairwise interactions. * \throw NOT_IMPLEMENTED if \a fg has factors depending on three or more variables or has variables with more than two possible states. */ MR( const FactorGraph &fg, const PropertySet &opts ); /// \name General InfAlg interface //@{ virtual MR* clone() const { return new MR(*this); } virtual std::string identify() const; virtual Factor belief( const Var &v ) const { return beliefV( findVar( v ) ); } virtual Factor belief( const VarSet &/*vs*/ ) const { DAI_THROW(NOT_IMPLEMENTED); return Factor(); } virtual Factor beliefV( size_t i ) const; virtual std::vector beliefs() const; virtual Real logZ() const { DAI_THROW(NOT_IMPLEMENTED); return 0.0; } virtual void init() {} virtual void init( const VarSet &/*ns*/ ) { DAI_THROW(NOT_IMPLEMENTED); } virtual Real run(); virtual Real maxDiff() const { return _maxdiff; } virtual size_t Iterations() const { return _iters; } virtual void setProperties( const PropertySet &opts ); virtual PropertySet getProperties() const; virtual std::string printProperties() const; //@} private: /// Returns the signum of \a a Real sign(Real a) { return (a >= 0) ? 1.0 : -1.0; } /// Initialize N, con, nb, tJ, theta void init(size_t Nin, Real *_w, Real *_th); /// Initialize kindex void makekindex(); /// Initialize cors Real init_cor(); /// Calculate cors using response propagation Real init_cor_resp(); /// Iterate update equations for cavity fields void solvemcav(); /// Calculate magnetizations void solveM(); /// Calculate the product of all tJ[i][_j] for _j in A /** \param i variable index * \param A subset of neighbors of variable \a i */ Real _tJ(size_t i, sub_nb A); /// Calculate \f$ \Omega^{(i)}_{j,l} \f$ as defined in [\ref MoR05] eqn. (2.15) Real Omega(size_t i, size_t _j, size_t _l); /// Calculate \f$ T^{(i)}_A \f$ as defined in [\ref MoR05] eqn. (2.17) with \f$ A = \{l_1,l_2,\dots\} \f$ /** \param i variable index * \param A subset of neighbors of variable \a i */ Real T(size_t i, sub_nb A); /// Calculates \f$ T^{(i)}_j \f$ where \a j is the \a _j 'th neighbor of \a i Real T(size_t i, size_t _j); /// Calculates \f$ \Gamma^{(i)}_{j,l_1l_2} \f$ as defined in [\ref MoR05] eqn. (2.16) Real Gamma(size_t i, size_t _j, size_t _l1, size_t _l2); /// Calculates \f$ \Gamma^{(i)}_{l_1l_2} \f$ as defined in [\ref MoK07] on page 1141 Real Gamma(size_t i, size_t _l1, size_t _l2); /// Approximates moments of variables in \a A /** Calculate the moment of variables in \a A from M and cors, neglecting higher order cumulants, * defined as the sum over all partitions of A into subsets of cardinality two at most of the * product of the cumulants (either first order, i.e. M, or second order, i.e. cors) of the * entries of the partitions. * * \param i variable index * \param A subset of neighbors of variable \a i */ Real appM(size_t i, sub_nb A); /// Calculate sum over all even/odd subsets B of \a A of _tJ(j,B) appM(j,B) /** \param j variable index * \param A subset of neighbors of variable \a j * \param sum_even on return, will contain the sum over all even subsets * \param sum_odd on return, will contain the sum over all odd subsets */ void sum_subs(size_t j, sub_nb A, Real *sum_even, Real *sum_odd); }; } // end of namespace dai #endif libDAI-0.2.4/include/dai/properties.h0000644000263000017630000002301311334764774016221 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines the Property and PropertySet classes, which are mainly used for managing parameters of inference algorithms #ifndef __defined_libdai_properties_h #define __defined_libdai_properties_h #include #include #include #include #include #include #include #include #include namespace dai { /// Type of the key of a Property typedef std::string PropertyKey; /// Type of the value of a Property typedef boost::any PropertyValue; /// A Property is a pair of a key and a corresponding value typedef std::pair Property; /// Writes a Property object (key-value pair) to an output stream std::ostream& operator<< ( std::ostream & os, const Property &p ); /// Represents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue) /** Properties are used for specifying parameters of algorithms in a convenient way, where the values of * the parameters can be of different types (e.g., strings, doubles, integers, enums). A PropertySet is * an attempt to mimic the functionality of a Python dictionary object in C++, using the boost::any class. * * A PropertySet can be converted to and from a string, using the following format: * * [key1=val1,key2=val2,...,keyn=valn] * * That is, * - the whole PropertySet is wrapped in square brackets ("[", "]") * - all properties in the PropertySet are seperated by a comma (",") * - each Property consists of: * - the name of the key * - an equality sign ("=") * - its value (represented as a string) * * Also, a PropertySet provides functionality for converting the representation of * individual values from some arbitrary type to and from std::string. * * \note Not all types are automatically supported; if a type is unknown, an UNKNOWN_PROPERTY_TYPE * exception is thrown. Adding support for a new type can be done in the body of the * operator<<(std::ostream &, const Property &). */ class PropertySet : private std::map { public: /// \name Constructors and destructors //@{ /// Default constructor PropertySet() {} /// Construct from a string /** \param s string in the format "[key1=val1,key2=val2,...,keyn=valn]" */ PropertySet( const std::string& s ) { std::stringstream ss; ss << s; ss >> *this; } //@} /// \name Setting property keys/values //@{ /// Sets a property (a key \a key with a corresponding value \a val) PropertySet& Set( const PropertyKey& key, const PropertyValue& val ) { this->operator[](key) = val; return *this; } /// Set properties according to \a newProps, overriding properties that already exist with new values PropertySet& Set( const PropertySet& newProps ) { const std::map *m = &newProps; foreach(value_type i, *m) Set( i.first, i.second ); return *this; } /// Shorthand for (temporarily) adding properties /** \par Example: \code PropertySet p()("method","BP")("verbose",1)("tol",1e-9) \endcode */ PropertySet operator()( const PropertyKey& key, const PropertyValue& val ) const { PropertySet copy = *this; return copy.Set(key,val); } /// Sets a property (a key \a key with a corresponding value \a val, which is first converted from \a ValueType to string) /** The implementation makes use of boost::lexical_cast. * \tparam ValueType Type from which the value should be cast * \throw IMPOSSIBLE_TYPECAST if the type cast cannot be done */ template PropertySet& setAsString( const PropertyKey& key, ValueType& val ) { try { return Set( key, boost::lexical_cast(val) ); } catch( boost::bad_lexical_cast & ) { DAI_THROWE(IMPOSSIBLE_TYPECAST,"Cannot cast value of property '" + key + "' to string."); } } /// Converts the type of the property value corresponding with \a key from string to \a ValueType (if necessary) /** The implementation makes use of boost::lexical_cast * \tparam ValueType Type to which the value should be cast * \throw IMPOSSIBLE_TYPECAST if the type cast cannot be done */ template void ConvertTo( const PropertyKey& key ) { PropertyValue val = Get(key); if( val.type() != typeid(ValueType) ) { DAI_ASSERT( val.type() == typeid(std::string) ); try { Set(key, boost::lexical_cast(GetAs(key))); } catch(boost::bad_lexical_cast &) { DAI_THROWE(IMPOSSIBLE_TYPECAST,"Cannot cast value of property '" + key + "' from string to desired type."); } } } //@} //@} /// \name Queries //@{ /// Check if a property with the given \a key is defined bool hasKey( const PropertyKey& key ) const { PropertySet::const_iterator x = find(key); return (x != this->end()); } /// Returns a set containing all keys std::set keys() const { std::set res; const_iterator i; for( i = begin(); i != end(); i++ ) res.insert( i->first ); return res; } /// Gets the value corresponding to \a key /** \throw OBJECT_NOT_FOUND if the key cannot be found in \c *this */ const PropertyValue& Get( const PropertyKey& key ) const { PropertySet::const_iterator x = find(key); if( x == this->end() ) DAI_THROWE(OBJECT_NOT_FOUND,"PropertySet::Get cannot find property '" + key + "'"); return x->second; } /// Gets the value corresponding to \a key, cast to \a ValueType /** \tparam ValueType Type to which the value should be cast * \throw OBJECT_NOT_FOUND if the key cannot be found in \c *this * \throw IMPOSSIBLE_TYPECAST if the type cast cannot be done */ template ValueType GetAs( const PropertyKey& key ) const { try { return boost::any_cast(Get(key)); } catch( const boost::bad_any_cast & ) { DAI_THROWE(IMPOSSIBLE_TYPECAST,"Cannot cast value of property '" + key + "' to desired type."); return ValueType(); } } /// Gets the value corresponding to \a key, cast to \a ValueType, converting from a string if necessary /** If the type of the value is already equal to \a ValueType, no conversion is done. * Otherwise, the type of the value should be a std::string, in which case boost::lexical_cast is * used to convert this to \a ValueType. * \tparam ValueType Type to which the value should be cast/converted * \throw OBJECT_NOT_FOUND if the key cannot be found in \c *this * \throw IMPOSSIBLE_TYPECAST if the type cast cannot be done */ template ValueType getStringAs( const PropertyKey& key ) const { PropertyValue val = Get(key); if( val.type() == typeid(ValueType) ) { return boost::any_cast(val); } else if( val.type() == typeid(std::string) ) { try { return boost::lexical_cast(GetAs(key)); } catch(boost::bad_lexical_cast &) { DAI_THROWE(IMPOSSIBLE_TYPECAST,"Cannot cast value of property '" + key + "' from string to desired type."); } } else DAI_THROWE(IMPOSSIBLE_TYPECAST,"Cannot cast value of property '" + key + "' from string to desired type."); return ValueType(); } //@} /// \name Input/output //@{ /// Writes a PropertySet object to an output stream. /** It uses the format "[key1=val1,key2=val2,...,keyn=valn]". * \note Only a subset of all possible types is supported (see the implementation of this function). * Adding support for more types has to be done by hand. * \throw UNKNOWN_PROPERTY_TYPE if the type of a property value is not supported. */ friend std::ostream& operator<< ( std::ostream& os, const PropertySet& ps ); /// Reads a PropertySet object from an input stream. /** It expects a string in the format "[key1=val1,key2=val2,...,keyn=valn]". * Values are stored as strings. * \throw MALFORMED_PROPERTY if the string is not in the expected format */ friend std::istream& operator>> ( std::istream& is, PropertySet& ps ); //@} }; } // end of namespace dai #endif libDAI-0.2.4/include/dai/util.h0000644000263000017630000001300311334764774015000 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines general utility functions and adds an abstraction layer for platform-dependent functionality #ifndef __defined_libdai_util_h #define __defined_libdai_util_h #include #include #include #include #include #include #include #include #if defined(WINDOWS) #include // only present in boost 1.37 and higher #elif defined(CYGWIN) #include // only present in boost 1.37 and higher #elif defined(MACOSX) #include // only present in boost 1.37 and higher #else #include // only present in modern GCC distributions #endif /// An alias to the BOOST_FOREACH macro from the boost::foreach library #define foreach BOOST_FOREACH #ifdef DAI_DEBUG /// \brief "Print variable". Prints the text of an expression, followed by its value (only if DAI_DEBUG is defined) /** * Useful debugging macro to see what your code is doing. * Example: \code DAI_PV(3+4) \endcode * Output: \code 3+4= 7 \endcode */ #define DAI_PV(x) do {std::cerr << #x "= " << (x) << std::endl;} while(0) /// "Debugging message": Prints a message (only if DAI_DEBUG is defined) #define DAI_DMSG(str) do {std::cerr << str << std::endl;} while(0) #else #define DAI_PV(x) do {} while(0) #define DAI_DMSG(str) do {} while(0) #endif /// Macro to write message \a stmt to \c std::cerr if \a props.verbose >= \a n #define DAI_IFVERB(n, stmt) if(props.verbose>=n) { std::cerr << stmt; } #ifdef WINDOWS /// Returns true if argument is NAN (Not A Number) bool isnan( double x ); /// Returns inverse hyperbolic tangent of argument double atanh( double x ); /// Returns log(1+x) double log1p( double x ); /// Define INFINITY #define INFINITY (std::numeric_limits::infinity()) #endif namespace dai { /// Real number (alias for \c double, which could be changed to long double if necessary) typedef double Real; /// Returns logarithm of \a x inline Real log( Real x ) { return std::log(x); } /// Returns logarithm of \a x, or 0 if \a x == 0 inline Real log0( Real x ) { return x ? std::log(x) : 0; } /// Returns exponent of \a x inline Real exp( Real x ) { return std::exp(x); } /// Returns maximum value of a std::vector Real max( const std::vector &v ); /// hash_map is an alias for \c std::tr1::unordered_map. /** We use the (experimental) TR1 unordered_map implementation included in modern GCC distributions or in boost versions 1.37 and higher. */ template > class hash_map : public std::tr1::unordered_map {}; /// Returns wall clock time in seconds double toc(); /// Returns absolute value of \a t template inline T abs( const T &t ) { return (t < 0) ? (-t) : t; } /// Sets the random seed void rnd_seed( size_t seed ); /// Returns a real number, distributed uniformly on [0,1) Real rnd_uniform(); /// Returns a real number from a standard-normal distribution Real rnd_stdnormal(); /// Returns a random integer in interval [\a min, \a max] int rnd_int( int min, int max ); /// Returns a random integer in the half-open interval [0, \a n) inline int rnd( int n ) { return rnd_int( 0, n-1 ); } /// Writes a \c std::vector<> to a \c std::ostream template std::ostream& operator << (std::ostream& os, const std::vector & x) { os << "("; for( typename std::vector::const_iterator it = x.begin(); it != x.end(); it++ ) os << (it != x.begin() ? ", " : "") << *it; os << ")"; return os; } /// Writes a \c std::set<> to a \c std::ostream template std::ostream& operator << (std::ostream& os, const std::set & x) { os << "{"; for( typename std::set::const_iterator it = x.begin(); it != x.end(); it++ ) os << (it != x.begin() ? ", " : "") << *it; os << "}"; return os; } /// Writes a \c std::map<> to a \c std::ostream template std::ostream& operator << (std::ostream& os, const std::map & x) { os << "{"; for( typename std::map::const_iterator it = x.begin(); it != x.end(); it++ ) os << (it != x.begin() ? ", " : "") << it->first << "->" << it->second; os << "}"; return os; } /// Writes a \c std::pair<> to a \c std::ostream template std::ostream& operator << (std::ostream& os, const std::pair & x) { os << "(" << x.first << ", " << x.second << ")"; return os; } /// Concatenates two vectors template std::vector concat( const std::vector& u, const std::vector& v ) { std::vector w; w.reserve( u.size() + v.size() ); for( size_t i = 0; i < u.size(); i++ ) w.push_back( u[i] ); for( size_t i = 0; i < v.size(); i++ ) w.push_back( v[i] ); return w; } /// Split a string into tokens delimited by one of the characters in \a delim void tokenizeString( const std::string& s, std::vector& outTokens, const std::string& delim="\t\n" ); } // end of namespace dai #endif libDAI-0.2.4/include/dai/trwbp.h0000644000263000017630000001112011334764774015157 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ /// \file /// \brief Defines class TRWBP, which implements Tree-Reweighted Belief Propagation #ifndef __defined_libdai_trwbp_h #define __defined_libdai_trwbp_h #include #include #include #include #include #include namespace dai { /// Approximate inference algorithm "Tree-Reweighted Belief Propagation" [\ref WJW03] /** The Tree-Reweighted Belief Propagation algorithm is like Belief * Propagation, but associates each factor with a scale parameter. * which controls the divergence measure being minimized. * * The messages \f$m_{I\to i}(x_i)\f$ are passed from factors \f$I\f$ to variables \f$i\f$. * The update equation is given by: * \f[ m_{I\to i}(x_i) \propto \sum_{x_{N_I\setminus\{i\}}} f_I(x_I)^{1/c_I} \prod_{j\in N_I\setminus\{i\}} m_{I\to j}^{c_I-1} \prod_{J\in N_j\setminus\{I\}} m_{J\to j}^{c_J} \f] * After convergence, the variable beliefs are calculated by: * \f[ b_i(x_i) \propto \prod_{I\in N_i} m_{I\to i}^{c_I} \f] * and the factor beliefs are calculated by: * \f[ b_I(x_I) \propto f_I(x_I)^{1/c_I} \prod_{j \in N_I} m_{I\to j}^{c_I-1} \prod_{J\in N_j\setminus\{I\}} m_{J\to j}^{c_J} \f] * The logarithm of the partition sum is approximated by: * \f[ \log Z = \sum_{I} \sum_{x_I} b_I(x_I) \big( \log f_I(x_I) - c_I \log b_I(x_I) \big) + \sum_{i} (c_i - 1) \sum_{x_i} b_i(x_i) \log b_i(x_i) \f] * where the variable weights are defined as * \f[ c_i := \sum_{I \in N_i} c_I \f] * * \note TRWBP is actually equivalent to FBP * \todo Add nice way to set weights * \todo Merge code of FBP and TRWBP */ class TRWBP : public BP { protected: /// "Edge weights" (indexed by factor ID) /** In [\ref WJW03], only unary or pairwise factors are considered. * Here we are more general by having a weight for each factor in the * factor graph. If unary factors have weight 1, and higher-order factors * are absent, then we have the special case considered in [\ref WJW03]. */ std::vector _weight; public: /// Name of this inference algorithm static const char *Name; public: /// \name Constructors/destructors //@{ /// Default constructor TRWBP() : BP(), _weight() {} /// Construct from FactorGraph \a fg and PropertySet \a opts /** \param opts Parameters @see BP::Properties */ TRWBP( const FactorGraph &fg, const PropertySet &opts ) : BP(fg, opts), _weight() { setProperties( opts ); construct(); } //@} /// \name General InfAlg interface //@{ virtual TRWBP* clone() const { return new TRWBP(*this); } virtual std::string identify() const; virtual Real logZ() const; //@} /// \name TRWBP accessors/mutators for scale parameters //@{ /// Returns weight corresponding to the \a I 'th factor Real Weight( size_t I ) const { return _weight[I]; } /// Returns constant reference to vector of all weights const std::vector& Weights() const { return _weight; } /// Sets the weight of the \a I 'th factor to \a c void setWeight( size_t I, Real c ) { _weight[I] = c; } /// Sets the weights of all factors simultaenously /** \note Faster than calling setWeight(size_t,Real) for each factor */ void setWeights( const std::vector &c ) { _weight = c; } protected: /// Calculate the product of factor \a I and the incoming messages /** If \a without_i == \c true, the message coming from variable \a i is omitted from the product * \note This function is used by calcNewMessage() and calcBeliefF() */ virtual Prob calcIncomingMessageProduct( size_t I, bool without_i, size_t i ) const; /// Calculates unnormalized belief of variable \a i virtual void calcBeliefV( size_t i, Prob &p ) const; // Calculates unnormalized belief of factor \a I virtual void calcBeliefF( size_t I, Prob &p ) const { p = calcIncomingMessageProduct( I, false, 0 ); } // Helper function for constructors virtual void construct(); }; } // end of namespace dai #endif libDAI-0.2.4/include/dai/evidence.h0000644000263000017630000000564411334764774015621 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Charles Vaske [cvaske at soe dot ucsc dot edu] * Copyright (C) 2009 University of California, Santa Cruz */ /// \file /// \brief Defines class Evidence, which stores multiple observations of joint states of variables #ifndef __defined_libdai_evidence_h #define __defined_libdai_evidence_h #include #include namespace dai { /// Stores a data set consisting of multiple samples, where each sample is the observed joint state of some variables. /** \note Each sample can describe the joint state of a different set of variables, * in order to be able to deal with missing data. * * \author Charles Vaske */ class Evidence { public: /// Stores joint state of a set of variables typedef std::map Observation; private: /// Each sample is an observed joint state of some variables std::vector _samples; public: /// Default constructor Evidence() : _samples() {} /// Construct from \a samples Evidence( std::vector &samples ) : _samples(samples) {} /// Read in tabular data from a stream and add the read samples to \c *this. /** \param is Input stream in .tab file format, describing joint observations of variables in \a fg * \param fg Factor graph describing the corresponding variables * \see \ref fileformats-evidence * \throw INVALID_EVIDENCE_FILE if the input stream is not valid */ void addEvidenceTabFile( std::istream& is, FactorGraph& fg ); /// Returns number of stored samples size_t nrSamples() const { return _samples.size(); } /// \name Iterator interface //@{ /// Iterator over the samples typedef std::vector::iterator iterator; /// Constant iterator over the samples typedef std::vector::const_iterator const_iterator; /// Returns iterator that points to the first sample iterator begin() { return _samples.begin(); } /// Returns constant iterator that points to the first sample const_iterator begin() const { return _samples.begin(); } /// Returns iterator that points beyond the last sample iterator end() { return _samples.end(); } /// Returns constant iterator that points beyond the last sample const_iterator end() const { return _samples.end(); } //@} private: /// Read in tabular data from a stream and add the read samples to \c *this. void addEvidenceTabFile( std::istream& is, std::map &varMap ); }; } // end of namespace dai #endif libDAI-0.2.4/include/dai/daialg.h0000644000263000017630000002740011334764774015252 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG). #ifndef __defined_libdai_daialg_h #define __defined_libdai_daialg_h #include #include #include #include #include #include namespace dai { /// InfAlg is an abstract base class, defining the common interface of all inference algorithms in libDAI. /** \idea General marginalization functions like calcMarginal() now copy a complete InfAlg object. Instead, * it would make more sense that they construct a new object without copying the FactorGraph or RegionGraph. * Or they can simply be made methods of the general InfAlg class. * \idea Use a PropertySet as output of an InfAlg, instead of functions like maxDiff() and Iterations(). */ class InfAlg { public: /// \name Constructors/destructors //@{ /// Virtual destructor (needed because this class contains virtual functions) virtual ~InfAlg() {} /// Returns a pointer to a new, cloned copy of \c *this (i.e., virtual copy constructor) virtual InfAlg* clone() const = 0; //@} /// \name Queries //@{ /// Identifies itself for logging purposes virtual std::string identify() const = 0; /// Returns reference to underlying FactorGraph. virtual FactorGraph &fg() = 0; /// Returns constant reference to underlying FactorGraph. virtual const FactorGraph &fg() const = 0; //@} /// \name Inference interface //@{ /// Initializes all data structures of the approximate inference algorithm. /** \note This method should be called at least once before run() is called. */ virtual void init() = 0; /// Initializes all data structures corresponding to some set of variables. /** This method can be used to do a partial initialization after a part of the factor graph has changed. * Instead of initializing all data structures, it only initializes those involving the variables in \a vs. * \throw NOT_IMPLEMENTED if not implemented/supported */ virtual void init( const VarSet &vs ) = 0; /// Runs the approximate inference algorithm. /** \note Before run() is called the first time, init() should have been called. */ virtual Real run() = 0; /// Returns the (approximate) marginal probability distribution of a variable. /** \note Before this method is called, run() should have been called. */ virtual Factor belief( const Var &v ) const { return belief( VarSet(v) ); } /// Returns the (approximate) marginal probability distribution of a set of variables. /** \note Before this method is called, run() should have been called. * \throw NOT_IMPLEMENTED if not implemented/supported. * \throw BELIEF_NOT_AVAILABLE if the requested belief cannot be calculated with this algorithm. */ virtual Factor belief( const VarSet &vs ) const = 0; /// Returns the (approximate) marginal probability distribution of the variable with index \a i. /** For some approximate inference algorithms, using beliefV() is preferred to belief() for performance reasons. * \note Before this method is called, run() should have been called. */ virtual Factor beliefV( size_t i ) const { return belief( fg().var(i) ); } /// Returns the (approximate) marginal probability distribution of the variables on which factor \a I depends. /** For some approximate inference algorithms, using beliefF() is preferred to belief() for performance reasons. * \note Before this method is called, run() should have been called. */ virtual Factor beliefF( size_t I ) const { return belief( fg().factor(I).vars() ); } /// Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm. /** \note Before this method is called, run() should have been called. */ virtual std::vector beliefs() const = 0; /// Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph). /** \note Before this method is called, run() should have been called. * \throw NOT_IMPLEMENTED if not implemented/supported */ virtual Real logZ() const = 0; /// Returns maximum difference between single variable beliefs in the last iteration. /** \throw NOT_IMPLEMENTED if not implemented/supported */ virtual Real maxDiff() const = 0; /// Returns number of iterations done (one iteration passes over the complete factorgraph). /** \throw NOT_IMPLEMENTED if not implemented/supported */ virtual size_t Iterations() const = 0; //@} /// \name Changing the factor graph //@{ /// Clamp variable with index \a i to value \a x (i.e. multiply with a Kronecker delta \f$\delta_{x_i, x}\f$) /** If \a backup == \c true, make a backup of all factors that are changed. */ virtual void clamp( size_t i, size_t x, bool backup = false ) = 0; /// Sets all factors interacting with variable with index \a i to one. /** If \a backup == \c true, make a backup of all factors that are changed. */ virtual void makeCavity( size_t i, bool backup = false ) = 0; //@} /// \name Backup/restore mechanism for factors //@{ /// Make a backup copy of factor \a I /** \throw MULTIPLE_UNDO if a backup already exists */ virtual void backupFactor( size_t I ) = 0; /// Make backup copies of all factors involving the variables in \a vs /** \throw MULTIPLE_UNDO if a backup already exists */ virtual void backupFactors( const VarSet &vs ) = 0; /// Restore factor \a I from its backup copy virtual void restoreFactor( size_t I ) = 0; /// Restore the factors involving the variables in \a vs from their backup copies virtual void restoreFactors( const VarSet &vs ) = 0; //@} /// \name Managing parameters //@{ /// Set parameters of this inference algorithm. /** The parameters are set according to the PropertySet \a opts. * The values can be stored either as std::string or as the type of the corresponding MF::props member. */ virtual void setProperties( const PropertySet &opts ) = 0; /// Returns parameters of this inference algorithm converted into a PropertySet. virtual PropertySet getProperties() const = 0; /// Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]". virtual std::string printProperties() const = 0; //@} }; /// Combines the abstract base class InfAlg with a graphical model (e.g., a FactorGraph or RegionGraph). /** Inference algorithms in libDAI directly inherit from a DAIAlg, currently either * from a DAIAlg or from a DAIAlg. * * \tparam GRM Should be castable to FactorGraph * \idea A DAIAlg should not inherit from a FactorGraph or RegionGraph, but should * store a reference to the graphical model object. This prevents needless copying * of (possibly large) data structures. Disadvantage: the caller must not change * the graphical model between calls to the inference algorithm (maybe a smart_ptr * or some locking mechanism would help here?). */ template class DAIAlg : public InfAlg, public GRM { public: /// \name Constructors/destructors //@{ /// Default constructor DAIAlg() : InfAlg(), GRM() {} /// Construct from GRM DAIAlg( const GRM &grm ) : InfAlg(), GRM(grm) {} //@} /// \name Queries //@{ /// Returns reference to underlying FactorGraph. FactorGraph &fg() { return (FactorGraph &)(*this); } /// Returns constant reference to underlying FactorGraph. const FactorGraph &fg() const { return (const FactorGraph &)(*this); } //@} /// \name Changing the factor graph //@{ /// Clamp variable with index \a i to value \a x (i.e. multiply with a Kronecker delta \f$\delta_{x_i, x}\f$) /** If \a backup == \c true, make a backup of all factors that are changed. */ void clamp( size_t i, size_t x, bool backup = false ) { GRM::clamp( i, x, backup ); } /// Sets all factors interacting with variable with index \a i to one. /** If \a backup == \c true, make a backup of all factors that are changed. */ void makeCavity( size_t i, bool backup = false ) { GRM::makeCavity( i, backup ); } //@} /// \name Backup/restore mechanism for factors //@{ /// Make a backup copy of factor \a I void backupFactor( size_t I ) { GRM::backupFactor( I ); } /// Make backup copies of all factors involving the variables in \a vs void backupFactors( const VarSet &vs ) { GRM::backupFactors( vs ); } /// Restore factor \a I from its backup copy void restoreFactor( size_t I ) { GRM::restoreFactor( I ); } /// Restore the factors involving the variables in \a vs from their backup copies void restoreFactors( const VarSet &vs ) { GRM::restoreFactors( vs ); } //@} }; /// Base class for inference algorithms that operate on a FactorGraph typedef DAIAlg DAIAlgFG; /// Base class for inference algorithms that operate on a RegionGraph typedef DAIAlg DAIAlgRG; /// Calculates the marginal probability distribution for \a vs using inference algorithm \a obj. /** calcMarginal() works by clamping all variables in \a vs and calculating the partition sum for each clamped state. * Therefore, it can be used in combination with any inference algorithm that can calculate/approximate partition sums. * \param obj instance of inference algorithm to be used * \param vs variables for which the marginal should be calculated * \param reInit should be set to \c true if at least one of the possible clamped states would be invalid (leading to a factor graph with zero partition sum). */ Factor calcMarginal( const InfAlg& obj, const VarSet& vs, bool reInit ); /// Calculates beliefs for all pairs of variables in \a vs using inference algorithm \a obj. /** calcPairBeliefs() works by * - clamping single variables in \a vs and calculating the partition sum and the single variable beliefs for each clamped state, if \a accurate == \c false; * - clamping pairs of variables in \a vs and calculating the partition sum for each clamped state, if \a accurate == \c true. * * Therefore, it can be used in combination with any inference algorithm that can calculate/approximate partition sums (and single variable beliefs, if * \a accurate == \c true). * \param obj instance of inference algorithm to be used * \param vs variables for which the pair beliefs should be calculated * \param reInit should be set to \c true if at least one of the possible clamped states would be invalid (leading to a factor graph with zero partition sum). * \param accurate if \c true, uses a slower but more accurate approximation algorithm */ std::vector calcPairBeliefs( const InfAlg& obj, const VarSet& vs, bool reInit, bool accurate=false ); } // end of namespace dai #endif libDAI-0.2.4/include/dai/factor.h0000644000263000017630000006017111334764774015311 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2002 Martijn Leisink [martijn@mbfys.kun.nl] * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2002-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines TFactor<> and Factor classes which represent factors in probability distributions. #ifndef __defined_libdai_factor_h #define __defined_libdai_factor_h #include #include #include #include #include #include #include namespace dai { /// Represents a (probability) factor. /** Mathematically, a \e factor is a function mapping joint states of some * variables to the nonnegative real numbers. * More formally, denoting a discrete variable with label \f$l\f$ by * \f$x_l\f$ and its state space by \f$X_l = \{0,1,\dots,S_l-1\}\f$, * a factor depending on the variables \f$\{x_l\}_{l\in L}\f$ is * a function \f$f_L : \prod_{l\in L} X_l \to [0,\infty)\f$. * * In libDAI, a factor is represented by a TFactor object, which has two * components: * \arg a VarSet, corresponding with the set of variables \f$\{x_l\}_{l\in L}\f$ * that the factor depends on; * \arg a TProb, a vector containing the value of the factor for each possible * joint state of the variables. * * The factor values are stored in the entries of the TProb in a particular * ordering, which is defined by the one-to-one correspondence of a joint state * in \f$\prod_{l\in L} X_l\f$ with a linear index in * \f$\{0,1,\dots,\prod_{l\in L} S_l-1\}\f$ according to the mapping \f$\sigma\f$ * induced by dai::calcLinearState(). * * \tparam T Should be a scalar that is castable from and to double and should support elementary arithmetic operations. * \todo Define a better fileformat for .fg files (maybe using XML)? * \todo Add support for sparse factors. */ template class TFactor { private: /// Stores the variables on which the factor depends VarSet _vs; /// Stores the factor values TProb _p; public: /// \name Constructors and destructors //@{ /// Constructs factor depending on no variables with value \a p TFactor ( T p = 1 ) : _vs(), _p(1,p) {} /// Constructs factor depending on the variable \a v with uniform distribution TFactor( const Var &v ) : _vs(v), _p(v.states()) {} /// Constructs factor depending on variables in \a vars with uniform distribution TFactor( const VarSet& vars ) : _vs(vars), _p(_vs.nrStates()) {} /// Constructs factor depending on variables in \a vars with all values set to \a p TFactor( const VarSet& vars, T p ) : _vs(vars), _p(_vs.nrStates(),p) {} /// Constructs factor depending on variables in \a vars, copying the values from a std::vector<> /** \tparam S Type of values of \a x * \param vars contains the variables that the new factor should depend on. * \param x Vector with values to be copied. */ template TFactor( const VarSet& vars, const std::vector &x ) : _vs(vars), _p(x.begin(), x.begin() + _vs.nrStates(), _vs.nrStates()) { DAI_ASSERT( x.size() == vars.nrStates() ); } /// Constructs factor depending on variables in \a vars, copying the values from an array /** \param vars contains the variables that the new factor should depend on. * \param p Points to array of values to be added. */ TFactor( const VarSet& vars, const T* p ) : _vs(vars), _p(p, p + _vs.nrStates(), _vs.nrStates()) {} /// Constructs factor depending on variables in \a vars, copying the values from \a p TFactor( const VarSet& vars, const TProb &p ) : _vs(vars), _p(p) { DAI_DEBASSERT( _vs.nrStates() == _p.size() ); } /// Constructs factor depending on variables in \a vars, permuting the values given in \a p accordingly TFactor( const std::vector &vars, const std::vector &p ) : _vs(vars.begin(), vars.end(), vars.size()), _p(p.size()) { Permute permindex(vars); for( size_t li = 0; li < p.size(); ++li ) _p[permindex.convertLinearIndex(li)] = p[li]; } //@} /// \name Queries //@{ /// Returns constant reference to value vector const TProb& p() const { return _p; } /// Returns reference to value vector TProb& p() { return _p; } /// Returns a copy of the \a i 'th entry of the value vector T operator[] (size_t i) const { return _p[i]; } /// Returns a reference to the \a i 'th entry of the value vector T& operator[] (size_t i) { return _p[i]; } /// Returns constant reference to variable set (i.e., the variables on which the factor depends) const VarSet& vars() const { return _vs; } /// Returns reference to variable set (i.e., the variables on which the factor depends) VarSet& vars() { return _vs; } /// Returns the number of possible joint states of the variables on which the factor depends, \f$\prod_{l\in L} S_l\f$ /** \note This is equal to the length of the value vector. */ size_t states() const { return _p.size(); } /// Returns the Shannon entropy of \c *this, \f$-\sum_i p_i \log p_i\f$ T entropy() const { return _p.entropy(); } /// Returns maximum of all values T max() const { return _p.max(); } /// Returns minimum of all values T min() const { return _p.min(); } /// Returns sum of all values T sum() const { return _p.sum(); } /// Returns maximum absolute value of all values T maxAbs() const { return _p.maxAbs(); } /// Returns \c true if one or more values are NaN bool hasNaNs() const { return _p.hasNaNs(); } /// Returns \c true if one or more values are negative bool hasNegatives() const { return _p.hasNegatives(); } /// Returns strength of this factor (between variables \a i and \a j), as defined in eq. (52) of [\ref MoK07b] T strength( const Var &i, const Var &j ) const; //@} /// \name Unary transformations //@{ /// Returns pointwise absolute value TFactor abs() const { // Note: the alternative (shorter) way of implementing this, // return TFactor( _vs, _p.abs() ); // is slower because it invokes the copy constructor of TProb TFactor x; x._vs = _vs; x._p = _p.abs(); return x; } /// Returns pointwise exponent TFactor exp() const { TFactor x; x._vs = _vs; x._p = _p.exp(); return x; } /// Returns pointwise logarithm /** If \a zero == \c true, uses log(0)==0; otherwise, log(0)==-Inf. */ TFactor log(bool zero=false) const { TFactor x; x._vs = _vs; x._p = _p.log(zero); return x; } /// Returns pointwise inverse /** If \a zero == \c true, uses 1/0==0; otherwise, 1/0==Inf. */ TFactor inverse(bool zero=true) const { TFactor x; x._vs = _vs; x._p = _p.inverse(zero); return x; } /// Returns normalized copy of \c *this, using the specified norm /** \throw NOT_NORMALIZABLE if the norm is zero */ TFactor normalized( typename TProb::NormType norm=TProb::NORMPROB ) const { TFactor x; x._vs = _vs; x._p = _p.normalized( norm ); return x; } //@} /// \name Unary operations //@{ /// Draws all values i.i.d. from a uniform distribution on [0,1) TFactor & randomize () { _p.randomize(); return *this; } /// Sets all values to \f$1/n\f$ where \a n is the number of states TFactor& setUniform () { _p.setUniform(); return *this; } /// Normalizes factor using the specified norm /** \throw NOT_NORMALIZABLE if the norm is zero */ T normalize( typename TProb::NormType norm=TProb::NORMPROB ) { return _p.normalize( norm ); } //@} /// \name Operations with scalars //@{ /// Sets all values to \a x TFactor & fill (T x) { _p.fill( x ); return *this; } /// Adds scalar \a x to each value TFactor& operator+= (T x) { _p += x; return *this; } /// Subtracts scalar \a x from each value TFactor& operator-= (T x) { _p -= x; return *this; } /// Multiplies each value with scalar \a x TFactor& operator*= (T x) { _p *= x; return *this; } /// Divides each entry by scalar \a x TFactor& operator/= (T x) { _p /= x; return *this; } /// Raises values to the power \a x TFactor& operator^= (T x) { _p ^= x; return *this; } //@} /// \name Transformations with scalars //@{ /// Returns sum of \c *this and scalar \a x TFactor operator+ (T x) const { // Note: the alternative (shorter) way of implementing this, // TFactor result(*this); // result._p += x; // is slower because it invokes the copy constructor of TFactor TFactor result; result._vs = _vs; result._p = p() + x; return result; } /// Returns difference of \c *this and scalar \a x TFactor operator- (T x) const { TFactor result; result._vs = _vs; result._p = p() - x; return result; } /// Returns product of \c *this with scalar \a x TFactor operator* (T x) const { TFactor result; result._vs = _vs; result._p = p() * x; return result; } /// Returns quotient of \c *this with scalar \a x TFactor operator/ (T x) const { TFactor result; result._vs = _vs; result._p = p() / x; return result; } /// Returns \c *this raised to the power \a x TFactor operator^ (T x) const { TFactor result; result._vs = _vs; result._p = p() ^ x; return result; } //@} /// \name Operations with other factors //@{ /// Applies binary operation \a op on two factors, \c *this and \a g /** \tparam binOp Type of function object that accepts two arguments of type \a T and outputs a type \a T * \param g Right operand * \param op Operation of type \a binOp */ template TFactor& binaryOp( const TFactor &g, binOp op ) { if( _vs == g._vs ) // optimize special case _p.pwBinaryOp( g._p, op ); else { TFactor f(*this); // make a copy _vs |= g._vs; size_t N = _vs.nrStates(); IndexFor i_f( f._vs, _vs ); IndexFor i_g( g._vs, _vs ); _p.p().clear(); _p.p().reserve( N ); for( size_t i = 0; i < N; i++, ++i_f, ++i_g ) _p.p().push_back( op( f._p[i_f], g._p[i_g] ) ); } return *this; } /// Adds \a g to \c *this /** The sum of two factors is defined as follows: if * \f$f : \prod_{l\in L} X_l \to [0,\infty)\f$ and \f$g : \prod_{m\in M} X_m \to [0,\infty)\f$, then * \f[f+g : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) + g(x_M).\f] */ TFactor& operator+= (const TFactor& g) { return binaryOp( g, std::plus() ); } /// Subtracts \a g from \c *this /** The difference of two factors is defined as follows: if * \f$f : \prod_{l\in L} X_l \to [0,\infty)\f$ and \f$g : \prod_{m\in M} X_m \to [0,\infty)\f$, then * \f[f-g : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) - g(x_M).\f] */ TFactor& operator-= (const TFactor& g) { return binaryOp( g, std::minus() ); } /// Multiplies \c *this with \a g /** The product of two factors is defined as follows: if * \f$f : \prod_{l\in L} X_l \to [0,\infty)\f$ and \f$g : \prod_{m\in M} X_m \to [0,\infty)\f$, then * \f[fg : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) g(x_M).\f] */ TFactor& operator*= (const TFactor& g) { return binaryOp( g, std::multiplies() ); } /// Divides \c *this by \a g (where division by zero yields zero) /** The quotient of two factors is defined as follows: if * \f$f : \prod_{l\in L} X_l \to [0,\infty)\f$ and \f$g : \prod_{m\in M} X_m \to [0,\infty)\f$, then * \f[\frac{f}{g} : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto \frac{f(x_L)}{g(x_M)}.\f] */ TFactor& operator/= (const TFactor& g) { return binaryOp( g, fo_divides0() ); } //@} /// \name Transformations with other factors //@{ /// Returns result of applying binary operation \a op on two factors, \c *this and \a g /** \tparam binOp Type of function object that accepts two arguments of type \a T and outputs a type \a T * \param g Right operand * \param op Operation of type \a binOp */ template TFactor binaryTr( const TFactor &g, binOp op ) const { // Note that to prevent a copy to be made, it is crucial // that the result is declared outside the if-else construct. TFactor result; if( _vs == g._vs ) { // optimize special case result._vs = _vs; result._p = _p.pwBinaryTr( g._p, op ); } else { result._vs = _vs | g._vs; size_t N = result._vs.nrStates(); IndexFor i_f( _vs, result.vars() ); IndexFor i_g( g._vs, result.vars() ); result._p.p().clear(); result._p.p().reserve( N ); for( size_t i = 0; i < N; i++, ++i_f, ++i_g ) result._p.p().push_back( op( _p[i_f], g._p[i_g] ) ); } return result; } /// Returns sum of \c *this and \a g /** The sum of two factors is defined as follows: if * \f$f : \prod_{l\in L} X_l \to [0,\infty)\f$ and \f$g : \prod_{m\in M} X_m \to [0,\infty)\f$, then * \f[f+g : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) + g(x_M).\f] */ TFactor operator+ (const TFactor& g) const { return binaryTr(g,std::plus()); } /// Returns \c *this minus \a g /** The difference of two factors is defined as follows: if * \f$f : \prod_{l\in L} X_l \to [0,\infty)\f$ and \f$g : \prod_{m\in M} X_m \to [0,\infty)\f$, then * \f[f-g : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) - g(x_M).\f] */ TFactor operator- (const TFactor& g) const { return binaryTr(g,std::minus()); } /// Returns product of \c *this with \a g /** The product of two factors is defined as follows: if * \f$f : \prod_{l\in L} X_l \to [0,\infty)\f$ and \f$g : \prod_{m\in M} X_m \to [0,\infty)\f$, then * \f[fg : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) g(x_M).\f] */ TFactor operator* (const TFactor& g) const { return binaryTr(g,std::multiplies()); } /// Returns quotient of \c *this by \a f (where division by zero yields zero) /** The quotient of two factors is defined as follows: if * \f$f : \prod_{l\in L} X_l \to [0,\infty)\f$ and \f$g : \prod_{m\in M} X_m \to [0,\infty)\f$, then * \f[\frac{f}{g} : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto \frac{f(x_L)}{g(x_M)}.\f] */ TFactor operator/ (const TFactor& g) const { return binaryTr(g,fo_divides0()); } //@} /// \name Miscellaneous operations //@{ /// Returns a slice of \c *this, where the subset \a vars is in state \a varsState /** \pre \a vars sould be a subset of vars() * \pre \a varsState < vars.states() * * The result is a factor that depends on the variables of *this except those in \a vars, * obtained by setting the variables in \a vars to the joint state specified by the linear index * \a varsState. Formally, if \c *this corresponds with the factor \f$f : \prod_{l\in L} X_l \to [0,\infty)\f$, * \f$M \subset L\f$ corresponds with \a vars and \a varsState corresponds with a mapping \f$s\f$ that * maps a variable \f$x_m\f$ with \f$m\in M\f$ to its state \f$s(x_m) \in X_m\f$, then the slice * returned corresponds with the factor \f$g : \prod_{l \in L \setminus M} X_l \to [0,\infty)\f$ * defined by \f$g(\{x_l\}_{l\in L \setminus M}) = f(\{x_l\}_{l\in L \setminus M}, \{s(x_m)\}_{m\in M})\f$. */ TFactor slice( const VarSet& vars, size_t varsState ) const; /// Embeds this factor in a larger VarSet /** \pre vars() should be a subset of \a vars * * If *this corresponds with \f$f : \prod_{l\in L} X_l \to [0,\infty)\f$ and \f$L \subset M\f$, then * the embedded factor corresponds with \f$g : \prod_{m\in M} X_m \to [0,\infty) : x \mapsto f(x_L)\f$. */ TFactor embed(const VarSet & vars) const { DAI_ASSERT( vars >> _vs ); if( _vs == vars ) return *this; else return (*this) * TFactor(vars / _vs, (T)1); } /// Returns marginal on \a vars, obtained by summing out all variables except those in \a vars, and normalizing the result if \a normed == \c true TFactor marginal(const VarSet &vars, bool normed=true) const; /// Returns max-marginal on \a vars, obtained by maximizing all variables except those in \a vars, and normalizing the result if \a normed == \c true TFactor maxMarginal(const VarSet &vars, bool normed=true) const; //@} }; template TFactor TFactor::slice( const VarSet& vars, size_t varsState ) const { DAI_ASSERT( vars << _vs ); VarSet varsrem = _vs / vars; TFactor result( varsrem, T(0) ); // OPTIMIZE ME IndexFor i_vars (vars, _vs); IndexFor i_varsrem (varsrem, _vs); for( size_t i = 0; i < states(); i++, ++i_vars, ++i_varsrem ) if( (size_t)i_vars == varsState ) result._p[i_varsrem] = _p[i]; return result; } template TFactor TFactor::marginal(const VarSet &vars, bool normed) const { VarSet res_vars = vars & _vs; TFactor res( res_vars, 0.0 ); IndexFor i_res( res_vars, _vs ); for( size_t i = 0; i < _p.size(); i++, ++i_res ) res._p[i_res] += _p[i]; if( normed ) res.normalize( TProb::NORMPROB ); return res; } template TFactor TFactor::maxMarginal(const VarSet &vars, bool normed) const { VarSet res_vars = vars & _vs; TFactor res( res_vars, 0.0 ); IndexFor i_res( res_vars, _vs ); for( size_t i = 0; i < _p.size(); i++, ++i_res ) if( _p[i] > res._p[i_res] ) res._p[i_res] = _p[i]; if( normed ) res.normalize( TProb::NORMPROB ); return res; } template T TFactor::strength( const Var &i, const Var &j ) const { DAI_DEBASSERT( _vs.contains( i ) ); DAI_DEBASSERT( _vs.contains( j ) ); DAI_DEBASSERT( i != j ); VarSet ij(i, j); T max = 0.0; for( size_t alpha1 = 0; alpha1 < i.states(); alpha1++ ) for( size_t alpha2 = 0; alpha2 < i.states(); alpha2++ ) if( alpha2 != alpha1 ) for( size_t beta1 = 0; beta1 < j.states(); beta1++ ) for( size_t beta2 = 0; beta2 < j.states(); beta2++ ) if( beta2 != beta1 ) { size_t as = 1, bs = 1; if( i < j ) bs = i.states(); else as = j.states(); T f1 = slice( ij, alpha1 * as + beta1 * bs ).p().divide( slice( ij, alpha2 * as + beta1 * bs ).p() ).max(); T f2 = slice( ij, alpha2 * as + beta2 * bs ).p().divide( slice( ij, alpha1 * as + beta2 * bs ).p() ).max(); T f = f1 * f2; if( f > max ) max = f; } return std::tanh( 0.25 * std::log( max ) ); } /// Writes a factor to an output stream /** \relates TFactor */ template std::ostream& operator<< (std::ostream& os, const TFactor& f) { os << "(" << f.vars() << ", ("; for( size_t i = 0; i < f.states(); i++ ) os << (i == 0 ? "" : ", ") << f[i]; os << "))"; return os; } /// Returns distance between two factors \a f and \a g, according to the distance measure \a dt /** \relates TFactor * \pre f.vars() == g.vars() */ template T dist( const TFactor &f, const TFactor &g, typename TProb::DistType dt ) { if( f.vars().empty() || g.vars().empty() ) return -1; else { DAI_DEBASSERT( f.vars() == g.vars() ); return dist( f.p(), g.p(), dt ); } } /// Returns the pointwise maximum of two factors /** \relates TFactor * \pre f.vars() == g.vars() */ template TFactor max( const TFactor &f, const TFactor &g ) { DAI_ASSERT( f._vs == g._vs ); return TFactor( f._vs, max( f.p(), g.p() ) ); } /// Returns the pointwise minimum of two factors /** \relates TFactor * \pre f.vars() == g.vars() */ template TFactor min( const TFactor &f, const TFactor &g ) { DAI_ASSERT( f._vs == g._vs ); return TFactor( f._vs, min( f.p(), g.p() ) ); } /// Calculates the mutual information between the two variables that \a f depends on, under the distribution given by \a f /** \relates TFactor * \pre f.vars().size() == 2 */ template T MutualInfo(const TFactor &f) { DAI_ASSERT( f.vars().size() == 2 ); VarSet::const_iterator it = f.vars().begin(); Var i = *it; it++; Var j = *it; TFactor projection = f.marginal(i) * f.marginal(j); return dist( f.normalized(), projection, TProb::DISTKL ); } /// Represents a factor with values of type dai::Real. typedef TFactor Factor; /// Returns a binary single-variable factor \f$ \exp(hx) \f$ where \f$ x = \pm 1 \f$ /** \param x Variable (should be binary) * \param h Field strength */ Factor createFactorIsing( const Var &x, Real h ); /// Returns a binary pairwise factor \f$ \exp(J x_1 x_2) \f$ where \f$ x_1, x_2 = \pm 1 \f$ /** \param x1 First variable (should be binary) * \param x2 Second variable (should be binary) * \param J Coupling strength */ Factor createFactorIsing( const Var &x1, const Var &x2, Real J ); /// Returns a random factor on the variables \a vs with strength \a beta /** Each entry are set by drawing a normally distributed random with mean * 0 and standard-deviation \a beta, and taking its exponent. * \param vs Variables * \param beta Factor strength (inverse temperature) */ Factor createFactorExpGauss( const VarSet &vs, Real beta ); /// Returns a pairwise Potts factor \f$ \exp( J \delta_{x_1, x_2} ) \f$ /** \param x1 First variable * \param x2 Second variable (should have the same number of states as \a x1) * \param J Factor strength */ Factor createFactorPotts( const Var &x1, const Var &x2, Real J ); /// Returns a Kronecker delta point mass /** \param v Variable * \param state The state of \a v that should get value 1 */ Factor createFactorDelta( const Var &v, size_t state ); } // end of namespace dai #endif libDAI-0.2.4/include/dai/cbp.h0000644000263000017630000002505011334764775014575 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Frederik Eaton [frederik at ofb dot net] */ /// \file /// \brief Defines class CBP, which implements Conditioned Belief Propagation #ifndef __defined_libdai_cbp_h #define __defined_libdai_cbp_h #include #include #include #include namespace dai { /// Class for CBP (Conditioned Belief Propagation) [\ref EaG09] /** This approximate inference algorithm uses configurable heuristics to choose a variable * \f$ x_i \f$ and a state \f$ x_i^* \f$. Inference is done with \f$ x_i \f$ "clamped" to \f$ x_i^* \f$ * (i.e., conditional on \f$ x_i = x_i^* \f$), and also with the negation of this condition. * Clamping is done recursively up to a fixed number of levels (other stopping criteria are * also implemented, see the CBP::Properties::RecurseType property). The resulting approximate * marginals are combined using estimates of the partition sum. * * \author Frederik Eaton */ class CBP : public DAIAlgFG { private: /// Variable beliefs std::vector _beliefsV; /// Factor beliefs std::vector _beliefsF; /// Logarithm of partition sum Real _logZ; /// Numer of iterations needed size_t _iters; /// Maximum difference encountered so far Real _maxdiff; /// Number of clampings at each leaf node Real _sum_level; /// Number of leaves of recursion tree size_t _num_leaves; /// Output stream where information about the clampings is written boost::shared_ptr _clamp_ofstream; public: /// Construct CBP object from FactorGraph \a fg and PropertySet \a opts /** \param opts Parameters @see Properties */ CBP( const FactorGraph &fg, const PropertySet &opts ) : DAIAlgFG(fg) { props.set( opts ); construct(); } /// Name of this inference algorithm static const char *Name; /// \name General InfAlg interface //@{ virtual CBP* clone() const { return new CBP(*this); } virtual std::string identify() const { return std::string(Name) + props.toString(); } virtual Factor belief( const Var &v ) const { return beliefV( findVar( v ) ); } virtual Factor belief( const VarSet & ) const { DAI_THROW(NOT_IMPLEMENTED); } virtual Factor beliefV( size_t i ) const { return _beliefsV[i]; } virtual Factor beliefF( size_t I ) const { return _beliefsF[I]; } virtual std::vector beliefs() const { return concat(_beliefsV, _beliefsF); } virtual Real logZ() const { return _logZ; } virtual void init() {}; virtual void init( const VarSet & ) {}; virtual Real run(); virtual Real maxDiff() const { return _maxdiff; } virtual size_t Iterations() const { return _iters; } virtual void setProperties( const PropertySet &opts ) { props.set( opts ); } virtual PropertySet getProperties() const { return props.get(); } virtual std::string printProperties() const { return props.toString(); } //@} //---------------------------------------------------------------- /// Parameters for CBP /* PROPERTIES(props,CBP) { /// Enumeration of possible update schedules typedef BP::Properties::UpdateType UpdateType; /// Enumeration of possible methods for deciding when to stop recursing DAI_ENUM(RecurseType,REC_FIXED,REC_LOGZ,REC_BDIFF); /// Enumeration of possible heuristics for choosing clamping variable DAI_ENUM(ChooseMethodType,CHOOSE_RANDOM,CHOOSE_MAXENT,CHOOSE_BBP,CHOOSE_BP_L1,CHOOSE_BP_CFN); /// Enumeration of possible clampings: variables or factors DAI_ENUM(ClampType,CLAMP_VAR,CLAMP_FACTOR); /// Verbosity (amount of output sent to stderr) size_t verbose = 0; /// Tolerance for BP convergence test Real tol; /// Update style for BP UpdateType updates; /// Maximum number of iterations for BP size_t maxiter; /// Tolerance used for controlling recursion depth (\a recurse is REC_LOGZ or REC_BDIFF) Real rec_tol; /// Maximum number of levels of recursion (\a recurse is REC_FIXED) size_t max_levels = 10; /// If choose==CHOOSE_BBP and maximum adjoint is less than this value, don't recurse Real min_max_adj; /// Heuristic for choosing clamping variable ChooseMethodType choose; /// Method for deciding when to stop recursing RecurseType recursion; /// Whether to clamp variables or factors ClampType clamp; /// Properties to pass to BBP PropertySet bbp_props; /// Cost function to use for BBP BBPCostFunction bbp_cfn; /// Random seed size_t rand_seed = 0; /// If non-empty, write clamping choices to this file std::string clamp_outfile = ""; } */ /* {{{ GENERATED CODE: DO NOT EDIT. Created by ./scripts/regenerate-properties include/dai/cbp.h src/cbp.cpp */ struct Properties { /// Enumeration of possible update schedules typedef BP::Properties::UpdateType UpdateType; /// Enumeration of possible methods for deciding when to stop recursing DAI_ENUM(RecurseType,REC_FIXED,REC_LOGZ,REC_BDIFF); /// Enumeration of possible heuristics for choosing clamping variable DAI_ENUM(ChooseMethodType,CHOOSE_RANDOM,CHOOSE_MAXENT,CHOOSE_BBP,CHOOSE_BP_L1,CHOOSE_BP_CFN); /// Enumeration of possible clampings: variables or factors DAI_ENUM(ClampType,CLAMP_VAR,CLAMP_FACTOR); /// Verbosity (amount of output sent to stderr) size_t verbose; /// Tolerance for BP convergence test Real tol; /// Update style for BP UpdateType updates; /// Maximum number of iterations for BP size_t maxiter; /// Tolerance used for controlling recursion depth (\a recurse is REC_LOGZ or REC_BDIFF) Real rec_tol; /// Maximum number of levels of recursion (\a recurse is REC_FIXED) size_t max_levels; /// If choose==CHOOSE_BBP and maximum adjoint is less than this value, don't recurse Real min_max_adj; /// Heuristic for choosing clamping variable ChooseMethodType choose; /// Method for deciding when to stop recursing RecurseType recursion; /// Whether to clamp variables or factors ClampType clamp; /// Properties to pass to BBP PropertySet bbp_props; /// Cost function to use for BBP BBPCostFunction bbp_cfn; /// Random seed size_t rand_seed; /// If non-empty, write clamping choices to this file std::string clamp_outfile; /// Set members from PropertySet /** \throw UNKNOWN_PROPERTY if a Property key is not recognized * \throw NOT_ALL_PROPERTIES_SPECIFIED if an expected Property is missing */ void set(const PropertySet &opts); /// Get members into PropertySet PropertySet get() const; /// Convert to a string which can be parsed as a PropertySet std::string toString() const; } props; /* }}} END OF GENERATED CODE */ private: /// Prints beliefs, variables and partition sum, in case of a debugging build void printDebugInfo(); /// Called by run(), and by itself. Implements the main algorithm. /** Chooses a variable to clamp, recurses, combines the partition sum * and belief estimates of the children, and returns the improved * estimates in \a lz_out and \a beliefs_out to its parent. */ void runRecurse( InfAlg *bp, Real orig_logZ, std::vector clamped_vars_list, size_t &num_leaves, size_t &choose_count, Real &sum_level, Real &lz_out, std::vector &beliefs_out ); /// Choose the next variable to clamp. /** Choose the next variable to clamp, given a converged InfAlg \a bp, * and a vector of variables that are already clamped (\a * clamped_vars_list). Returns the chosen variable in \a i, and * the set of states in \a xis. If \a maxVarOut is non-NULL and * \a props.choose == \c CHOOSE_BBP then it is used to store the * adjoint of the chosen variable. */ virtual bool chooseNextClampVar( InfAlg* bp, std::vector &clamped_vars_list, size_t &i, std::vector &xis, Real *maxVarOut ); /// Return the InfAlg to use at each step of the recursion. /** \todo At present, CBP::getInfAlg() only returns a BP instance; * it should be possible to select other inference algorithms via a property */ InfAlg* getInfAlg(); /// Sets variable beliefs, factor beliefs and log partition sum to the specified values /** \param bs should be a concatenation of the variable beliefs followed by the factor beliefs * \param logZ log partition sum */ void setBeliefs( const std::vector &bs, Real logZ ); /// Constructor helper function void construct(); }; /// Find the best variable/factor to clamp using BBP. /** Takes a converged inference algorithm as input, runs Gibbs and BP_dual, creates * and runs a BBP object, finds the best variable/factor (the one with the maximum * factor adjoint), and returns the corresponding (index,state) pair. * \param in_bp inference algorithm (compatible with BP) that should have converged; * \param clampingVar if \c true, finds best variable, otherwise, finds best factor; * \param bbp_props BBP parameters to use; * \param cfn BBP cost function to use; * \param maxVarOut maximum adjoint value (only set if not NULL). * \see BBP * \relates CBP */ std::pair BBPFindClampVar( const InfAlg &in_bp, bool clampingVar, const PropertySet &bbp_props, const BBPCostFunction &cfn, Real *maxVarOut ); } // end of namespace dai #endif libDAI-0.2.4/include/dai/index.h0000644000263000017630000003760211334764775015146 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2002 Martijn Leisink [martijn@mbfys.kun.nl] * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2002-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines the IndexFor, multifor, Permute and State classes, which all deal with indexing multi-dimensional arrays #ifndef __defined_libdai_index_h #define __defined_libdai_index_h #include #include #include #include namespace dai { /// Tool for looping over the states of several variables. /** The class IndexFor is an important tool for indexing Factor entries. * Its usage can best be explained by an example. * Assume \a indexVars, \a forVars are both VarSet 's. * Then the following code: * \code * IndexFor i( indexVars, forVars ); * size_t iter = 0; * for( ; i.valid(); i++, iter++ ) { * cout << "State of forVars: " << calcState( forVars, iter ) << "; "; * cout << "state of indexVars: " << calcState( indexVars, long(i) ) << endl; * } * \endcode * loops over all joint states of the variables in \a forVars, * and (long)i equals the linear index of the corresponding * state of \a indexVars, where the variables in \a indexVars that are * not in \a forVars assume their zero'th value. * \idea Optimize all indices as follows: keep a cache of all (or only * relatively small) indices that have been computed (use a hash). Then, * instead of computing on the fly, use the precomputed ones. Here the * labels of the variables don't matter, but the ranges of the variables do. */ class IndexFor { private: /// The current linear index corresponding to the state of indexVars long _index; /// For each variable in forVars, the amount of change in _index std::vector _sum; /// For each variable in forVars, the current state std::vector _state; /// For each variable in forVars, its number of possible values std::vector _ranges; public: /// Default constructor IndexFor() : _index(-1) {} /// Construct IndexFor object from \a indexVars and \a forVars IndexFor( const VarSet& indexVars, const VarSet& forVars ) : _state( forVars.size(), 0 ) { long sum = 1; _ranges.reserve( forVars.size() ); _sum.reserve( forVars.size() ); VarSet::const_iterator j = forVars.begin(); for( VarSet::const_iterator i = indexVars.begin(); i != indexVars.end(); ++i ) { for( ; j != forVars.end() && *j <= *i; ++j ) { _ranges.push_back( j->states() ); _sum.push_back( (*i == *j) ? sum : 0 ); } sum *= i->states(); } for( ; j != forVars.end(); ++j ) { _ranges.push_back( j->states() ); _sum.push_back( 0 ); } _index = 0; } /// Resets the state IndexFor& reset() { fill( _state.begin(), _state.end(), 0 ); _index = 0; return( *this ); } /// Conversion to \c size_t: returns linear index of the current state of indexVars operator size_t() const { DAI_ASSERT( valid() ); return( _index ); } /// Increments the current state of \a forVars (prefix) IndexFor& operator++ () { if( _index >= 0 ) { size_t i = 0; while( i < _state.size() ) { _index += _sum[i]; if( ++_state[i] < _ranges[i] ) break; _index -= _sum[i] * _ranges[i]; _state[i] = 0; i++; } if( i == _state.size() ) _index = -1; } return( *this ); } /// Increments the current state of \a forVars (postfix) void operator++( int ) { operator++(); } /// Returns \c true if the current state is valid bool valid() const { return( _index >= 0 ); } }; /// Tool for calculating permutations of linear indices of multi-dimensional arrays. /** \note This is mainly useful for converting indices into multi-dimensional arrays * corresponding to joint states of variables to and from the canonical ordering used in libDAI. */ class Permute { private: /// Stores the number of possible values of all indices std::vector _ranges; /// Stores the permutation std::vector _sigma; public: /// Default constructor Permute() : _ranges(), _sigma() {} /// Construct from vector of index ranges and permutation Permute( const std::vector &rs, const std::vector &sigma ) : _ranges(rs), _sigma(sigma) { DAI_ASSERT( _ranges.size() == _sigma.size() ); } /// Construct from vector of variables. /** The implied permutation maps the index of each variable in \a vars according to the canonical ordering * (i.e., sorted ascendingly according to their label) to the index it has in \a vars. */ Permute( const std::vector &vars ) : _ranges(vars.size()), _sigma(vars.size()) { for( size_t i = 0; i < vars.size(); ++i ) _ranges[i] = vars[i].states(); VarSet vs( vars.begin(), vars.end(), vars.size() ); VarSet::const_iterator vs_i = vs.begin(); for( size_t i = 0; i < vs.size(); ++i, ++vs_i ) _sigma[i] = find( vars.begin(), vars.end(), *vs_i ) - vars.begin(); } /// Calculates a permuted linear index. /** Converts the linear index \a li to a vector index, permutes its * components, and converts it back to a linear index. */ size_t convertLinearIndex( size_t li ) const { size_t N = _ranges.size(); // calculate vector index corresponding to linear index std::vector vi; vi.reserve( N ); size_t prod = 1; for( size_t k = 0; k < N; k++ ) { vi.push_back( li % _ranges[k] ); li /= _ranges[k]; prod *= _ranges[k]; } // convert permuted vector index to corresponding linear index prod = 1; size_t sigma_li = 0; for( size_t k = 0; k < N; k++ ) { sigma_li += vi[_sigma[k]] * prod; prod *= _ranges[_sigma[k]]; } return sigma_li; } /// Returns const reference to the permutation const std::vector& sigma() const { return _sigma; } /// Returns reference to the permutation std::vector& sigma() { return _sigma; } /// Returns the result of applying the permutation on \a i size_t operator[]( size_t i ) const { #ifdef DAI_DEBUG return _sigma.at(i); #else return _sigma[i]; #endif } }; /// multifor makes it easy to perform a dynamic number of nested \c for loops. /** An example of the usage is as follows: * \code * std::vector ranges; * ranges.push_back( 3 ); * ranges.push_back( 4 ); * ranges.push_back( 5 ); * for( multifor s(ranges); s.valid(); ++s ) * cout << "linear index: " << (size_t)s << " corresponds to indices " << s[2] << ", " << s[1] << ", " << s[0] << endl; * \endcode * which would be equivalent to: * \code * size_t s = 0; * for( size_t s2 = 0; s2 < 5; s2++ ) * for( size_t s1 = 0; s1 < 4; s1++ ) * for( size_t s0 = 0; s0 < 3; s++, s0++ ) * cout << "linear index: " << (size_t)s << " corresponds to indices " << s2 << ", " << s1 << ", " << s0 << endl; * \endcode */ class multifor { private: /// Stores the number of possible values of all indices std::vector _ranges; /// Stores the current values of all indices std::vector _indices; /// Stores the current linear index long _linear_index; public: /// Default constructor multifor() : _ranges(), _indices(), _linear_index(0) {} /// Initialize from vector of index ranges multifor( const std::vector &d ) : _ranges(d), _indices(d.size(),0), _linear_index(0) {} /// Returns linear index (i.e., the index in the Cartesian product space) operator size_t() const { DAI_DEBASSERT( valid() ); return( _linear_index ); } /// Returns \a k 'th index size_t operator[]( size_t k ) const { DAI_DEBASSERT( valid() ); DAI_DEBASSERT( k < _indices.size() ); return _indices[k]; } /// Increments the current indices (prefix) multifor & operator++() { if( valid() ) { _linear_index++; size_t i; for( i = 0; i != _indices.size(); i++ ) { if( ++(_indices[i]) < _ranges[i] ) break; _indices[i] = 0; } if( i == _indices.size() ) _linear_index = -1; } return *this; } /// Increments the current indices (postfix) void operator++( int ) { operator++(); } /// Returns \c true if the current indices are valid bool valid() const { return( _linear_index >= 0 ); } }; /// Makes it easy to iterate over all possible joint states of variables within a VarSet. /** A joint state of several variables can be represented in two different ways, by a map that maps each variable * to its own state, or by an integer that gives the index of the joint state in the canonical enumeration. * * Both representations are useful, and the main functionality provided by the State class is to simplify iterating * over the various joint states of a VarSet and to provide access to the current state in both representations. * * As an example, consider the following code snippet which iterates over all joint states of variables \a x0 and \a x1: * \code * VarSet vars( x0, x1 ); * for( State S(vars); S.valid(); S++ ) { * cout << "Linear state: " << S.get() << ", x0 = " << S(x0) << ", x1 = " << S(x1) << endl; * } * \endcode * * \note The same functionality could be achieved by simply iterating over the linear state and using dai::calcState(), * but the State class offers a more efficient implementation. * * \note A State is very similar to a \link multifor \endlink, but tailored for Var 's and VarSet 's. * * \see dai::calcLinearState(), dai::calcState() * * \idea Make the State class a more prominent part of libDAI * (and document it clearly, explaining the concept of state); * add more optimized variants of the State class like IndexFor * (e.g. for TFactor<>::slice()). */ class State { private: /// Type for representing a joint state of some variables as a map, which maps each variable to its state typedef std::map states_type; /// Current state (represented linearly) long state; /// Current state (represented as a map) states_type states; public: /// Default constructor State() : state(0), states() {} /// Construct from VarSet \a vs and corresponding linear state \a linearState State( const VarSet &vs, size_t linearState=0 ) : state(linearState), states() { if( linearState == 0 ) for( VarSet::const_iterator v = vs.begin(); v != vs.end(); v++ ) states[*v] = 0; else { for( VarSet::const_iterator v = vs.begin(); v != vs.end(); v++ ) { states[*v] = linearState % v->states(); linearState /= v->states(); } DAI_ASSERT( linearState == 0 ); } } /// Construct from a std::map State( const std::map &s ) : state(0), states() { insert( s.begin(), s.end() ); } /// Constant iterator over the values typedef states_type::const_iterator const_iterator; /// Returns constant iterator that points to the first item const_iterator begin() const { return states.begin(); } /// Returns constant iterator that points beyond the last item const_iterator end() const { return states.end(); } /// Return current linear state operator size_t() const { DAI_ASSERT( valid() ); return( state ); } /// Inserts a range of variable-state pairs, changing the current state template void insert( InputIterator b, InputIterator e ) { states.insert( b, e ); VarSet vars; for( const_iterator it = begin(); it != end(); it++ ) vars |= it->first; state = 0; state = this->operator()( vars ); } /// Return current state represented as a map const std::map& get() const { return states; } /// Cast into std::map operator const std::map& () const { return states; } /// Return current state of variable \a v, or 0 if \a v is not in \c *this size_t operator() ( const Var &v ) const { DAI_ASSERT( valid() ); states_type::const_iterator entry = states.find( v ); if( entry == states.end() ) return 0; else return entry->second; } /// Return linear state of variables in \a vs, assuming that variables that are not in \c *this are in state 0 size_t operator() ( const VarSet &vs ) const { DAI_ASSERT( valid() ); size_t vs_state = 0; size_t prod = 1; for( VarSet::const_iterator v = vs.begin(); v != vs.end(); v++ ) { states_type::const_iterator entry = states.find( *v ); if( entry != states.end() ) vs_state += entry->second * prod; prod *= v->states(); } return vs_state; } /// Increments the current state (prefix) void operator++( ) { if( valid() ) { state++; states_type::iterator entry = states.begin(); while( entry != states.end() ) { if( ++(entry->second) < entry->first.states() ) break; entry->second = 0; entry++; } if( entry == states.end() ) state = -1; } } /// Increments the current state (postfix) void operator++( int ) { operator++(); } /// Returns \c true if the current state is valid bool valid() const { return( state >= 0 ); } /// Resets the current state (to the joint state represented by linear state 0) void reset() { state = 0; for( states_type::iterator s = states.begin(); s != states.end(); s++ ) s->second = 0; } }; } // end of namespace dai /** \example example_permute.cpp * This example shows how to use the Permute, multifor and State classes. * * \section Output * \verbinclude examples/example_permute.out * * \section Source */ #endif libDAI-0.2.4/include/dai/bipgraph.h0000644000263000017630000004457211334764775015637 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines the BipartiteGraph class, which represents a bipartite graph #ifndef __defined_libdai_bipgraph_h #define __defined_libdai_bipgraph_h #include #include #include #include #include namespace dai { /// Represents the neighborhood structure of nodes in an undirected, bipartite graph. /** A bipartite graph has two types of nodes: type 1 and type 2. Edges can occur only between * nodes of different type. Nodes are indexed by an unsigned integer. If there are nrNodes1() * nodes of type 1 and nrNodes2() nodes of type 2, the nodes of type 1 are numbered * 0,1,2,...,nrNodes1()-1 and the nodes of type 2 are numbered 0,1,2,...,nrNodes2()-1. An edge * between node \a n1 of type 1 and node \a n2 of type 2 is represented by a BipartiteGraph::Edge(\a n1,\a n2). * * A BipartiteGraph is implemented as a sparse adjacency list, i.e., it stores for each node a list of * its neighboring nodes. More precisely: it stores for each node of type 1 a vector of Neighbor structures * (accessible by the nb1() method) describing the neighboring nodes of type 2; similarly, for each node * of type 2 it stores a vector of Neighbor structures (accessibly by the nb2() method) describing the * neighboring nodes of type 1. * Thus, each node has an associated variable of type BipartiteGraph::Neighbors, which is a vector of * Neighbor structures, describing its neighboring nodes of the other type. * \idea Cache second-order neighborhoods in BipartiteGraph. */ class BipartiteGraph { public: /// Describes the neighbor relationship of two nodes in a BipartiteGraph. /** Sometimes we want to do an action, such as sending a * message, for all edges in a graph. However, most graphs * will be sparse, so we need some way of storing a set of * the neighbors of a node, which is both fast and * memory-efficient. We also need to be able to go between * viewing node \a a as a neighbor of node \a b, and node \a b * as a neighbor of node \a a. The Neighbor struct solves * both of these problems. Each node has a list of neighbors, * stored as a std::vector<\link Neighbor \endlink>, and * extra information is included in the Neighbor struct which * allows us to access a node as a neighbor of its neighbor * (the \c dual member). * * By convention, variable identifiers naming indices into a * vector of neighbors are prefixed with an underscore ("_"). * The neighbor list which they point into is then understood * from context. For example: * * \code * void BP::calcNewMessage( size_t i, size_t _I ) * \endcode * * Here, \a i is the "absolute" index of node i, but \a _I is * understood as a "relative" index, giving node \a I 's entry in * nb1(i). The corresponding Neighbor structure can be * accessed as nb1(i,_I) or nb1(i)[_I]. The * absolute index of \a _I, which would be called \a I, can be * recovered from the \c node member: nb1(i,_I).node. * The \c iter member gives the relative index \a _I, and the * \c dual member gives the "dual" relative index, i.e., the * index of \a i in \a I 's neighbor list. * * \code * Neighbor n = nb1(i,_I); * n.node == I && * n.iter == _I && * nb2(n.node,n.dual).node == i * \endcode * * In a FactorGraph, the nodes of type 1 represent variables, and * the nodes of type 2 represent factors. For convenience, nb1() is * called FactorGraph::nbV(), and nb2() is called FactorGraph::nbF(). * * There is no easy way to transform a pair of absolute node * indices \a i and \a I into a Neighbor structure relative * to one of the nodes. Such a feature has never yet been * found to be necessary. Iteration over edges can always be * accomplished using the Neighbor lists, and by writing * functions that accept relative indices: * \code * for( size_t i = 0; i < nrVars(); ++i ) * foreach( const Neighbor &I, nbV(i) ) * calcNewMessage( i, I.iter ); * \endcode */ struct Neighbor { /// Corresponds to the index of this Neighbor entry in the vector of neighbors size_t iter; /// Contains the number of the neighboring node size_t node; /// Contains the "dual" iter size_t dual; /// Default constructor Neighbor() {} /// Constructor that sets the Neighbor members according to the parameters Neighbor( size_t iter, size_t node, size_t dual ) : iter(iter), node(node), dual(dual) {} /// Cast to \c size_t returns \c node member operator size_t () const { return node; } }; /// Describes the neighbors of some node. typedef std::vector Neighbors; /// Represents an edge: an Edge(\a n1,\a n2) corresponds to the edge between node \a n1 of type 1 and node \a n2 of type 2. typedef std::pair Edge; private: /// Contains for each node of type 1 a vector of its neighbors std::vector _nb1; /// Contains for each node of type 2 a vector of its neighbors std::vector _nb2; /// Used internally by isTree() struct levelType { /// Indices of nodes of type 1 std::vector ind1; /// Indices of nodes of type 2 std::vector ind2; }; public: /// \name Constructors and destructors //@{ /// Default constructor (creates an empty bipartite graph) BipartiteGraph() : _nb1(), _nb2() {} /// Constructs BipartiteGraph from a range of edges. /** \tparam EdgeInputIterator Iterator that iterates over instances of BipartiteGraph::Edge. * \param nrNodes1 The number of nodes of type 1. * \param nrNodes2 The number of nodes of type 2. * \param begin Points to the first edge. * \param end Points just beyond the last edge. */ template BipartiteGraph( size_t nrNodes1, size_t nrNodes2, EdgeInputIterator begin, EdgeInputIterator end ) : _nb1(), _nb2() { construct( nrNodes1, nrNodes2, begin, end ); } //@} /// \name Accessors and mutators //@{ /// Returns constant reference to the \a _i2 'th neighbor of node \a i1 of type 1 const Neighbor & nb1( size_t i1, size_t _i2 ) const { DAI_DEBASSERT( i1 < _nb1.size() ); DAI_DEBASSERT( _i2 < _nb1[i1].size() ); return _nb1[i1][_i2]; } /// Returns reference to the \a _i2 'th neighbor of node \a i1 of type 1 Neighbor & nb1( size_t i1, size_t _i2 ) { DAI_DEBASSERT( i1 < _nb1.size() ); DAI_DEBASSERT( _i2 < _nb1[i1].size() ); return _nb1[i1][_i2]; } /// Returns constant reference to the \a _i1 'th neighbor of node \a i2 of type 2 const Neighbor & nb2( size_t i2, size_t _i1 ) const { DAI_DEBASSERT( i2 < _nb2.size() ); DAI_DEBASSERT( _i1 < _nb2[i2].size() ); return _nb2[i2][_i1]; } /// Returns reference to the \a _i1 'th neighbor of node \a i2 of type 2 Neighbor & nb2( size_t i2, size_t _i1 ) { DAI_DEBASSERT( i2 < _nb2.size() ); DAI_DEBASSERT( _i1 < _nb2[i2].size() ); return _nb2[i2][_i1]; } /// Returns constant reference to all neighbors of node \a i1 of type 1 const Neighbors & nb1( size_t i1 ) const { DAI_DEBASSERT( i1 < _nb1.size() ); return _nb1[i1]; } /// Returns reference to all neighbors of node \a i1 of type 1 Neighbors & nb1( size_t i1 ) { DAI_DEBASSERT( i1 < _nb1.size() ); return _nb1[i1]; } /// Returns constant reference to all neighbors of node \a i2 of type 2 const Neighbors & nb2( size_t i2 ) const { DAI_DEBASSERT( i2 < _nb2.size() ); return _nb2[i2]; } /// Returns reference to all neighbors of node \a i2 of type 2 Neighbors & nb2( size_t i2 ) { DAI_DEBASSERT( i2 < _nb2.size() ); return _nb2[i2]; } //@} /// \name Adding nodes and edges //@{ /// (Re)constructs BipartiteGraph from a range of edges. /** \tparam EdgeInputIterator Iterator that iterates over instances of BipartiteGraph::Edge. * \param nrNodes1 The number of nodes of type 1. * \param nrNodes2 The number of nodes of type 2. * \param begin Points to the first edge. * \param end Points just beyond the last edge. */ template void construct( size_t nrNodes1, size_t nrNodes2, EdgeInputIterator begin, EdgeInputIterator end ); /// Adds a node of type 1 without neighbors and returns the index of the added node. size_t addNode1() { _nb1.push_back( Neighbors() ); return _nb1.size() - 1; } /// Adds a node of type 2 without neighbors and returns the index of the added node. size_t addNode2() { _nb2.push_back( Neighbors() ); return _nb2.size() - 1; } /// Adds a node of type 1 without neighbors and returns the index of the added node. /** \deprecated Please use dai::BipartiteGraph::addNode1() instead. */ size_t add1() { return addNode1(); } /// Adds a node of type 2 without neighbors and returns the index of the added node. /** \deprecated Please use dai::BipartiteGraph::addNode2() instead. */ size_t add2() { return addNode2(); } /// Adds a node of type 1, with neighbors specified by a range of nodes of type 2. /** \tparam NodeInputIterator Iterator that iterates over instances of \c size_t. * \param begin Points to the first index of the nodes of type 2 that should become neighbors of the added node. * \param end Points just beyond the last index of the nodes of type 2 that should become neighbors of the added node. * \param sizeHint For improved efficiency, the size of the range may be specified by \a sizeHint. * \returns Index of the added node. */ template size_t addNode1( NodeInputIterator begin, NodeInputIterator end, size_t sizeHint = 0 ) { Neighbors nbs1new; nbs1new.reserve( sizeHint ); size_t iter = 0; for( NodeInputIterator it = begin; it != end; ++it ) { DAI_ASSERT( *it < nrNodes2() ); Neighbor nb1new( iter, *it, nb2(*it).size() ); Neighbor nb2new( nb2(*it).size(), nrNodes1(), iter++ ); nbs1new.push_back( nb1new ); nb2( *it ).push_back( nb2new ); } _nb1.push_back( nbs1new ); return _nb1.size() - 1; } /// Adds a node of type 2, with neighbors specified by a range of nodes of type 1. /** \tparam NodeInputIterator Iterator that iterates over instances of \c size_t. * \param begin Points to the first index of the nodes of type 1 that should become neighbors of the added node. * \param end Points just beyond the last index of the nodes of type 1 that should become neighbors of the added node. * \param sizeHint For improved efficiency, the size of the range may be specified by \a sizeHint. * \returns Index of the added node. */ template size_t addNode2( NodeInputIterator begin, NodeInputIterator end, size_t sizeHint = 0 ) { Neighbors nbs2new; nbs2new.reserve( sizeHint ); size_t iter = 0; for( NodeInputIterator it = begin; it != end; ++it ) { DAI_ASSERT( *it < nrNodes1() ); Neighbor nb2new( iter, *it, nb1(*it).size() ); Neighbor nb1new( nb1(*it).size(), nrNodes2(), iter++ ); nbs2new.push_back( nb2new ); nb1( *it ).push_back( nb1new ); } _nb2.push_back( nbs2new ); return _nb2.size() - 1; } /// Adds a node of type 1, with neighbors specified by a range of nodes of type 2. /** \deprecated Please use dai::BipartiteGraph::addNode1( NodeInputIterator, NodeInputIterator, size_t) instead. */ template size_t add1( NodeInputIterator begin, NodeInputIterator end, size_t sizeHint = 0 ) { return addNode1( begin, end, sizeHint ); } /// Adds a node of type 2, with neighbors specified by a range of nodes of type 1. /** \deprecated Please use dai::BipartiteGraph::addNode2( NodeInputIterator, NodeInputIterator, size_t) instead. */ template size_t add2( NodeInputIterator begin, NodeInputIterator end, size_t sizeHint = 0 ) { return addNode2( begin, end, sizeHint ); } /// Adds an edge between node \a n1 of type 1 and node \a n2 of type 2. /** If \a check == \c true, only adds the edge if it does not exist already. */ void addEdge( size_t n1, size_t n2, bool check = true ); //@} /// \name Erasing nodes and edges //@{ /// Removes node \a n1 of type 1 and all incident edges; indices of other nodes are changed accordingly. void eraseNode1( size_t n1 ); /// Removes node \a n2 of type 2 and all incident edges; indices of other nodes are changed accordingly. void eraseNode2( size_t n2 ); /// Removes node \a n1 of type 1 and all incident edges; indices of other nodes are changed accordingly. /** \deprecated Please use dai::BipartiteGraph::eraseNode1(size_t) instead. */ void erase1( size_t n1 ) { eraseNode1( n1 ); } /// Removes node \a n2 of type 2 and all incident edges; indices of other nodes are changed accordingly. /** \deprecated Please use dai::BipartiteGraph::eraseNode2(size_t) instead. */ void erase2( size_t n2 ) { eraseNode2( n2 ); } /// Removes edge between node \a n1 of type 1 and node \a n2 of type 2. void eraseEdge( size_t n1, size_t n2 ); //@} /// \name Queries //@{ /// Returns number of nodes of type 1 size_t nrNodes1() const { return _nb1.size(); } /// Returns number of nodes of type 2 size_t nrNodes2() const { return _nb2.size(); } /// Returns number of nodes of type 1 /** \deprecated Please use dai::BipartiteGraph::nrNodes1() instead. */ size_t nr1() const { return nrNodes1(); } /// Returns number of nodes of type 2 /** \deprecated Please use dai::BipartiteGraph::nrNodes2() instead. */ size_t nr2() const { return nrNodes2(); } /// Calculates the number of edges, time complexity: O(nrNodes1()) size_t nrEdges() const { size_t sum = 0; for( size_t i1 = 0; i1 < nrNodes1(); i1++ ) sum += nb1(i1).size(); return sum; } /// Calculates second-order neighbors (i.e., neighbors of neighbors) of node \a n1 of type 1. /** If \a include == \c true, includes \a n1 itself, otherwise excludes \a n1. */ std::vector delta1( size_t n1, bool include = false ) const; /// Calculates second-order neighbors (i.e., neighbors of neighbors) of node \a n2 of type 2. /** If \a include == \c true, includes \a n2 itself, otherwise excludes \a n2. */ std::vector delta2( size_t n2, bool include = false ) const; /// Returns true if the graph is connected bool isConnected() const; /// Returns true if the graph is a tree, i.e., if it is singly connected and connected. bool isTree() const; /// Checks internal consistency void checkConsistency() const; //@} /// \name Input and output //@{ /// Writes this BipartiteGraph to an output stream in GraphViz .dot syntax void printDot( std::ostream& os ) const; //@} }; template void BipartiteGraph::construct( size_t nrNodes1, size_t nrNodes2, EdgeInputIterator begin, EdgeInputIterator end ) { _nb1.clear(); _nb1.resize( nrNodes1 ); _nb2.clear(); _nb2.resize( nrNodes2 ); for( EdgeInputIterator e = begin; e != end; e++ ) { #ifdef DAI_DEBUG addEdge( e->first, e->second, true ); #else addEdge( e->first, e->second, false ); #endif } } } // end of namespace dai /** \example example_bipgraph.cpp * This example deals with the following bipartite graph: * \dot * graph example { * ordering=out; * subgraph cluster_type1 { * node[shape=circle,width=0.4,fixedsize=true,style=filled]; * 12 [label="2"]; * 11 [label="1"]; * 10 [label="0"]; * } * subgraph cluster_type2 { * node[shape=polygon,regular=true,sides=4,width=0.4,fixedsize=true,style=filled]; * 21 [label="1"]; * 20 [label="0"]; * } * 10 -- 20; * 11 -- 20; * 12 -- 20; * 11 -- 21; * 12 -- 21; * } * \enddot * It has three nodes of type 1 (drawn as circles) and two nodes of type 2 (drawn as rectangles). * Node 0 of type 1 has only one neighbor (node 0 of type 2), but node 0 of type 2 has three neighbors (nodes 0,1,2 of type 1). * The example code shows how to construct a BipartiteGraph object representing this bipartite graph and * how to iterate over nodes and their neighbors. * * \section Output * \verbinclude examples/example_bipgraph.out * * \section Source */ #endif libDAI-0.2.4/include/dai/prob.h0000644000263000017630000006206211334764775014777 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines TProb<> and Prob classes which represent (probability) vectors (e.g., probability distributions of discrete random variables) #ifndef __defined_libdai_prob_h #define __defined_libdai_prob_h #include #include #include #include #include #include #include #include namespace dai { /// Function object that returns the value itself template struct fo_id : public std::unary_function { /// Returns \a x T operator()( const T &x ) const { return x; } }; /// Function object that takes the absolute value template struct fo_abs : public std::unary_function { /// Returns abs(\a x) T operator()( const T &x ) const { if( x < (T)0 ) return -x; else return x; } }; /// Function object that takes the exponent template struct fo_exp : public std::unary_function { /// Returns exp(\a x) T operator()( const T &x ) const { return exp( x ); } }; /// Function object that takes the logarithm template struct fo_log : public std::unary_function { /// Returns log(\a x) T operator()( const T &x ) const { return log( x ); } }; /// Function object that takes the logarithm, except that log(0) is defined to be 0 template struct fo_log0 : public std::unary_function { /// Returns (\a x == 0 ? 0 : log(\a x)) T operator()( const T &x ) const { if( x ) return log( x ); else return 0; } }; /// Function object that takes the inverse template struct fo_inv : public std::unary_function { /// Returns 1 / \a x T operator()( const T &x ) const { return 1 / x; } }; /// Function object that takes the inverse, except that 1/0 is defined to be 0 template struct fo_inv0 : public std::unary_function { /// Returns (\a x == 0 ? 0 : (1 / \a x)) T operator()( const T &x ) const { if( x ) return 1 / x; else return 0; } }; /// Function object that returns p*log0(p) template struct fo_plog0p : public std::unary_function { /// Returns \a p * log0(\a p) T operator()( const T &p ) const { return p * dai::log0(p); } }; /// Function object similar to std::divides(), but different in that dividing by zero results in zero template struct fo_divides0 : public std::binary_function { /// Returns (\a y == 0 ? 0 : (\a x / \a y)) T operator()( const T &x, const T &y ) const { if( y == (T)0 ) return (T)0; else return x / y; } }; /// Function object useful for calculating the KL distance template struct fo_KL : public std::binary_function { /// Returns (\a p == 0 ? 0 : (\a p * (log(\a p) - log(\a q)))) T operator()( const T &p, const T &q ) const { if( p == (T)0 ) return (T)0; else return p * (log(p) - log(q)); } }; /// Function object useful for calculating the Hellinger distance template struct fo_Hellinger : public std::binary_function { /// Returns (sqrt(\a p) - sqrt(\a q))^2 T operator()( const T &p, const T &q ) const { T x = sqrt(p) - sqrt(q); return x * x; } }; /// Function object that returns x to the power y template struct fo_pow : public std::binary_function { /// Returns (\a x ^ \a y) T operator()( const T &x, const T &y ) const { if( y != 1 ) return std::pow( x, y ); else return x; } }; /// Function object that returns the maximum of two values template struct fo_max : public std::binary_function { /// Returns (\a x > y ? x : y) T operator()( const T &x, const T &y ) const { return (x > y) ? x : y; } }; /// Function object that returns the minimum of two values template struct fo_min : public std::binary_function { /// Returns (\a x > y ? y : x) T operator()( const T &x, const T &y ) const { return (x > y) ? y : x; } }; /// Function object that returns the absolute difference of x and y template struct fo_absdiff : public std::binary_function { /// Returns abs( \a x - \a y ) T operator()( const T &x, const T &y ) const { return dai::abs( x - y ); } }; /// Represents a vector with entries of type \a T. /** It is simply a std::vector<T> with an interface designed for dealing with probability mass functions. * * It is mainly used for representing measures on a finite outcome space, for example, the probability * distribution of a discrete random variable. However, entries are not necessarily non-negative; it is also used to * represent logarithms of probability mass functions. * * \tparam T Should be a scalar that is castable from and to dai::Real and should support elementary arithmetic operations. */ template class TProb { private: /// The vector std::vector _p; public: /// Enumerates different ways of normalizing a probability measure. /** * - NORMPROB means that the sum of all entries should be 1; * - NORMLINF means that the maximum absolute value of all entries should be 1. */ typedef enum { NORMPROB, NORMLINF } NormType; /// Enumerates different distance measures between probability measures. /** * - DISTL1 is the \f$\ell_1\f$ distance (sum of absolute values of pointwise difference); * - DISTLINF is the \f$\ell_\infty\f$ distance (maximum absolute value of pointwise difference); * - DISTTV is the total variation distance (half of the \f$\ell_1\f$ distance); * - DISTKL is the Kullback-Leibler distance (\f$\sum_i p_i (\log p_i - \log q_i)\f$). * - DISTHEL is the Hellinger distance (\f$\frac{1}{2}\sum_i (\sqrt{p_i}-\sqrt{q_i})^2\f$). */ typedef enum { DISTL1, DISTLINF, DISTTV, DISTKL, DISTHEL } DistType; /// \name Constructors and destructors //@{ /// Default constructor (constructs empty vector) TProb() : _p() {} /// Construct uniform probability distribution over \a n outcomes (i.e., a vector of length \a n with each entry set to \f$1/n\f$) explicit TProb( size_t n ) : _p(std::vector(n, (T)1 / n)) {} /// Construct vector of length \a n with each entry set to \a p explicit TProb( size_t n, T p ) : _p(n, p) {} /// Construct vector from a range /** \tparam TIterator Iterates over instances that can be cast to \a T * \param begin Points to first instance to be added. * \param end Points just beyond last instance to be added. * \param sizeHint For efficiency, the number of entries can be speficied by \a sizeHint. */ template TProb( TIterator begin, TIterator end, size_t sizeHint=0 ) : _p() { _p.reserve( sizeHint ); _p.insert( _p.begin(), begin, end ); } /// Construct vector from another vector /** \tparam S type of elements in \a v (should be castable to type \a T) * \param v vector used for initialization */ template TProb( const std::vector &v ) : _p() { _p.reserve( v.size() ); _p.insert( _p.begin(), v.begin(), v.end() ); } //@} /// Constant iterator over the elements typedef typename std::vector::const_iterator const_iterator; /// Iterator over the elements typedef typename std::vector::iterator iterator; /// Constant reverse iterator over the elements typedef typename std::vector::const_reverse_iterator const_reverse_iterator; /// Reverse iterator over the elements typedef typename std::vector::reverse_iterator reverse_iterator; /// \name Iterator interface //@{ /// Returns iterator that points to the first element iterator begin() { return _p.begin(); } /// Returns constant iterator that points to the first element const_iterator begin() const { return _p.begin(); } /// Returns iterator that points beyond the last element iterator end() { return _p.end(); } /// Returns constant iterator that points beyond the last element const_iterator end() const { return _p.end(); } /// Returns reverse iterator that points to the last element reverse_iterator rbegin() { return _p.rbegin(); } /// Returns constant reverse iterator that points to the last element const_reverse_iterator rbegin() const { return _p.rbegin(); } /// Returns reverse iterator that points beyond the first element reverse_iterator rend() { return _p.rend(); } /// Returns constant reverse iterator that points beyond the first element const_reverse_iterator rend() const { return _p.rend(); } //@} /// \name Queries //@{ /// Returns a const reference to the wrapped vector const std::vector & p() const { return _p; } /// Returns a reference to the wrapped vector std::vector & p() { return _p; } /// Returns a copy of the \a i 'th entry T operator[]( size_t i ) const { #ifdef DAI_DEBUG return _p.at(i); #else return _p[i]; #endif } /// Returns reference to the \a i 'th entry T& operator[]( size_t i ) { return _p[i]; } /// Returns length of the vector (i.e., the number of entries) size_t size() const { return _p.size(); } /// Accumulate over all values, similar to std::accumulate template T accumulate( T init, binOp op1, unOp op2 ) const { T t = init; for( const_iterator it = begin(); it != end(); it++ ) t = op1( t, op2(*it) ); return t; } /// Returns the Shannon entropy of \c *this, \f$-\sum_i p_i \log p_i\f$ T entropy() const { return -accumulate( (T)0, std::plus(), fo_plog0p() ); } /// Returns maximum value of all entries T max() const { return accumulate( (T)(-INFINITY), fo_max(), fo_id() ); } /// Returns minimum value of all entries T min() const { return accumulate( (T)INFINITY, fo_min(), fo_id() ); } /// Returns sum of all entries T sum() const { return accumulate( (T)0, std::plus(), fo_id() ); } /// Return sum of absolute value of all entries T sumAbs() const { return accumulate( (T)0, std::plus(), fo_abs() ); } /// Returns maximum absolute value of all entries T maxAbs() const { return accumulate( (T)0, fo_max(), fo_abs() ); } /// Returns \c true if one or more entries are NaN bool hasNaNs() const { bool foundnan = false; for( typename std::vector::const_iterator x = _p.begin(); x != _p.end(); x++ ) if( isnan( *x ) ) { foundnan = true; break; } return foundnan; } /// Returns \c true if one or more entries are negative bool hasNegatives() const { return (std::find_if( _p.begin(), _p.end(), std::bind2nd( std::less(), (T)0 ) ) != _p.end()); } /// Returns a pair consisting of the index of the maximum value and the maximum value itself std::pair argmax() const { T max = _p[0]; size_t arg = 0; for( size_t i = 1; i < size(); i++ ) { if( _p[i] > max ) { max = _p[i]; arg = i; } } return std::make_pair(arg,max); } /// Returns a random index, according to the (normalized) distribution described by *this size_t draw() { Real x = rnd_uniform() * sum(); T s = 0; for( size_t i = 0; i < size(); i++ ) { s += _p[i]; if( s > x ) return i; } return( size() - 1 ); } /// Lexicographical comparison /** \pre this->size() == q.size() */ bool operator<= (const TProb & q) const { DAI_DEBASSERT( size() == q.size() ); return lexicographical_compare( begin(), end(), q.begin(), q.end() ); } //@} /// \name Unary transformations //@{ /// Returns the result of applying operation \a op pointwise on \c *this template TProb pwUnaryTr( unaryOp op ) const { TProb r; r._p.reserve( size() ); std::transform( _p.begin(), _p.end(), back_inserter( r._p ), op ); return r; } /// Returns negative of \c *this TProb operator- () const { return pwUnaryTr( std::negate() ); } /// Returns pointwise absolute value TProb abs() const { return pwUnaryTr( fo_abs() ); } /// Returns pointwise exponent TProb exp() const { return pwUnaryTr( fo_exp() ); } /// Returns pointwise logarithm /** If \a zero == \c true, uses log(0)==0; otherwise, log(0)==-Inf. */ TProb log(bool zero=false) const { if( zero ) return pwUnaryTr( fo_log0() ); else return pwUnaryTr( fo_log() ); } /// Returns pointwise inverse /** If \a zero == \c true, uses 1/0==0; otherwise, 1/0==Inf. */ TProb inverse(bool zero=true) const { if( zero ) return pwUnaryTr( fo_inv0() ); else return pwUnaryTr( fo_inv() ); } /// Returns normalized copy of \c *this, using the specified norm /** \throw NOT_NORMALIZABLE if the norm is zero */ TProb normalized( NormType norm = NORMPROB ) const { T Z = 0; if( norm == NORMPROB ) Z = sum(); else if( norm == NORMLINF ) Z = maxAbs(); if( Z == (T)0 ) { DAI_THROW(NOT_NORMALIZABLE); return *this; } else return pwUnaryTr( std::bind2nd( std::divides(), Z ) ); } //@} /// \name Unary operations //@{ /// Applies unary operation \a op pointwise template TProb& pwUnaryOp( unaryOp op ) { std::transform( _p.begin(), _p.end(), _p.begin(), op ); return *this; } /// Draws all entries i.i.d. from a uniform distribution on [0,1) TProb& randomize() { std::generate( _p.begin(), _p.end(), rnd_uniform ); return *this; } /// Sets all entries to \f$1/n\f$ where \a n is the length of the vector TProb& setUniform () { fill( (T)1 / size() ); return *this; } /// Applies absolute value pointwise const TProb& takeAbs() { return pwUnaryOp( fo_abs() ); } /// Applies exponent pointwise const TProb& takeExp() { return pwUnaryOp( fo_exp() ); } /// Applies logarithm pointwise /** If \a zero == \c true, uses log(0)==0; otherwise, log(0)==-Inf. */ const TProb& takeLog(bool zero=false) { if( zero ) { return pwUnaryOp( fo_log0() ); } else return pwUnaryOp( fo_log() ); } /// Normalizes vector using the specified norm /** \throw NOT_NORMALIZABLE if the norm is zero */ T normalize( NormType norm=NORMPROB ) { T Z = 0; if( norm == NORMPROB ) Z = sum(); else if( norm == NORMLINF ) Z = maxAbs(); if( Z == (T)0 ) DAI_THROW(NOT_NORMALIZABLE); else *this /= Z; return Z; } //@} /// \name Operations with scalars //@{ /// Sets all entries to \a x TProb & fill(T x) { std::fill( _p.begin(), _p.end(), x ); return *this; } /// Adds scalar \a x to each entry TProb& operator+= (T x) { if( x != 0 ) return pwUnaryOp( std::bind2nd( std::plus(), x ) ); else return *this; } /// Subtracts scalar \a x from each entry TProb& operator-= (T x) { if( x != 0 ) return pwUnaryOp( std::bind2nd( std::minus(), x ) ); else return *this; } /// Multiplies each entry with scalar \a x TProb& operator*= (T x) { if( x != 1 ) return pwUnaryOp( std::bind2nd( std::multiplies(), x ) ); else return *this; } /// Divides each entry by scalar \a x TProb& operator/= (T x) { DAI_DEBASSERT( x != 0 ); if( x != 1 ) return pwUnaryOp( std::bind2nd( std::divides(), x ) ); else return *this; } /// Raises entries to the power \a x TProb& operator^= (T x) { if( x != (T)1 ) return pwUnaryOp( std::bind2nd( fo_pow(), x) ); else return *this; } //@} /// \name Transformations with scalars //@{ /// Returns sum of \c *this and scalar \a x TProb operator+ (T x) const { return pwUnaryTr( std::bind2nd( std::plus(), x ) ); } /// Returns difference of \c *this and scalar \a x TProb operator- (T x) const { return pwUnaryTr( std::bind2nd( std::minus(), x ) ); } /// Returns product of \c *this with scalar \a x TProb operator* (T x) const { return pwUnaryTr( std::bind2nd( std::multiplies(), x ) ); } /// Returns quotient of \c *this and scalar \a x, where division by 0 yields 0 TProb operator/ (T x) const { return pwUnaryTr( std::bind2nd( fo_divides0(), x ) ); } /// Returns \c *this raised to the power \a x TProb operator^ (T x) const { return pwUnaryTr( std::bind2nd( fo_pow(), x ) ); } //@} /// \name Operations with other equally-sized vectors //@{ /// Applies binary operation pointwise on two vectors /** \tparam binaryOp Type of function object that accepts two arguments of type \a T and outputs a type \a T * \param q Right operand * \param op Operation of type \a binaryOp */ template TProb& pwBinaryOp( const TProb &q, binaryOp op ) { DAI_DEBASSERT( size() == q.size() ); std::transform( _p.begin(), _p.end(), q._p.begin(), _p.begin(), op ); return *this; } /// Pointwise addition with \a q /** \pre this->size() == q.size() */ TProb& operator+= (const TProb & q) { return pwBinaryOp( q, std::plus() ); } /// Pointwise subtraction of \a q /** \pre this->size() == q.size() */ TProb& operator-= (const TProb & q) { return pwBinaryOp( q, std::minus() ); } /// Pointwise multiplication with \a q /** \pre this->size() == q.size() */ TProb& operator*= (const TProb & q) { return pwBinaryOp( q, std::multiplies() ); } /// Pointwise division by \a q, where division by 0 yields 0 /** \pre this->size() == q.size() * \see divide(const TProb &) */ TProb& operator/= (const TProb & q) { return pwBinaryOp( q, fo_divides0() ); } /// Pointwise division by \a q, where division by 0 yields +Inf /** \pre this->size() == q.size() * \see operator/=(const TProb &) */ TProb& divide (const TProb & q) { return pwBinaryOp( q, std::divides() ); } /// Pointwise power /** \pre this->size() == q.size() */ TProb& operator^= (const TProb & q) { return pwBinaryOp( q, fo_pow() ); } //@} /// \name Transformations with other equally-sized vectors //@{ /// Returns the result of applying binary operation \a op pointwise on \c *this and \a q /** \tparam binaryOp Type of function object that accepts two arguments of type \a T and outputs a type \a T * \param q Right operand * \param op Operation of type \a binaryOp */ template TProb pwBinaryTr( const TProb &q, binaryOp op ) const { DAI_DEBASSERT( size() == q.size() ); TProb r; r._p.reserve( size() ); std::transform( _p.begin(), _p.end(), q._p.begin(), back_inserter( r._p ), op ); return r; } /// Returns sum of \c *this and \a q /** \pre this->size() == q.size() */ TProb operator+ ( const TProb& q ) const { return pwBinaryTr( q, std::plus() ); } /// Return \c *this minus \a q /** \pre this->size() == q.size() */ TProb operator- ( const TProb& q ) const { return pwBinaryTr( q, std::minus() ); } /// Return product of \c *this with \a q /** \pre this->size() == q.size() */ TProb operator* ( const TProb &q ) const { return pwBinaryTr( q, std::multiplies() ); } /// Returns quotient of \c *this with \a q, where division by 0 yields 0 /** \pre this->size() == q.size() * \see divided_by(const TProb &) */ TProb operator/ ( const TProb &q ) const { return pwBinaryTr( q, fo_divides0() ); } /// Pointwise division by \a q, where division by 0 yields +Inf /** \pre this->size() == q.size() * \see operator/(const TProb &) */ TProb divided_by( const TProb &q ) const { return pwBinaryTr( q, std::divides() ); } /// Returns \c *this to the power \a q /** \pre this->size() == q.size() */ TProb operator^ ( const TProb &q ) const { return pwBinaryTr( q, fo_pow() ); } //@} /// Performs a generalized inner product, similar to std::inner_product /** \pre this->size() == q.size() */ template T innerProduct( const TProb &q, T init, binOp1 binaryOp1, binOp2 binaryOp2 ) const { DAI_DEBASSERT( size() == q.size() ); return std::inner_product( begin(), end(), q.begin(), init, binaryOp1, binaryOp2 ); } }; /// Returns distance between \a p and \a q, measured using distance measure \a dt /** \relates TProb * \pre this->size() == q.size() */ template T dist( const TProb &p, const TProb &q, typename TProb::DistType dt ) { switch( dt ) { case TProb::DISTL1: return p.innerProduct( q, (T)0, std::plus(), fo_absdiff() ); case TProb::DISTLINF: return p.innerProduct( q, (T)0, fo_max(), fo_absdiff() ); case TProb::DISTTV: return p.innerProduct( q, (T)0, std::plus(), fo_absdiff() ) / 2; case TProb::DISTKL: return p.innerProduct( q, (T)0, std::plus(), fo_KL() ); case TProb::DISTHEL: return p.innerProduct( q, (T)0, std::plus(), fo_Hellinger() ) / 2; default: DAI_THROW(UNKNOWN_ENUM_VALUE); return INFINITY; } } /// Writes a TProb to an output stream /** \relates TProb */ template std::ostream& operator<< (std::ostream& os, const TProb& p) { os << "["; std::copy( p.p().begin(), p.p().end(), std::ostream_iterator(os, " ") ); os << "]"; return os; } /// Returns the pointwise minimum of \a a and \a b /** \relates TProb * \pre this->size() == q.size() */ template TProb min( const TProb &a, const TProb &b ) { return a.pwBinaryTr( b, fo_min() ); } /// Returns the pointwise maximum of \a a and \a b /** \relates TProb * \pre this->size() == q.size() */ template TProb max( const TProb &a, const TProb &b ) { return a.pwBinaryTr( b, fo_max() ); } /// Represents a vector with entries of type dai::Real. typedef TProb Prob; } // end of namespace dai #endif libDAI-0.2.4/include/dai/matlab/0000755000263000017630000000000011334764775015116 5ustar jorismkyblibDAI-0.2.4/include/dai/matlab/matlab.h0000644000263000017630000000211111334764775016522 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines some utility functions for interfacing with MatLab #ifndef __defined_libdai_matlab_h #define __defined_libdai_matlab_h #include "mex.h" #include namespace dai { #ifdef SMALLMEM typedef int mwSize; typedef int mwIndex; #endif /// Convert vector structure to a cell vector of CPTAB-like structs mxArray *Factors2mx(const std::vector &Ps); /// Convert cell vector of CPTAB-like structs to vector std::vector mx2Factors(const mxArray *psi, long verbose); /// Convert CPTAB-like struct to Factor Factor mx2Factor(const mxArray *psi); } // end of namespace dai #endif libDAI-0.2.4/include/dai/treeep.h0000644000263000017630000002032611334764775015316 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines class TreeEP, which implements Tree Expectation Propagation /// \todo Clean up the TreeEP code (exploiting that a large part of the code /// is just a special case of JTree). #ifndef __defined_libdai_treeep_h #define __defined_libdai_treeep_h #include #include #include #include #include #include #include #include #include #include #include namespace dai { /// Approximate inference algorithm "Tree Expectation Propagation" [\ref MiQ04] class TreeEP : public JTree { private: /// Maximum difference encountered so far Real _maxdiff; /// Number of iterations needed size_t _iters; public: /// Parameters for TreeEP struct Properties { /// Enumeration of possible choices for the tree /** The two possibilities are: * - \c ORG: take the maximum spanning tree where the weights are crude * estimates of the mutual information between the nodes; * - \c ALT: take the maximum spanning tree where the weights are upper * bounds on the effective interaction strengths between pairs of nodes. */ DAI_ENUM(TypeType,ORG,ALT); /// Verbosity (amount of output sent to stderr) size_t verbose; /// Maximum number of iterations size_t maxiter; /// Tolerance for convergence test Real tol; /// How to choose the tree TypeType type; } props; /// Name of this inference method static const char *Name; private: /// Stores the data structures needed to efficiently update the approximation of an off-tree factor. /** The TreeEP object stores a TreeEPSubTree object for each off-tree factor. * It stores the approximation of that off-tree factor, which is represented * as a distribution on a subtree of the main tree. */ class TreeEPSubTree { private: /// Outer region pseudomarginals (corresponding with the \f$\tilde f_i(x_j,x_k)\f$ in [\ref MiQ04]) std::vector _Qa; /// Inner region pseudomarginals (corresponding with the \f$\tilde f_i(x_s)\f$ in [\ref MiQ04]) std::vector _Qb; /// The junction tree (stored as a rooted tree) RootedTree _RTree; /// Index conversion table for outer region indices (_Qa[alpha] corresponds with Qa[_a[alpha]] of the supertree) std::vector _a; /// Index conversion table for inner region indices (_Qb[beta] corresponds with Qb[_b[beta]] of the supertree) std::vector _b; /// Pointer to off-tree factor const Factor * _I; /// Variables in off-tree factor VarSet _ns; /// Variables in off-tree factor which are not in the root of this subtree VarSet _nsrem; /// Used for calculating the free energy Real _logZ; public: /// \name Constructors/destructors //@{ /// Default constructor TreeEPSubTree() : _Qa(), _Qb(), _RTree(), _a(), _b(), _I(NULL), _ns(), _nsrem(), _logZ(0.0) {} /// Copy constructor TreeEPSubTree( const TreeEPSubTree &x ) : _Qa(x._Qa), _Qb(x._Qb), _RTree(x._RTree), _a(x._a), _b(x._b), _I(x._I), _ns(x._ns), _nsrem(x._nsrem), _logZ(x._logZ) {} /// Assignment operator TreeEPSubTree & operator=( const TreeEPSubTree& x ) { if( this != &x ) { _Qa = x._Qa; _Qb = x._Qb; _RTree = x._RTree; _a = x._a; _b = x._b; _I = x._I; _ns = x._ns; _nsrem = x._nsrem; _logZ = x._logZ; } return *this; } /// Construct from \a subRTree, which is a subtree of the main tree \a jt_RTree, with distribution represented by \a jt_Qa and \a jt_Qb, for off-tree factor \a I TreeEPSubTree( const RootedTree &subRTree, const RootedTree &jt_RTree, const std::vector &jt_Qa, const std::vector &jt_Qb, const Factor *I ); //@} /// Initializes beliefs of this subtree void init(); /// Inverts this approximation and multiplies it by the (super) junction tree marginals \a Qa and \a Qb void InvertAndMultiply( const std::vector &Qa, const std::vector &Qb ); /// Runs junction tree algorithm (including off-tree factor I) storing the results in the (super) junction tree \a Qa and \a Qb void HUGIN_with_I( std::vector &Qa, std::vector &Qb ); /// Returns energy (?) of this subtree Real logZ( const std::vector &Qa, const std::vector &Qb ) const; /// Returns constant reference to the pointer to the off-tree factor const Factor *& I() { return _I; } }; /// Stores a TreeEPSubTree object for each off-tree factor std::map _Q; public: /// Default constructor TreeEP() : JTree(), _maxdiff(0.0), _iters(0), props(), _Q() {} /// Copy constructor TreeEP( const TreeEP &x ) : JTree(x), _maxdiff(x._maxdiff), _iters(x._iters), props(x.props), _Q(x._Q) { for( size_t I = 0; I < nrFactors(); I++ ) if( offtree( I ) ) _Q[I].I() = &factor(I); } /// Assignment operator TreeEP& operator=( const TreeEP &x ) { if( this != &x ) { JTree::operator=( x ); _maxdiff = x._maxdiff; _iters = x._iters; props = x.props; _Q = x._Q; for( size_t I = 0; I < nrFactors(); I++ ) if( offtree( I ) ) _Q[I].I() = &factor(I); } return *this; } /// Construct from FactorGraph \a fg and PropertySet \a opts /** \param opts Parameters @see Properties * \note The factor graph has to be connected. * \throw FACTORGRAPH_NOT_CONNECTED if \a fg is not connected */ TreeEP( const FactorGraph &fg, const PropertySet &opts ); /// \name General InfAlg interface //@{ virtual TreeEP* clone() const { return new TreeEP(*this); } virtual std::string identify() const; virtual Real logZ() const; virtual void init(); virtual void init( const VarSet &/*ns*/ ) { init(); } virtual Real run(); virtual Real maxDiff() const { return _maxdiff; } virtual size_t Iterations() const { return _iters; } virtual void setProperties( const PropertySet &opts ); virtual PropertySet getProperties() const; virtual std::string printProperties() const; //@} private: /// Helper function for constructors void construct( const RootedTree &tree ); /// Returns \c true if factor \a I is not part of the tree bool offtree( size_t I ) const { return (fac2OR[I] == -1U); } }; } // end of namespace dai #endif libDAI-0.2.4/include/dai/lc.h0000644000263000017630000001351511334764775014432 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines class LC, which implements loop corrections for approximate inference #ifndef __defined_libdai_lc_h #define __defined_libdai_lc_h #include #include #include #include #include #include namespace dai { /// Approximate inference algorithm "Loop Corrected Belief Propagation" [\ref MoK07] class LC : public DAIAlgFG { private: /// Stores for each variable the approximate cavity distribution multiplied with the omitted factors std::vector _pancakes; /// Stores for each variable the approximate cavity distribution std::vector _cavitydists; /// _phis[i][_I] corresponds to \f$ \phi^{\setminus i}_I(x_{I \setminus i}) \f$ in the paper std::vector > _phis; /// Single variable beliefs std::vector _beliefs; /// Maximum difference encountered so far Real _maxdiff; /// Number of iterations needed size_t _iters; public: /// Parameters for LC struct Properties { /// Enumeration of possible ways to initialize the cavities /** The following initialization methods are defined: * - FULL calculates the marginal using calcMarginal() * - PAIR calculates only second order interactions using calcPairBeliefs() with \a accurate == \c false * - PAIR2 calculates only second order interactions using calcPairBeliefs() with \a accurate == \c true * - UNIFORM uses a uniform distribution */ DAI_ENUM(CavityType,FULL,PAIR,PAIR2,UNIFORM); /// Enumeration of different update schedules /** The following update schedules are defined: * - SEQFIX sequential fixed schedule * - SEQRND sequential random schedule */ DAI_ENUM(UpdateType,SEQFIX,SEQRND); /// Verbosity (amount of output sent to stderr) size_t verbose; /// Maximum number of iterations size_t maxiter; /// Tolerance for convergence test Real tol; /// Complete or partial reinitialization of cavity graphs? bool reinit; /// Damping constant (0.0 means no damping, 1.0 is maximum damping) Real damping; /// How to initialize the cavities CavityType cavity; /// What update schedule to use UpdateType updates; /// Name of the algorithm used to initialize the cavity distributions std::string cavainame; /// Parameters for the algorithm used to initialize the cavity distributions PropertySet cavaiopts; } props; /// Name of this inference algorithm static const char *Name; public: /// Default constructor LC() : DAIAlgFG(), _pancakes(), _cavitydists(), _phis(), _beliefs(), _maxdiff(), _iters(), props() {} /// Construct from FactorGraph \a fg and PropertySet \a opts /** \param opts Parameters @see Properties */ LC( const FactorGraph &fg, const PropertySet &opts ); /// \name General InfAlg interface //@{ virtual LC* clone() const { return new LC(*this); } virtual std::string identify() const; virtual Factor belief( const Var &v ) const { return beliefV( findVar( v ) ); } virtual Factor belief( const VarSet &/*vs*/ ) const { DAI_THROW(NOT_IMPLEMENTED); return Factor(); } virtual Factor beliefV( size_t i ) const { return _beliefs[i]; } virtual std::vector beliefs() const { return _beliefs; } virtual Real logZ() const { DAI_THROW(NOT_IMPLEMENTED); return 0.0; } virtual void init(); virtual void init( const VarSet &/*ns*/ ) { init(); } virtual Real run(); virtual Real maxDiff() const { return _maxdiff; } virtual size_t Iterations() const { return _iters; } virtual void setProperties( const PropertySet &opts ); virtual PropertySet getProperties() const; virtual std::string printProperties() const; //@} /// \name Additional interface specific for LC //@{ /// Approximates the cavity distribution of variable \a i, using the inference algorithm \a name with parameters \a opts Real CalcCavityDist( size_t i, const std::string &name, const PropertySet &opts ); /// Approximates all cavity distributions using inference algorithm \a name with parameters \a opts Real InitCavityDists( const std::string &name, const PropertySet &opts ); /// Sets approximate cavity distributions to \a Q long SetCavityDists( std::vector &Q ); /// Updates the belief of the Markov blanket of variable \a i based upon the information from its \a _I 'th neighboring factor Factor NewPancake (size_t i, size_t _I, bool & hasNaNs); /// Calculates the belief of variable \a i void CalcBelief (size_t i); /// Returns the belief of the Markov blanket of variable \a i (including the variable itself) const Factor &pancake (size_t i) const { return _pancakes[i]; }; /// Returns the approximate cavity distribution for variable \a i const Factor &cavitydist (size_t i) const { return _cavitydists[i]; }; //@} }; } // end of namespace dai #endif libDAI-0.2.4/include/dai/jtree.h0000644000263000017630000002134611334764775015146 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines class JTree, which implements the junction tree algorithm #ifndef __defined_libdai_jtree_h #define __defined_libdai_jtree_h #include #include #include #include #include #include #include #include #include #include namespace dai { /// Exact inference algorithm using junction tree /** The junction tree algorithm uses message passing on a junction tree to calculate * exact marginal probability distributions ("beliefs") for specified cliques * (outer regions) and separators (intersections of pairs of cliques). * * There are two variants, the sum-product algorithm (corresponding to * finite temperature) and the max-product algorithm (corresponding to * zero temperature). */ class JTree : public DAIAlgRG { private: /// Stores the messages std::vector > _mes; /// Stores the logarithm of the partition sum Real _logZ; public: /// The junction tree (stored as a rooted tree) RootedTree RTree; /// Outer region beliefs std::vector Qa; /// Inner region beliefs std::vector Qb; /// Parameters for JTree struct Properties { /// Enumeration of possible JTree updates /** There are two types of updates: * - HUGIN similar to those in HUGIN * - SHSH Shafer-Shenoy type */ DAI_ENUM(UpdateType,HUGIN,SHSH); /// Enumeration of inference variants /** There are two inference variants: * - SUMPROD Sum-Product * - MAXPROD Max-Product (equivalent to Min-Sum) */ DAI_ENUM(InfType,SUMPROD,MAXPROD); /// Enumeration of elimination cost functions used for constructing the junction tree /** The cost of eliminating a variable can be (\see [\ref KoF09], page 314)): * - MINNEIGHBORS the number of neighbors it has in the current adjacency graph; * - MINWEIGHT the product of the number of states of all neighbors in the current adjacency graph; * - MINFILL the number of edges that need to be added to the adjacency graph due to the elimination; * - WEIGHTEDMINFILL the sum of weights of the edges that need to be added to the adjacency graph * due to the elimination, where a weight of an edge is the produt of weights of its constituent * vertices. * The elimination sequence is chosen greedily in order to minimize the cost. */ DAI_ENUM(HeuristicType,MINNEIGHBORS,MINWEIGHT,MINFILL,WEIGHTEDMINFILL); /// Verbosity (amount of output sent to stderr) size_t verbose; /// Type of updates UpdateType updates; /// Type of inference InfType inference; /// Heuristic to use for constructing the junction tree HeuristicType heuristic; } props; /// Name of this inference algorithm static const char *Name; public: /// \name Constructors/destructors //@{ /// Default constructor JTree() : DAIAlgRG(), _mes(), _logZ(), RTree(), Qa(), Qb(), props() {} /// Construct from FactorGraph \a fg and PropertySet \a opts /** \param fg factor graph (which has to be connected); ** \param opts Parameters @see Properties * \param automatic if \c true, construct the junction tree automatically, using the heuristic in opts['heuristic']. * \throw FACTORGRAPH_NOT_CONNECTED if \a fg is not connected */ JTree( const FactorGraph &fg, const PropertySet &opts, bool automatic=true ); //@} /// \name General InfAlg interface //@{ virtual JTree* clone() const { return new JTree(*this); } virtual std::string identify() const; virtual Factor belief( const VarSet &vs ) const; virtual std::vector beliefs() const; virtual Real logZ() const; virtual void init() {} virtual void init( const VarSet &/*ns*/ ) {} virtual Real run(); virtual Real maxDiff() const { return 0.0; } virtual size_t Iterations() const { return 1UL; } virtual void setProperties( const PropertySet &opts ); virtual PropertySet getProperties() const; virtual std::string printProperties() const; //@} /// \name Additional interface specific for JTree //@{ /// Constructs a junction tree based on the cliques \a cl (corresponding to some elimination sequence). /** First, constructs a weighted graph, where the nodes are the elements of \a cl, and * each edge is weighted with the cardinality of the intersection of the state spaces of the nodes. * Then, a maximal spanning tree for this weighted graph is calculated. * Subsequently, a corresponding region graph is built: * - the outer regions correspond with the cliques and have counting number 1; * - the inner regions correspond with the seperators, i.e., the intersections of two * cliques that are neighbors in the spanning tree, and have counting number -1; * - inner and outer regions are connected by an edge if the inner region is a * seperator for the outer region. * Finally, Beliefs are constructed. * If \a verify == \c true, checks whether each factor is subsumed by a clique. */ void construct( const std::vector &cl, bool verify=false ); /// Constructs a junction tree based on the cliques \a cl (corresponding to some elimination sequence). /** Invokes construct() and then constructs messages. * \see construct() */ void GenerateJT( const std::vector &cl ); /// Returns constant reference to the message from outer region \a alpha to its \a _beta 'th neighboring inner region const Factor & message( size_t alpha, size_t _beta ) const { return _mes[alpha][_beta]; } /// Returns reference to the message from outer region \a alpha to its \a _beta 'th neighboring inner region Factor & message( size_t alpha, size_t _beta ) { return _mes[alpha][_beta]; } /// Runs junction tree algorithm using HUGIN (message-free) updates /** \note The initial messages may be arbitrary; actually they are not used at all. */ void runHUGIN(); /// Runs junction tree algorithm using Shafer-Shenoy updates /** \note The initial messages may be arbitrary. */ void runShaferShenoy(); /// Finds an efficient subtree for calculating the marginal of the variables in \a vs /** First, the current junction tree is reordered such that it gets as root the clique * that has maximal state space overlap with \a vs. Then, the minimal subtree * (starting from the root) is identified that contains all the variables in \a vs * and also the outer region with index \a PreviousRoot (if specified). Finally, * the current junction tree is reordered such that this minimal subtree comes * before the other edges, and the size of the minimal subtree is returned. */ size_t findEfficientTree( const VarSet& vs, RootedTree &Tree, size_t PreviousRoot=(size_t)-1 ) const; /// Calculates the marginal of a set of variables (using cutset conditioning, if necessary) /** \pre assumes that run() has been called already */ Factor calcMarginal( const VarSet& vs ); /// Calculates the joint state of all variables that has maximum probability /** \pre Assumes that run() has been called and that \a props.inference == \c MAXPROD */ std::vector findMaximum() const; //@} }; /// Calculates upper bound to the treewidth of a FactorGraph, using the specified heuristic /** \relates JTree * \return a pair (number of variables in largest clique, number of states in largest clique) */ std::pair boundTreewidth( const FactorGraph &fg, greedyVariableElimination::eliminationCostFunction fn ); } // end of namespace dai #endif libDAI-0.2.4/include/dai/bp.h0000644000263000017630000002732111334764775014435 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines class BP, which implements (Loopy) Belief Propagation #ifndef __defined_libdai_bp_h #define __defined_libdai_bp_h #include #include #include #include #include namespace dai { /// Approximate inference algorithm "(Loopy) Belief Propagation" /** The Loopy Belief Propagation algorithm uses message passing * to approximate marginal probability distributions ("beliefs") for variables * and factors (more precisely, for the subset of variables depending on the factor). * There are two variants, the sum-product algorithm (corresponding to * finite temperature) and the max-product algorithm (corresponding to * zero temperature). * * The messages \f$m_{I\to i}(x_i)\f$ are passed from factors \f$I\f$ to variables \f$i\f$. * In case of the sum-product algorith, the update equation is: * \f[ m_{I\to i}(x_i) \propto \sum_{x_{N_I\setminus\{i\}}} f_I(x_I) \prod_{j\in N_I\setminus\{i\}} \prod_{J\in N_j\setminus\{I\}} m_{J\to j}\f] * and in case of the max-product algorithm: * \f[ m_{I\to i}(x_i) \propto \max_{x_{N_I\setminus\{i\}}} f_I(x_I) \prod_{j\in N_I\setminus\{i\}} \prod_{J\in N_j\setminus\{I\}} m_{J\to j}\f] * In order to improve convergence, the updates can be damped. For improved numerical stability, * the updates can be done in the log-domain alternatively. * * After convergence, the variable beliefs are calculated by: * \f[ b_i(x_i) \propto \prod_{I\in N_i} m_{I\to i}(x_i)\f] * and the factor beliefs are calculated by: * \f[ b_I(x_I) \propto f_I(x_I) \prod_{j\in N_I} \prod_{J\in N_j\setminus\{I\}} m_{J\to j}(x_j) \f] * The logarithm of the partition sum is calculated by: * \f[ \log Z = \sum_i (1 - |N_i|) \sum_{x_i} b_i(x_i) \log b_i(x_i) - \sum_I \sum_{x_I} b_I(x_I) \log \frac{b_I(x_I)}{f_I(x_I)} \f] * * For the max-product algorithm, a heuristic way of finding the MAP state (the * joint configuration of all variables which has maximum probability) is provided * by the findMaximum() method, which can be called after convergence. * * \note There are two implementations, an optimized one (the default) which caches IndexFor objects, * and a slower, less complicated one which is easier to maintain/understand. The slower one can be * enabled by defining DAI_BP_FAST as false in the source file. */ class BP : public DAIAlgFG { protected: /// Type used for index cache typedef std::vector ind_t; /// Type used for storing edge properties struct EdgeProp { /// Index cached for this edge ind_t index; /// Old message living on this edge Prob message; /// New message living on this edge Prob newMessage; /// Residual for this edge Real residual; }; /// Stores all edge properties std::vector > _edges; /// Type of lookup table (only used for maximum-residual BP) typedef std::multimap > LutType; /// Lookup table (only used for maximum-residual BP) std::vector > _edge2lut; /// Lookup table (only used for maximum-residual BP) LutType _lut; /// Maximum difference between variable beliefs encountered so far Real _maxdiff; /// Number of iterations needed size_t _iters; /// The history of message updates (only recorded if \a recordSentMessages is \c true) std::vector > _sentMessages; public: /// Parameters for BP struct Properties { /// Enumeration of possible update schedules /** The following update schedules have been defined: * - PARALL parallel updates * - SEQFIX sequential updates using a fixed sequence * - SEQRND sequential updates using a random sequence * - SEQMAX maximum-residual updates [\ref EMK06] */ DAI_ENUM(UpdateType,SEQFIX,SEQRND,SEQMAX,PARALL); /// Enumeration of inference variants /** There are two inference variants: * - SUMPROD Sum-Product * - MAXPROD Max-Product (equivalent to Min-Sum) */ DAI_ENUM(InfType,SUMPROD,MAXPROD); /// Verbosity (amount of output sent to stderr) size_t verbose; /// Maximum number of iterations size_t maxiter; /// Tolerance for convergence test Real tol; /// Whether updates should be done in logarithmic domain or not bool logdomain; /// Damping constant (0.0 means no damping, 1.0 is maximum damping) Real damping; /// Message update schedule UpdateType updates; /// Inference variant InfType inference; } props; /// Name of this inference algorithm static const char *Name; /// Specifies whether the history of message updates should be recorded bool recordSentMessages; public: /// \name Constructors/destructors //@{ /// Default constructor BP() : DAIAlgFG(), _edges(), _edge2lut(), _lut(), _maxdiff(0.0), _iters(0U), _sentMessages(), props(), recordSentMessages(false) {} /// Construct from FactorGraph \a fg and PropertySet \a opts /** \param opts Parameters @see Properties */ BP( const FactorGraph & fg, const PropertySet &opts ) : DAIAlgFG(fg), _edges(), _maxdiff(0.0), _iters(0U), _sentMessages(), props(), recordSentMessages(false) { setProperties( opts ); construct(); } /// Copy constructor BP( const BP &x ) : DAIAlgFG(x), _edges(x._edges), _edge2lut(x._edge2lut), _lut(x._lut), _maxdiff(x._maxdiff), _iters(x._iters), _sentMessages(x._sentMessages), props(x.props), recordSentMessages(x.recordSentMessages) { for( LutType::iterator l = _lut.begin(); l != _lut.end(); ++l ) _edge2lut[l->second.first][l->second.second] = l; } /// Assignment operator BP& operator=( const BP &x ) { if( this != &x ) { DAIAlgFG::operator=( x ); _edges = x._edges; _lut = x._lut; for( LutType::iterator l = _lut.begin(); l != _lut.end(); ++l ) _edge2lut[l->second.first][l->second.second] = l; _maxdiff = x._maxdiff; _iters = x._iters; _sentMessages = x._sentMessages; props = x.props; recordSentMessages = x.recordSentMessages; } return *this; } //@} /// \name General InfAlg interface //@{ virtual BP* clone() const { return new BP(*this); } virtual std::string identify() const; virtual Factor belief( const Var &v ) const { return beliefV( findVar( v ) ); } virtual Factor belief( const VarSet &vs ) const; virtual Factor beliefV( size_t i ) const; virtual Factor beliefF( size_t I ) const; virtual std::vector beliefs() const; virtual Real logZ() const; virtual void init(); virtual void init( const VarSet &ns ); virtual Real run(); virtual Real maxDiff() const { return _maxdiff; } virtual size_t Iterations() const { return _iters; } virtual void setProperties( const PropertySet &opts ); virtual PropertySet getProperties() const; virtual std::string printProperties() const; //@} /// \name Additional interface specific for BP //@{ /// Calculates the joint state of all variables that has maximum probability /** \pre Assumes that run() has been called and that \a props.inference == \c MAXPROD */ std::vector findMaximum() const; /// Returns history of which messages have been updated const std::vector >& getSentMessages() const { return _sentMessages; } /// Clears history of which messages have been updated void clearSentMessages() { _sentMessages.clear(); } //@} protected: /// Returns constant reference to message from the \a _I 'th neighbor of variable \a i to variable \a i const Prob & message(size_t i, size_t _I) const { return _edges[i][_I].message; } /// Returns reference to message from the \a _I 'th neighbor of variable \a i to variable \a i Prob & message(size_t i, size_t _I) { return _edges[i][_I].message; } /// Returns constant reference to updated message from the \a _I 'th neighbor of variable \a i to variable \a i const Prob & newMessage(size_t i, size_t _I) const { return _edges[i][_I].newMessage; } /// Returns reference to updated message from the \a _I 'th neighbor of variable \a i to variable \a i Prob & newMessage(size_t i, size_t _I) { return _edges[i][_I].newMessage; } /// Returns constant reference to cached index for the edge between variable \a i and its \a _I 'th neighbor const ind_t & index(size_t i, size_t _I) const { return _edges[i][_I].index; } /// Returns reference to cached index for the edge between variable \a i and its \a _I 'th neighbor ind_t & index(size_t i, size_t _I) { return _edges[i][_I].index; } /// Returns constant reference to residual for the edge between variable \a i and its \a _I 'th neighbor const Real & residual(size_t i, size_t _I) const { return _edges[i][_I].residual; } /// Returns reference to residual for the edge between variable \a i and its \a _I 'th neighbor Real & residual(size_t i, size_t _I) { return _edges[i][_I].residual; } /// Calculate the product of factor \a I and the incoming messages /** If \a without_i == \c true, the message coming from variable \a i is omitted from the product * \note This function is used by calcNewMessage() and calcBeliefF() */ virtual Prob calcIncomingMessageProduct( size_t I, bool without_i, size_t i ) const; /// Calculate the updated message from the \a _I 'th neighbor of variable \a i to variable \a i virtual void calcNewMessage( size_t i, size_t _I ); /// Replace the "old" message from the \a _I 'th neighbor of variable \a i to variable \a i by the "new" (updated) message void updateMessage( size_t i, size_t _I ); /// Set the residual (difference between new and old message) for the edge between variable \a i and its \a _I 'th neighbor to \a r void updateResidual( size_t i, size_t _I, Real r ); /// Finds the edge which has the maximum residual (difference between new and old message) void findMaxResidual( size_t &i, size_t &_I ); /// Calculates unnormalized belief of variable \a i virtual void calcBeliefV( size_t i, Prob &p ) const; /// Calculates unnormalized belief of factor \a I virtual void calcBeliefF( size_t I, Prob &p ) const { p = calcIncomingMessageProduct( I, false, 0 ); } /// Helper function for constructors virtual void construct(); }; } // end of namespace dai #endif libDAI-0.2.4/include/dai/fbp.h0000644000263000017630000001135311334764775014601 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Frederik Eaton [frederik at ofb dot net] * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ /// \file /// \brief Defines class FBP, which implements Fractional Belief Propagation #ifndef __defined_libdai_fbp_h #define __defined_libdai_fbp_h #include #include #include #include #include #include namespace dai { /// Approximate inference algorithm "Fractional Belief Propagation" [\ref WiH03] /** The Fractional Belief Propagation algorithm is like Belief * Propagation, but associates each factor with a weight (scale parameter) * which controls the divergence measure being minimized. Standard * Belief Propagation corresponds to the case of FBP where each weight * is 1. When cast as an EP algorithm, BP (and EP) minimize * the inclusive KL-divergence, i.e. \f$\min_q KL(p||q)\f$ (note that the * Bethe free energy is typically derived from \f$ KL(q||p) \f$). If each * factor \a I has weight \f$ c_I \f$, then FBP minimizes the * alpha-divergence with \f$ \alpha=1/c_I \f$ for that factor, which also * corresponds to Power EP [\ref Min05]. * * The messages \f$m_{I\to i}(x_i)\f$ are passed from factors \f$I\f$ to variables \f$i\f$. * The update equation is given by: * \f[ m_{I\to i}(x_i) \propto \left( \sum_{x_{N_I\setminus\{i\}}} f_I(x_I)^{1/c_I} \prod_{j\in N_I\setminus\{i\}} m_{I\to j}^{1-1/c_I} \prod_{J\in N_j\setminus\{I\}} m_{J\to j} \right)^{c_I} \f] * After convergence, the variable beliefs are calculated by: * \f[ b_i(x_i) \propto \prod_{I\in N_i} m_{I\to i} \f] * and the factor beliefs are calculated by: * \f[ b_I(x_I) \propto f_I(x_I)^{1/c_I} \prod_{j \in N_I} m_{I\to j}^{1-1/c_I} \prod_{J\in N_j\setminus\{I\}} m_{J\to j} \f] * The logarithm of the partition sum is approximated by: * \f[ \log Z = \sum_{I} \sum_{x_I} b_I(x_I) \big( \log f_I(x_I) - c_I \log b_I(x_I) \big) + \sum_{i} (c_i - 1) \sum_{x_i} b_i(x_i) \log b_i(x_i) \f] * where the variable weights are defined as * \f[ c_i := \sum_{I \in N_i} c_I \f] * * \todo Add nice way to set weights * \author Frederik Eaton */ class FBP : public BP { protected: /// Factor weights (indexed by factor ID) std::vector _weight; public: /// Name of this inference algorithm static const char *Name; public: /// \name Constructors/destructors //@{ /// Default constructor FBP() : BP(), _weight() {} /// Construct from FactorGraph \a fg and PropertySet \a opts /** \param opts Parameters @see BP::Properties */ FBP( const FactorGraph &fg, const PropertySet &opts ) : BP(fg, opts), _weight() { setProperties( opts ); construct(); } //@} /// \name General InfAlg interface //@{ virtual FBP* clone() const { return new FBP(*this); } virtual std::string identify() const; virtual Real logZ() const; //@} /// \name FBP accessors/mutators for weights //@{ /// Returns weight of the \a I 'th factor Real Weight( size_t I ) const { return _weight[I]; } /// Returns constant reference to vector of all factor weights const std::vector& Weights() const { return _weight; } /// Sets the weight of the \a I 'th factor to \a c void setWeight( size_t I, Real c ) { _weight[I] = c; } /// Sets the weights of all factors simultaenously /** \note Faster than calling setWeight(size_t,Real) for each factor */ void setWeights( const std::vector &c ) { _weight = c; } protected: /// Calculate the product of factor \a I and the incoming messages /** If \a without_i == \c true, the message coming from variable \a i is omitted from the product * \note This function is used by calcNewMessage() and calcBeliefF() */ virtual Prob calcIncomingMessageProduct( size_t I, bool without_i, size_t i ) const; // Calculate the updated message from the \a _I 'th neighbor of variable \a i to variable \a i virtual void calcNewMessage( size_t i, size_t _I ); // Calculates unnormalized belief of factor \a I virtual void calcBeliefF( size_t I, Prob &p ) const { p = calcIncomingMessageProduct( I, false, 0 ); } // Helper function for constructors virtual void construct(); }; } // end of namespace dai #endif libDAI-0.2.4/include/dai/clustergraph.h0000644000263000017630000003141211334764775016533 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines class ClusterGraph, which is used by JTree, TreeEP and HAK #ifndef __defined_libdai_clustergraph_h #define __defined_libdai_clustergraph_h #include #include #include #include namespace dai { /// A ClusterGraph is a hypergraph with variables as nodes, and "clusters" (sets of variables) as hyperedges. /** It is implemented as a bipartite graph with variable (Var) nodes and cluster (VarSet) nodes. */ class ClusterGraph { public: /// Stores the neighborhood structure BipartiteGraph G; /// Stores the variables corresponding to the nodes std::vector vars; /// Stores the clusters corresponding to the hyperedges std::vector clusters; /// Shorthand for BipartiteGraph::Neighbor typedef BipartiteGraph::Neighbor Neighbor; /// Shorthand for BipartiteGraph::Edge typedef BipartiteGraph::Edge Edge; public: /// \name Constructors and destructors //@{ /// Default constructor ClusterGraph() : G(), vars(), clusters() {} /// Construct from vector of VarSet 's ClusterGraph( const std::vector & cls ); //@} /// \name Queries //@{ /// Returns a constant reference to the clusters const std::vector & toVector() const { return clusters; } /// Returns number of clusters size_t size() const { return G.nrNodes2(); } /// Returns the index of variable \a n size_t findVar( const Var &n ) const { return find( vars.begin(), vars.end(), n ) - vars.begin(); } /// Returns union of clusters that contain the \a i 'th variable VarSet Delta( size_t i ) const { VarSet result; foreach( const Neighbor &I, G.nb1(i) ) result |= clusters[I]; return result; } /// Returns union of clusters that contain the \a i 'th (except this variable itself) VarSet delta( size_t i ) const { return Delta( i ) / vars[i]; } /// Returns \c true if variables with indices \a i1 and \a i2 are adjacent, i.e., both contained in the same cluster bool adj( size_t i1, size_t i2 ) const { bool result = false; foreach( const Neighbor &I, G.nb1(i1) ) if( find( G.nb2(I).begin(), G.nb2(I).end(), i2 ) != G.nb2(I).end() ) { result = true; break; } return result; } /// Returns \c true if cluster \a I is not contained in a larger cluster bool isMaximal( size_t I ) const { DAI_DEBASSERT( I < G.nrNodes2() ); const VarSet & clI = clusters[I]; bool maximal = true; // The following may not be optimal, since it may repeatedly test the same cluster *J foreach( const Neighbor &i, G.nb2(I) ) { foreach( const Neighbor &J, G.nb1(i) ) if( (J != I) && (clI << clusters[J]) ) { maximal = false; break; } if( !maximal ) break; } return maximal; } //@} /// \name Operations //@{ /// Inserts a cluster (if it does not already exist) void insert( const VarSet &cl ) { if( find( clusters.begin(), clusters.end(), cl ) == clusters.end() ) { clusters.push_back( cl ); // add variables (if necessary) and calculate neighborhood of new cluster std::vector nbs; for( VarSet::const_iterator n = cl.begin(); n != cl.end(); n++ ) { size_t iter = find( vars.begin(), vars.end(), *n ) - vars.begin(); nbs.push_back( iter ); if( iter == vars.size() ) { G.addNode1(); vars.push_back( *n ); } } G.addNode2( nbs.begin(), nbs.end(), nbs.size() ); } } /// Erases all clusters that are not maximal ClusterGraph& eraseNonMaximal() { for( size_t I = 0; I < G.nrNodes2(); ) { if( !isMaximal(I) ) { clusters.erase( clusters.begin() + I ); G.eraseNode2(I); } else I++; } return *this; } /// Erases all clusters that contain the \a i 'th variable ClusterGraph& eraseSubsuming( size_t i ) { while( G.nb1(i).size() ) { clusters.erase( clusters.begin() + G.nb1(i)[0] ); G.eraseNode2( G.nb1(i)[0] ); } return *this; } //@} /// \name Input/Ouput //@{ /// Writes a ClusterGraph to an output stream friend std::ostream & operator << ( std::ostream & os, const ClusterGraph & cl ) { os << cl.toVector(); return os; } //@} /// \name Variable elimination //@{ /// Performs Variable Elimination, only keeping track of the interactions that are created along the way. /** \tparam EliminationChoice should support "size_t operator()( const ClusterGraph &cl, const std::set &remainingVars )" * \param f function object which returns the next variable index to eliminate; for example, a dai::greedyVariableElimination object. * \return A set of elimination "cliques". */ template ClusterGraph VarElim( EliminationChoice f ) const { // Make a copy ClusterGraph cl(*this); cl.eraseNonMaximal(); ClusterGraph result; // Construct set of variable indices std::set varindices; for( size_t i = 0; i < vars.size(); ++i ) varindices.insert( i ); // Do variable elimination while( !varindices.empty() ) { size_t i = f( cl, varindices ); DAI_ASSERT( i < vars.size() ); result.insert( cl.Delta( i ) ); cl.insert( cl.delta( i ) ); cl.eraseSubsuming( i ); cl.eraseNonMaximal(); varindices.erase( i ); } return result; } /// Calculates cost of eliminating the \a i 'th variable. /** The cost is measured as "number of added edges in the adjacency graph", * where the adjacency graph has the variables as its nodes and connects * nodes \a i1 and \a i2 iff \a i1 and \a i2 occur together in some common cluster. * \deprecated Please use dai::eliminationCost_MinFill() instead. */ size_t eliminationCost( size_t i ) const; /// Performs Variable Elimination, only keeping track of the interactions that are created along the way. /** \param ElimSeq The sequence in which to eliminate the variables * \return A set of elimination "cliques" * \deprecated Please use dai::ClusterGraph::VarElim( sequentialVariableElimination( ElimSeq ) ) instead. */ ClusterGraph VarElim( const std::vector &ElimSeq ) const; /// Performs Variable Elimination using the "MinFill" heuristic /** The "MinFill" heuristic greedily minimizes the cost of eliminating a variable, * measured with eliminationCost(). * \return A set of elimination "cliques". * \deprecated Please use dai::ClusterGraph::VarElim( greedyVariableElimination( eliminationCost_MinFill ) ) instead. */ ClusterGraph VarElim_MinFill() const; //@} }; /// Helper object for dai::ClusterGraph::VarElim() /** Chooses the next variable to eliminate by picking them sequentially from a given vector of variables. */ class sequentialVariableElimination { private: /// The variable elimination sequence std::vector seq; /// Counter size_t i; public: /// Construct from vector of variables sequentialVariableElimination( const std::vector s ) : seq(s), i(0) {} /// Returns next variable in sequence size_t operator()( const ClusterGraph &cl, const std::set &/*remainingVars*/ ); }; /// Helper object for dai::ClusterGraph::VarElim() /** Chooses the next variable to eliminate greedily by taking the one that minimizes * a given heuristic cost function. */ class greedyVariableElimination { public: /// Type of cost functions to be used for greedy variable elimination typedef size_t (*eliminationCostFunction)(const ClusterGraph &, size_t); private: /// Pointer to the cost function used eliminationCostFunction heuristic; public: /// Construct from cost function /** \note Examples of cost functions are eliminationCost_MinFill() and eliminationCost_WeightedMinFill(). */ greedyVariableElimination( eliminationCostFunction h ) : heuristic(h) {} /// Returns the best variable from \a remainingVars to eliminate in the cluster graph \a cl by greedily minimizing the cost function. /** This function calculates the cost for eliminating each variable in \a remaingVars and returns the variable which has lowest cost. */ size_t operator()( const ClusterGraph &cl, const std::set &remainingVars ); }; /// Calculates cost of eliminating the \a i 'th variable from cluster graph \a cl according to the "MinNeighbors" criterion. /** The cost is measured as "number of neigboring nodes in the current adjacency graph", * where the adjacency graph has the variables as its nodes and connects * nodes \a i1 and \a i2 iff \a i1 and \a i2 occur together in some common cluster. */ size_t eliminationCost_MinNeighbors( const ClusterGraph &cl, size_t i ); /// Calculates cost of eliminating the \a i 'th variable from cluster graph \a cl according to the "MinWeight" criterion. /** The cost is measured as "product of weights of neighboring nodes in the current adjacency graph", * where the adjacency graph has the variables as its nodes and connects * nodes \a i1 and \a i2 iff \a i1 and \a i2 occur together in some common cluster. * The weight of a node is the number of states of the corresponding variable. */ size_t eliminationCost_MinWeight( const ClusterGraph &cl, size_t i ); /// Calculates cost of eliminating the \a i 'th variable from cluster graph \a cl according to the "MinFill" criterion. /** The cost is measured as "number of added edges in the adjacency graph", * where the adjacency graph has the variables as its nodes and connects * nodes \a i1 and \a i2 iff \a i1 and \a i2 occur together in some common cluster. */ size_t eliminationCost_MinFill( const ClusterGraph &cl, size_t i ); /// Calculates cost of eliminating the \a i 'th variable from cluster graph \a cl according to the "WeightedMinFill" criterion. /** The cost is measured as "total weight of added edges in the adjacency graph", * where the adjacency graph has the variables as its nodes and connects * nodes \a i1 and \a i2 iff \a i1 and \a i2 occur together in some common cluster. * The weight of an edge is the product of the number of states of the variables corresponding with its nodes. */ size_t eliminationCost_WeightedMinFill( const ClusterGraph &cl, size_t i ); } // end of namespace dai #endif libDAI-0.2.4/include/dai/gibbs.h0000644000263000017630000001134011334764775015114 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2008 Frederik Eaton [frederik at ofb dot net] */ /// \file /// \brief Defines class Gibbs, which implements Gibbs sampling #ifndef __defined_libdai_gibbs_h #define __defined_libdai_gibbs_h #include #include #include namespace dai { /// Approximate inference algorithm "Gibbs sampling" /** \author Frederik Eaton */ class Gibbs : public DAIAlgFG { private: /// Type used to store the counts of various states typedef std::vector _count_t; /// Type used to store the joint state of all variables typedef std::vector _state_t; /// Number of samples counted so far (excluding burn-in) size_t _sample_count; /// State counts for each variable std::vector<_count_t> _var_counts; /// State counts for each factor std::vector<_count_t> _factor_counts; /// Current joint state of all variables _state_t _state; public: /// Parameters for Gibbs struct Properties { /// Total number of iterations size_t iters; /// Number of "burn-in" iterations size_t burnin; /// Verbosity (amount of output sent to stderr) size_t verbose; } props; /// Name of this inference algorithm static const char *Name; public: /// Default constructor Gibbs() : DAIAlgFG(), _sample_count(0), _var_counts(), _factor_counts(), _state() {} /// Construct from FactorGraph \a fg and PropertySet \a opts /** \param opts Parameters @see Properties */ Gibbs( const FactorGraph &fg, const PropertySet &opts ) : DAIAlgFG(fg), _sample_count(0), _var_counts(), _factor_counts(), _state() { setProperties( opts ); construct(); } /// \name General InfAlg interface //@{ virtual Gibbs* clone() const { return new Gibbs(*this); } virtual std::string identify() const { return std::string(Name) + printProperties(); } virtual Factor belief( const Var &v ) const { return beliefV( findVar( v ) ); } virtual Factor belief( const VarSet &vs ) const; virtual Factor beliefV( size_t i ) const; virtual Factor beliefF( size_t I ) const; virtual std::vector beliefs() const; virtual Real logZ() const { DAI_THROW(NOT_IMPLEMENTED); return 0.0; } virtual void init(); virtual void init( const VarSet &/*ns*/ ) { init(); } virtual Real run(); virtual Real maxDiff() const { DAI_THROW(NOT_IMPLEMENTED); return 0.0; } virtual size_t Iterations() const { return props.iters; } virtual void setProperties( const PropertySet &opts ); virtual PropertySet getProperties() const; virtual std::string printProperties() const; //@} /// \name Additional interface specific for Gibbs //@{ /// Draw the current joint state of all variables from a uniform random distribution void randomizeState(); /// Return reference to current state of all variables std::vector& state() { return _state; } /// Return constant reference to current state of all variables const std::vector& state() const { return _state; } //@} private: /// Helper function for constructors void construct(); /// Updates all counts (_sample_count, _var_counts, _factor_counts) based on current state void updateCounts(); /// Calculate conditional distribution of variable \a i, given the current state Prob getVarDist( size_t i ); /// Draw state of variable \a i randomly from its conditional distribution and update the current state void resampleVar( size_t i ); /// Calculates linear index into factor \a I corresponding to the current state size_t getFactorEntry( size_t I ); /// Calculates the differences between linear indices into factor \a I corresponding with a state change of variable \a i size_t getFactorEntryDiff( size_t I, size_t i ); }; /// Runs Gibbs sampling for \a iters iterations (of which \a burnin for burn-in) on FactorGraph \a fg, and returns the resulting state /** \relates Gibbs */ std::vector getGibbsState( const FactorGraph &fg, size_t iters ); } // end of namespace dai /** \example example_sprinkler_gibbs.cpp * This example shows how to use the Gibbs class. */ #endif libDAI-0.2.4/include/dai/weightedgraph.h0000644000263000017630000001667611334764775016671 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /** \file * \brief Defines some utility functions for (weighted) undirected graphs, trees and rooted trees. * \todo Improve general support for graphs and trees. */ #ifndef __defined_libdai_weightedgraph_h #define __defined_libdai_weightedgraph_h #include #include #include #include #include #include // Work-around for bug in boost graph library #include #include namespace dai { /// Represents a directed edge class DEdge { public: /// First node index (source of edge) size_t n1; /// Second node index (sink of edge) size_t n2; /// Default constructor DEdge() {} /// Constructs a directed edge pointing from \a m1 to \a m2 DEdge( size_t m1, size_t m2 ) : n1(m1), n2(m2) {} /// Tests for equality bool operator==( const DEdge &x ) const { return ((n1 == x.n1) && (n2 == x.n2)); } /// Tests for inequality bool operator!=( const DEdge &x ) const { return !(*this == x); } /// Smaller-than operator (performs lexicographical comparison) bool operator<( const DEdge &x ) const { return( (n1 < x.n1) || ((n1 == x.n1) && (n2 < x.n2)) ); } /// Writes a directed edge to an output stream friend std::ostream & operator << (std::ostream & os, const DEdge & e) { os << "(" << e.n1 << "," << e.n2 << ")"; return os; } }; /// Represents an undirected edge class UEdge { public: /// First node index union { size_t n1; size_t first; /// alias }; /// Second node index union { size_t n2; size_t second; /// alias }; /// Default constructor UEdge() {} /// Constructs an undirected edge between \a m1 and \a m2 UEdge( size_t m1, size_t m2 ) : n1(m1), n2(m2) {} /// Construct from DEdge UEdge( const DEdge &e ) : n1(e.n1), n2(e.n2) {} /// Tests for inequality (disregarding the ordering of the nodes) bool operator==( const UEdge &x ) { return ((n1 == x.n1) && (n2 == x.n2)) || ((n1 == x.n2) && (n2 == x.n1)); } /// Smaller-than operator bool operator<( const UEdge &x ) const { size_t s = n1, l = n2; if( s > l ) std::swap( s, l ); size_t xs = x.n1, xl = x.n2; if( xs > xl ) std::swap( xs, xl ); return( (s < xs) || ((s == xs) && (l < xl)) ); } /// Writes an undirected edge to an output stream friend std::ostream & operator << (std::ostream & os, const UEdge & e) { if( e.n1 < e.n2 ) os << "{" << e.n1 << "," << e.n2 << "}"; else os << "{" << e.n2 << "," << e.n1 << "}"; return os; } }; /// Represents an undirected graph, implemented as a std::set of undirected edges class GraphEL : public std::set { public: /// Default constructor GraphEL() {} /// Construct from range of objects that can be cast to DEdge template GraphEL( InputIterator begin, InputIterator end ) { insert( begin, end ); } }; /// \deprecated Please use dai::GraphEL instead. typedef GraphEL Graph; /// Represents an undirected weighted graph, with weights of type \a T, implemented as a std::map mapping undirected edges to weights template class WeightedGraph : public std::map {}; /// Represents a rooted tree, implemented as a vector of directed edges /** By convention, the edges are stored such that they point away from * the root and such that edges nearer to the root come before edges * farther away from the root. */ class RootedTree : public std::vector { public: /// Default constructor RootedTree() {} /// Constructs a rooted tree from a tree and a root /** \pre T has no cycles and contains node \a Root */ RootedTree( const GraphEL &T, size_t Root ); }; /// Uses Prim's algorithm to construct a minimal spanning tree from the (positively) weighted graph \a G. /** Uses implementation in Boost Graph Library. */ template RootedTree MinSpanningTreePrims( const WeightedGraph &G ) { RootedTree result; if( G.size() > 0 ) { using namespace boost; using namespace std; typedef adjacency_list< vecS, vecS, undirectedS, property, property > boostGraph; typedef pair E; set nodes; vector edges; vector weights; edges.reserve( G.size() ); weights.reserve( G.size() ); for( typename WeightedGraph::const_iterator e = G.begin(); e != G.end(); e++ ) { weights.push_back( e->second ); edges.push_back( E( e->first.n1, e->first.n2 ) ); nodes.insert( e->first.n1 ); nodes.insert( e->first.n2 ); } boostGraph g( edges.begin(), edges.end(), weights.begin(), nodes.size() ); vector< graph_traits< boostGraph >::vertex_descriptor > p( num_vertices(g) ); prim_minimum_spanning_tree( g, &(p[0]) ); // Store tree edges in result GraphEL tree; size_t root = 0; for( size_t i = 0; i != p.size(); i++ ) if( p[i] != i ) tree.insert( UEdge( p[i], i ) ); else root = i; // Order them to obtain a rooted tree result = RootedTree( tree, root ); } return result; } /// Use Prim's algorithm to construct a maximal spanning tree from the (positively) weighted graph \a G. /** Uses implementation in Boost Graph Library. */ template RootedTree MaxSpanningTreePrims( const WeightedGraph &G ) { if( G.size() == 0 ) return RootedTree(); else { T maxweight = G.begin()->second; for( typename WeightedGraph::const_iterator it = G.begin(); it != G.end(); it++ ) if( it->second > maxweight ) maxweight = it->second; // make a copy of the graph WeightedGraph gr( G ); // invoke MinSpanningTreePrims with negative weights // (which have to be shifted to satisfy positivity criterion) for( typename WeightedGraph::iterator it = gr.begin(); it != gr.end(); it++ ) it->second = maxweight - it->second; return MinSpanningTreePrims( gr ); } } /// Constructs a random undirected graph of \a N nodes, where each node has connectivity \a d /** Algorithm 1 in [\ref StW99]. * Draws a random graph of size \a N and uniform degree \a d * from an almost uniform probability distribution over these graphs * (which becomes uniform in the limit that \a d is small and \a N goes * to infinity). */ GraphEL RandomDRegularGraph( size_t N, size_t d ); } // end of namespace dai #endif libDAI-0.2.4/include/dai/bp_dual.h0000644000263000017630000001264611334764775015446 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Frederik Eaton [frederik at ofb dot net] */ /// \file /// \brief Defines class BP_dual, which is used primarily by BBP. /// \idea BP_dual replicates a large part of the functionality of BP; would it not be more efficient to adapt BP instead? /// \author Frederik Eaton #ifndef __defined_libdai_bp_dual_h #define __defined_libdai_bp_dual_h #include #include #include namespace dai { /// Calculates both types of BP messages and their normalizers from an InfAlg. /** BP_dual calculates "dual" versions of BP messages (both messages from factors * to variables and messages from variables to factors), and normalizers, given an InfAlg. * These are computed from the variable and factor beliefs of the InfAlg. * This class is used primarily by BBP. * * \author Frederik Eaton */ class BP_dual { protected: /// Convenience label for storing edge properties template struct _edges_t : public std::vector > {}; /// Groups together the data structures for storing the two types of messages and their normalizers struct messages { /// Unnormalized variable->factor messages _edges_t n; /// Normalizers of variable->factor messages _edges_t Zn; /// Unnormalized Factor->variable messages _edges_t m; /// Normalizers of factor->variable messages _edges_t Zm; }; /// Stores all messages messages _msgs; /// Groups together the data structures for storing the two types of beliefs and their normalizers struct beliefs { /// Unnormalized variable beliefs std::vector b1; /// Normalizers of variable beliefs std::vector Zb1; /// Unnormalized factor beliefs std::vector b2; /// Normalizers of factor beliefs std::vector Zb2; }; /// Stores all beliefs beliefs _beliefs; /// Pointer to the InfAlg object const InfAlg *_ia; /// Does all necessary preprocessing void init(); /// Allocates space for \a _msgs void regenerateMessages(); /// Allocates space for \a _beliefs void regenerateBeliefs(); /// Calculate all messages from InfAlg beliefs void calcMessages(); /// Update factor->variable message (\a i -> \a I) void calcNewM(size_t i, size_t _I); /// Update variable->factor message (\a I -> \a i) void calcNewN(size_t i, size_t _I); /// Calculate all variable and factor beliefs from messages void calcBeliefs(); /// Calculate belief of variable \a i void calcBeliefV(size_t i); /// Calculate belief of factor \a I void calcBeliefF(size_t I); public: /// Construct BP_dual object from (converged) InfAlg object's beliefs and factors. /** \warning A pointer to the the InfAlg object is stored, * so the object must not be destroyed before the BP_dual is destroyed. */ BP_dual( const InfAlg *ia ) : _ia(ia) { init(); } /// Returns the underlying FactorGraph const FactorGraph& fg() const { return _ia->fg(); } /// Returns reference to factor->variable message (\a I -> \a i) Prob & msgM( size_t i, size_t _I ) { return _msgs.m[i][_I]; } /// Returns constant reference to factor->variable message (\a I -> \a i) const Prob & msgM( size_t i, size_t _I ) const { return _msgs.m[i][_I]; } /// Returns reference to variable -> factor message (\a i -> \a I) Prob & msgN( size_t i, size_t _I ) { return _msgs.n[i][_I]; } /// Returns constant reference to variable -> factor message (\a i -> \a I) const Prob & msgN( size_t i, size_t _I ) const { return _msgs.n[i][_I]; } /// Returns reference to normalizer for factor->variable message (\a I -> \a i) Real & zM( size_t i, size_t _I ) { return _msgs.Zm[i][_I]; } /// Returns constant reference to normalizer for factor->variable message (\a I -> \a i) const Real & zM( size_t i, size_t _I ) const { return _msgs.Zm[i][_I]; } /// Returns reference to normalizer for variable -> factor message (\a i -> \a I) Real & zN( size_t i, size_t _I ) { return _msgs.Zn[i][_I]; } /// Returns constant reference to normalizer for variable -> factor message (\a i -> \a I) const Real & zN( size_t i, size_t _I ) const { return _msgs.Zn[i][_I]; } /// Returns belief of variable \a i Factor beliefV( size_t i ) const { return Factor( _ia->fg().var(i), _beliefs.b1[i] ); } /// Returns belief of factor \a I Factor beliefF( size_t I ) const { return Factor( _ia->fg().factor(I).vars(), _beliefs.b2[I] ); } /// Returns normalizer for belief of variable \a i Real beliefVZ( size_t i ) const { return _beliefs.Zb1[i]; } /// Returns normalizer for belief of factor \a I Real beliefFZ( size_t I ) const { return _beliefs.Zb2[I]; } }; } // end of namespace dai #endif libDAI-0.2.4/include/dai/emalg.h0000644000263000017630000004251011334764775015116 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Charles Vaske [cvaske at soe dot ucsc dot edu] * Copyright (C) 2009 University of California, Santa Cruz */ #ifndef __defined_libdai_emalg_h #define __defined_libdai_emalg_h #include #include #include #include #include #include #include /// \file /// \brief Defines classes related to Expectation Maximization (EMAlg, ParameterEstimation, CondProbEstimation and SharedParameters) /// \todo Implement parameter estimation for undirected models / factor graphs. namespace dai { /// Base class for parameter estimation methods. /** This class defines the general interface of parameter estimation methods. * * Implementations of this interface (see e.g. CondProbEstimation) should * register a factory function (virtual constructor) via the static * registerMethod() function. * This factory function should return a pointer to a newly constructed * object, whose type is a subclass of ParameterEstimation, and gets as * input a PropertySet of parameters. After a subclass has been registered, * instances of it can be constructed using the construct() method. * * Implementations are responsible for collecting data from a probability * vector passed to it from a SharedParameters container object. * * The default registry only contains CondProbEstimation, named * "CondProbEstimation". * * \author Charles Vaske */ class ParameterEstimation { public: /// Type of pointer to factory function. typedef ParameterEstimation* (*ParamEstFactory)( const PropertySet& ); /// Virtual destructor for deleting pointers to derived classes. virtual ~ParameterEstimation() {} /// Virtual copy constructor. virtual ParameterEstimation* clone() const = 0; /// General factory method that constructs the desired ParameterEstimation subclass /** \param method Name of the subclass that should be constructed; * \param p Parameters passed to constructor of subclass. * \note \a method should either be in the default registry or should be registered first using registerMethod(). * \throw UNKNOWN_PARAMETER_ESTIMATION_METHOD if the requested \a method is not registered. */ static ParameterEstimation* construct( const std::string &method, const PropertySet &p ); /// Register a subclass so that it can be used with construct(). static void registerMethod( const std::string &method, const ParamEstFactory &f ) { if( _registry == NULL ) loadDefaultRegistry(); (*_registry)[method] = f; } /// Estimate the factor using the accumulated sufficient statistics and reset. virtual Prob estimate() = 0; /// Accumulate the sufficient statistics for \a p. virtual void addSufficientStatistics( const Prob &p ) = 0; /// Returns the size of the Prob that should be passed to addSufficientStatistics. virtual size_t probSize() const = 0; private: /// A static registry containing all methods registered so far. static std::map *_registry; /// Registers default ParameterEstimation subclasses (currently, only CondProbEstimation). static void loadDefaultRegistry(); }; /// Estimates the parameters of a conditional probability table, using pseudocounts. /** \author Charles Vaske */ class CondProbEstimation : private ParameterEstimation { private: /// Number of states of the variable of interest size_t _target_dim; /// Current pseudocounts Prob _stats; /// Initial pseudocounts Prob _initial_stats; public: /// Constructor /** For a conditional probability \f$ P( X | Y ) \f$, * \param target_dimension should equal \f$ | X | \f$ * \param pseudocounts are the initial pseudocounts, of length \f$ |X| \cdot |Y| \f$ */ CondProbEstimation( size_t target_dimension, const Prob &pseudocounts ); /// Virtual constructor, using a PropertySet. /** Some keys in the PropertySet are required. * For a conditional probability \f$ P( X | Y ) \f$, * - \a target_dimension should be equal to \f$ | X | \f$ * - \a total_dimension should be equal to \f$ |X| \cdot |Y| \f$ * * An optional key is: * - \a pseudo_count which specifies the initial counts (defaults to 1) */ static ParameterEstimation* factory( const PropertySet &p ); /// Virtual copy constructor virtual ParameterEstimation* clone() const { return new CondProbEstimation( _target_dim, _initial_stats ); } /// Virtual destructor virtual ~CondProbEstimation() {} /// Returns an estimate of the conditional probability distribution. /** The format of the resulting Prob keeps all the values for * \f$ P(X | Y=y) \f$ in sequential order in the array. */ virtual Prob estimate(); /// Accumulate sufficient statistics from the expectations in \a p virtual void addSufficientStatistics( const Prob &p ); /// Returns the required size for arguments to addSufficientStatistics(). virtual size_t probSize() const { return _stats.size(); } }; /// Represents a single factor or set of factors whose parameters should be estimated. /** To ensure that parameters can be shared between different factors during * EM learning, each factor's values are reordered to match a desired variable * ordering. The ordering of the variables in a factor may therefore differ * from the canonical ordering used in libDAI. The SharedParameters * class combines one or more factors (together with the specified orderings * of the variables) with a ParameterEstimation object, taking care of the * necessary permutations of the factor entries / parameters. * * \author Charles Vaske */ class SharedParameters { public: /// Convenience label for an index of a factor in a FactorGraph. typedef size_t FactorIndex; /// Convenience label for a grouping of factor orientations. typedef std::map > FactorOrientations; private: /// Maps factor indices to the corresponding VarSets std::map _varsets; /// Maps factor indices to the corresponding Permute objects that permute the canonical ordering into the desired ordering std::map _perms; /// Maps factor indices to the corresponding desired variable orderings FactorOrientations _varorders; /// Parameter estimation method to be used ParameterEstimation *_estimation; /// Indicates whether \c *this gets ownership of _estimation bool _ownEstimation; /// Calculates the permutation that permutes the canonical ordering into the desired ordering /** \param varOrder Desired ordering of variables * \param outVS Contains variables in \a varOrder represented as a VarSet * \return Permute object for permuting variables in varOrder from the canonical libDAI ordering into the desired ordering */ static Permute calculatePermutation( const std::vector &varOrder, VarSet &outVS ); /// Initializes _varsets and _perms from _varorders and checks whether their state spaces correspond with _estimation.probSize() void setPermsAndVarSetsFromVarOrders(); public: /// Constructor /** \param varorders all the factor orientations for this parameter * \param estimation a pointer to the parameter estimation method * \param ownPE whether the constructed object gets ownership of \a estimation */ SharedParameters( const FactorOrientations &varorders, ParameterEstimation *estimation, bool ownPE=false ); /// Construct a SharedParameters object from an input stream \a is and a factor graph \a fg /** \see \ref fileformats-emalg-sharedparameters * \throw INVALID_EMALG_FILE if the input stream is not valid */ SharedParameters( std::istream &is, const FactorGraph &fg ); /// Copy constructor SharedParameters( const SharedParameters &sp ) : _varsets(sp._varsets), _perms(sp._perms), _varorders(sp._varorders), _estimation(sp._estimation), _ownEstimation(sp._ownEstimation) { // If sp owns its _estimation object, we should clone it instead of copying the pointer if( _ownEstimation ) _estimation = _estimation->clone(); } /// Destructor ~SharedParameters() { // If we own the _estimation object, we should delete it now if( _ownEstimation ) delete _estimation; } /// Collect the sufficient statistics from expected values (beliefs) according to \a alg /** For each of the relevant factors (that shares the parameters we are interested in), * the corresponding belief according to \a alg is obtained and its entries are permuted * such that their ordering corresponds with the shared parameters that we are estimating. * Then, the parameter estimation subclass method addSufficientStatistics() is called with * this vector of expected values of the parameters as input. */ void collectSufficientStatistics( InfAlg &alg ); /// Estimate and set the shared parameters /** Based on the sufficient statistics collected so far, the shared parameters are estimated * using the parameter estimation subclass method estimate(). Then, each of the relevant * factors in \a fg (that shares the parameters we are interested in) is set according * to those parameters (permuting the parameters accordingly). */ void setParameters( FactorGraph &fg ); }; /// A MaximizationStep groups together several parameter estimation tasks (SharedParameters objects) into a single unit. /** \author Charles Vaske */ class MaximizationStep { private: /// Vector of parameter estimation tasks of which this maximization step consists std::vector _params; public: /// Default constructor MaximizationStep() : _params() {} /// Construct MaximizationStep from a vector of parameter estimation tasks MaximizationStep( std::vector &maximizations ) : _params(maximizations) {} /// Constructor from an input stream and a corresponding factor graph /** \see \ref fileformats-emalg-maximizationstep */ MaximizationStep( std::istream &is, const FactorGraph &fg_varlookup ); /// Collect the beliefs from this InfAlg as expectations for the next Maximization step void addExpectations( InfAlg &alg ); /// Using all of the currently added expectations, make new factors with maximized parameters and set them in the FactorGraph. void maximize( FactorGraph &fg ); /// \name Iterator interface //@{ /// Iterator over the parameter estimation tasks typedef std::vector::iterator iterator; /// Constant iterator over the parameter estimation tasks typedef std::vector::const_iterator const_iterator; /// Returns iterator that points to the first parameter estimation task iterator begin() { return _params.begin(); } /// Returns constant iterator that points to the first parameter estimation task const_iterator begin() const { return _params.begin(); } /// Returns iterator that points beyond the last parameter estimation task iterator end() { return _params.end(); } /// Returns constant iterator that points beyond the last parameter estimation task const_iterator end() const { return _params.end(); } //@} }; /// EMAlg performs Expectation Maximization to learn factor parameters. /** This requires specifying: * - Evidence (instances of observations from the graphical model), * - InfAlg for performing the E-step (which includes the factor graph), * - a vector of MaximizationStep 's steps to be performed. * * This implementation can perform incremental EM by using multiple * MaximizationSteps. An expectation step is performed between execution * of each MaximizationStep. A call to iterate() will cycle through all * MaximizationStep 's. A call to run() will call iterate() until the * termination criteria have been met. * * Having multiple and separate maximization steps allows for maximizing some * parameters, performing another E-step, and then maximizing separate * parameters, which may result in faster convergence in some cases. * * \author Charles Vaske */ class EMAlg { private: /// All the data samples used during learning const Evidence &_evidence; /// How to do the expectation step InfAlg &_estep; /// The maximization steps to take std::vector _msteps; /// Number of iterations done size_t _iters; /// History of likelihoods std::vector _lastLogZ; /// Maximum number of iterations size_t _max_iters; /// Convergence tolerance Real _log_z_tol; public: /// Key for setting maximum iterations static const std::string MAX_ITERS_KEY; /// Default maximum iterations static const size_t MAX_ITERS_DEFAULT; /// Key for setting likelihood termination condition static const std::string LOG_Z_TOL_KEY; /// Default likelihood tolerance static const Real LOG_Z_TOL_DEFAULT; /// Construct an EMAlg from several objects /** \param evidence Specifies the observed evidence * \param estep Inference algorithm to be used for the E-step * \param msteps Vector of maximization steps, each of which is a group of parameter estimation tasks * \param termconditions Termination conditions @see setTermConditions() */ EMAlg( const Evidence &evidence, InfAlg &estep, std::vector &msteps, const PropertySet &termconditions ) : _evidence(evidence), _estep(estep), _msteps(msteps), _iters(0), _lastLogZ(), _max_iters(MAX_ITERS_DEFAULT), _log_z_tol(LOG_Z_TOL_DEFAULT) { setTermConditions( termconditions ); } /// Construct an EMAlg from Evidence \a evidence, an InfAlg \a estep, and an input stream \a mstep_file /** \see \ref fileformats-emalg */ EMAlg( const Evidence &evidence, InfAlg &estep, std::istream &mstep_file ); /// Change the conditions for termination /** There are two possible parameters in the PropertySet \a p: * - \a max_iters maximum number of iterations * - \a log_z_tol critical proportion of increase in logZ * * \see hasSatisifiedTermConditions() */ void setTermConditions( const PropertySet &p ); /// Determine if the termination conditions have been met. /** There are two sufficient termination conditions: * -# the maximum number of iterations has been performed * -# the ratio of logZ increase over previous logZ is less than the * tolerance, i.e., * \f$ \frac{\log(Z_t) - \log(Z_{t-1})}{| \log(Z_{t-1}) | } < \mathrm{tol} \f$. */ bool hasSatisfiedTermConditions() const; /// Return the last calculated log likelihood Real logZ() const { return _lastLogZ.back(); } /// Returns number of iterations done so far size_t Iterations() const { return _iters; } /// Get the E-step method used const InfAlg& eStep() const { return _estep; } /// Iterate once over all maximization steps /** \return Log-likelihood after iteration */ Real iterate(); /// Iterate over a single MaximizationStep Real iterate( MaximizationStep &mstep ); /// Iterate until termination conditions are satisfied void run(); /// \name Iterator interface //@{ /// Iterator over the maximization steps typedef std::vector::iterator s_iterator; /// Constant iterator over the maximization steps typedef std::vector::const_iterator const_s_iterator; /// Returns iterator that points to the first maximization step s_iterator s_begin() { return _msteps.begin(); } /// Returns constant iterator that points to the first maximization step const_s_iterator s_begin() const { return _msteps.begin(); } /// Returns iterator that points beyond the last maximization step s_iterator s_end() { return _msteps.end(); } /// Returns constant iterator that points beyond the last maximization step const_s_iterator s_end() const { return _msteps.end(); } //@} }; } // end of namespace dai /** \example example_sprinkler_em.cpp * This example shows how to use the EMAlg class. */ #endif libDAI-0.2.4/include/dai/exceptions.h0000644000263000017630000001072611334764775016216 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines the Exception class and macros for throwing exceptions and doing assertions #ifndef __defined_libdai_exceptions_h #define __defined_libdai_exceptions_h #include #include #include #include /// Used by DAI_THROW #define DAI_QUOTE(x) #x /// Used by DAI_THROW #define DAI_TOSTRING(x) DAI_QUOTE(x) /// Macro that simplifies throwing an exception with a useful default error message. /** The error message consists of a description of the exception, the source * code file and line number where the exception has been thrown. * \param cod Corresponds to one of the enum values of dai::Exception::Code * * \par Example: * \code * DAI_THROW(NOT_IMPLEMENTED); * \endcode */ #define DAI_THROW(cod) throw dai::Exception(dai::Exception::cod, std::string(__FILE__ ", line " DAI_TOSTRING(__LINE__))) /// Macro that simplifies throwing an exception with a user-defined error message. /** \param cod Corresponds to one of the enum values of dai::Exception::Code * \param msg Detailed error message that will be written to std::cerr. * * \par Example: * \code * DAI_THROWE(NOT_IMPLEMENTED,"Detailed error message"); * \endcode */ #define DAI_THROWE(cod,msg) throw dai::Exception(dai::Exception::cod, std::string(__FILE__ ", line " DAI_TOSTRING(__LINE__)), msg) /// Assertion mechanism, similar to the standard assert() macro. It is always active, even if NDEBUG is defined #define DAI_ASSERT(condition) ((condition) ? ((void)0) : DAI_THROWE(ASSERTION_FAILED, std::string("Assertion \"" #condition "\" failed"))) // Assertion only if DAI_DEBUG is defined #ifdef DAI_DEBUG /// Assertion mechanism similar to DAI_ASSERT which is only active if DAI_DEBUG is defined #define DAI_DEBASSERT(x) do {DAI_ASSERT(x);} while(0) #else #define DAI_DEBASSERT(x) do {} while(0) #endif namespace dai { /// Error handling in libDAI is done by throwing an instance of the Exception class. /** The Exception class inherits from std::runtime_error. It defines several types of exceptions * and corresponding error messages. The recommended way to throw an instance of the Exception * class is by using the #DAI_THROW or #DAI_THROWE macros. */ class Exception : public std::runtime_error { public: /// Enumeration of exceptions used in libDAI enum Code {NOT_IMPLEMENTED, ASSERTION_FAILED, IMPOSSIBLE_TYPECAST, OBJECT_NOT_FOUND, BELIEF_NOT_AVAILABLE, UNKNOWN_ENUM_VALUE, UNKNOWN_DAI_ALGORITHM, UNKNOWN_PARAMETER_ESTIMATION_METHOD, UNKNOWN_PROPERTY_TYPE, UNKNOWN_PROPERTY, MALFORMED_PROPERTY, NOT_ALL_PROPERTIES_SPECIFIED, INVALID_ALIAS, CANNOT_READ_FILE, CANNOT_WRITE_FILE, INVALID_FACTORGRAPH_FILE, INVALID_EVIDENCE_FILE, INVALID_EMALG_FILE, NOT_NORMALIZABLE, MULTIPLE_UNDO, FACTORGRAPH_NOT_CONNECTED, INTERNAL_ERROR, RUNTIME_ERROR, NUM_ERRORS}; // NUM_ERRORS should be the last entry /// Constructor Exception( Code _code, const std::string& msg="", const std::string& detailedMsg="" ) : std::runtime_error(ErrorStrings[_code] + " [" + msg + "]"), errorcode(_code) { if( !detailedMsg.empty() ) std::cerr << "ERROR: " << detailedMsg << std::endl; } /// Returns error code of this exception Code code() const { return errorcode; } /// Returns error message corresponding to an error code const std::string &message( const Code c ) const { return ErrorStrings[c]; } private: /// Contains the error code of this exception Code errorcode; /// Error messages corresponding to the exceptions enumerated above static std::string ErrorStrings[NUM_ERRORS]; }; } #endif libDAI-0.2.4/include/dai/alldai.h0000644000263000017630000001160111334764775015254 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /** \file * \brief Main libDAI header file. It \#includes all other libDAI headers. * * \todo Replace VarSets by SmallSet where appropriate, in order to minimize the use of FactorGraph::findVar(). * * \todo Implement routines for UAI probabilistic inference evaluation data * * \todo Improve SWIG interfaces and merge their build process with the main build process */ #ifndef __defined_libdai_alldai_h #define __defined_libdai_alldai_h #include #include #include #include #include #include #ifdef DAI_WITH_BP #include #endif #ifdef DAI_WITH_FBP #include #endif #ifdef DAI_WITH_TRWBP #include #endif #ifdef DAI_WITH_MF #include #endif #ifdef DAI_WITH_HAK #include #endif #ifdef DAI_WITH_LC #include #endif #ifdef DAI_WITH_TREEEP #include #endif #ifdef DAI_WITH_JTREE #include #endif #ifdef DAI_WITH_MR #include #endif #ifdef DAI_WITH_GIBBS #include #endif #ifdef DAI_WITH_CBP #include #endif /// Namespace for libDAI namespace dai { /// Constructs a new inference algorithm. /** \param name The name of the inference algorithm (should be one of the names in DAINames). * \param fg The FactorGraph that the algorithm should be applied to. * \param opts A PropertySet specifying the options for the algorithm. * \return Returns a pointer to the new InfAlg object; it is the responsibility of the caller to delete it later. * \throw UNKNOWN_DAI_ALGORITHM if the requested name is not known/compiled in. */ InfAlg *newInfAlg( const std::string &name, const FactorGraph &fg, const PropertySet &opts ); /// Constructs a new inference algorithm. /** \param nameOpts The name and options of the inference algorithm (should be in the format "name[key1=val1,key2=val2,...,keyn=valn]"). * \param fg The FactorGraph that the algorithm should be applied to. * \return Returns a pointer to the new InfAlg object; it is the responsibility of the caller to delete it later. * \throw UNKNOWN_DAI_ALGORITHM if the requested name is not known/compiled in. */ InfAlg *newInfAlgFromString( const std::string &nameOpts, const FactorGraph &fg ); /// Constructs a new inference algorithm. /** \param aliases Maps names to strings in the format "name[key1=val1,key2=val2,...,keyn=valn]"; if not empty, alias substitution * will be performed when parsing \a nameOpts by invoking parseNameProperties(const std::string &,const std::map &) * \see newInfAlgFromString(const std::string &, const FactorGraph &) */ InfAlg *newInfAlgFromString( const std::string &nameOpts, const FactorGraph &fg, const std::map &aliases ); /// Extracts the name and property set from a string \a s in the format "name[key1=val1,key2=val2,...]" or "name" std::pair parseNameProperties( const std::string &s ); /// Extracts the name and property set from a string \a s in the format "name[key1=val1,key2=val2,...]" or "name", performing alias substitution /** Alias substitution is performed as follows: as long as name appears as a key in \a aliases, * it is substituted by its value. Properties in \a s override those of the alias (in case of * recursion, the "outer" properties override those of the "inner" aliases). */ std::pair parseNameProperties( const std::string &s, const std::map &aliases ); /// Reads aliases from file named \a filename /** \param filename Name of the alias file * \return A map that maps aliases to the strings they should be substituted with. * \see \ref fileformats-aliases */ std::map readAliasesFile( const std::string &filename ); /// Contains the names of all inference algorithms compiled into libDAI. static const char* DAINames[] = { ExactInf::Name, #ifdef DAI_WITH_BP BP::Name, #endif #ifdef DAI_WITH_FBP FBP::Name, #endif #ifdef DAI_WITH_TRWBP TRWBP::Name, #endif #ifdef DAI_WITH_MF MF::Name, #endif #ifdef DAI_WITH_HAK HAK::Name, #endif #ifdef DAI_WITH_LC LC::Name, #endif #ifdef DAI_WITH_TREEEP TreeEP::Name, #endif #ifdef DAI_WITH_JTREE JTree::Name, #endif #ifdef DAI_WITH_MR MR::Name, #endif #ifdef DAI_WITH_GIBBS Gibbs::Name, #endif #ifdef DAI_WITH_CBP CBP::Name, #endif "" }; } // end of namespace dai #endif libDAI-0.2.4/include/dai/doc.h0000644000263000017630000011461411334764775014603 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2008-2010 Joris Mooij [joris dot mooij at libdai dot org] */ /** \file * \brief Contains additional doxygen documentation * * \idea Adapt (part of the) guidelines in http://www.boost.org/development/requirements.html#Design_and_Programming * * \idea Use "gcc -MM" to generate dependencies for targets: http://make.paulandlesley.org/autodep.html * * \idea Disentangle structures. In particular, ensure that graphical properties are not * entangled with probabilistic properties. For example, a FactorGraph contains several components: * - a BipartiteGraph * - an array of variable labels * - an array of variable state space sizes * - an array of pointers to factor value vectors * In this way, each factor could be implemented differently, e.g., we could have * some sparse factors, some noisy-OR factors, some dense factors, some arbitrary * precision factors, etcetera. * * \idea Use boost::uBLAS framework to deal with matrices, especially, with 2D sparse matrices. * See http://www.boost.org/libs/numeric/ublas/doc/matrix_sparse.htm * However: I read somewhere that boost::uBLAS concentrates more on correct implementation than on performance. * * \idea Introduce naming scheme: * - all Vars should be named v_..., e.g. v_i instead of i * - all VarSets should be named vs_..., e.g. v_i instead of i * - all Factors should be named f_..., e.g. f_I instead of I * - all indices should be named _..., e.g. _k instead of k * - all iterators should be named i_, e.g. i_i is an iterator to i * - all const_iterators should be named ci_, e.g. ci_i is an iterator to i **/ /** \mainpage Reference manual for libDAI - A free/open source C++ library for Discrete Approximate Inference methods * \author Joris Mooij, Frederik Eaton * \version 0.2.4 * \date February 11, 2010 * *
* \section about About libDAI * libDAI is a free/open source C++ library (licensed under GPL 2+) that provides * implementations of various (approximate) inference methods for discrete * graphical models. libDAI supports arbitrary factor graphs with discrete * variables; this includes discrete Markov Random Fields and Bayesian * Networks. * * The library is targeted at researchers. To be able to use the library, a * good understanding of graphical models is needed. * * The best way to use libDAI is by writing C++ code that invokes the library; * in addition, part of the functionality is accessibly by using the * - command line interface * - (limited) MatLab interface * - (experimental) python interface * - (experimental) octave interface. * * libDAI can be used to implement novel (approximate) inference algorithms * and to easily compare the accuracy and performance with existing algorithms * that have been implemented already. * * \section features Features * Currently, libDAI supports the following (approximate) inference methods: * - Exact inference by brute force enumeration; * - Exact inference by junction-tree methods; * - Mean Field; * - Loopy Belief Propagation [\ref KFL01]; * - Fractional Belief Propagation [\ref WiH03]; * - Tree-Reweighted Belief Propagation [\ref WJW03]; * - Tree Expectation Propagation [\ref MiQ04]; * - Generalized Belief Propagation [\ref YFW05]; * - Double-loop GBP [\ref HAK03]; * - Various variants of Loop Corrected Belief Propagation * [\ref MoK07, \ref MoR05]; * - Gibbs sampler; * - Conditioned Belief Propagation [\ref EaG09]. * * These inference methods can be used to calculate partition sums, marginals * over subsets of variables, and MAP states (the joint state of variables that * has maximum probability). * * In addition, libDAI supports parameter learning of conditional probability * tables by Expectation Maximization. * * \section limitations Limitations * libDAI is not intended to be a complete package for approximate inference. * Instead, it should be considered as an "inference engine", providing * various inference methods. In particular, it contains no GUI, currently * only supports its own file format for input and output (although support * for standard file formats may be added later), and provides very limited * visualization functionalities. The only learning method supported currently * is Expectation Maximization (or Maximum Likelihood if no data is missing) * for learning factor parameters. * * \section rationale Rationale * * In my opinion, the lack of open source "reference" implementations hampers * progress in research on approximate inference. Methods differ widely in terms * of quality and performance characteristics, which also depend in different * ways on various properties of the graphical models. Finding the best * approximate inference method for a particular application therefore often * requires empirical comparisons. However, implementing and debugging these * methods takes a lot of time which could otherwise be spent on research. I hope * that this code will aid researchers to be able to easily compare various * (existing as well as new) approximate inference methods, in this way * accelerating research and stimulating real-world applications of approximate * inference. * * \section language Language * Because libDAI is implemented in C++, it is very fast compared with * implementations in MatLab (a factor 1000 faster is not uncommon). * libDAI does provide a (limited) MatLab interface for easy integration with MatLab. * It also provides a command line interface and experimental python and octave * interfaces (thanks to Patrick Pletscher). * * \section compatibility Compatibility * * The code has been developed under Debian GNU/Linux with the GCC compiler suite. * libDAI compiles successfully with g++ versions 3.4, 4.1, 4.2 and 4.3. * * libDAI has also been successfully compiled with MS Visual Studio 2008 under Windows * (but not all build targets are supported yet) and with Cygwin under Windows. * * Finally, libDAI has been compiled successfully on MacOS X. * * \section download Downloading libDAI * The libDAI sources and documentation can be downloaded from the libDAI website: * http://www.libdai.org. * * \section support Mailing list * The Google group "libDAI" (http://groups.google.com/group/libdai) * can be used for getting support and discussing development issues. */ /** \page license License *
* \section license-license License * * libDAI is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * libDAI is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * *
* \section license-gpl GNU General Public License version 2 * * \verbinclude COPYING */ /** \page citations Citing libDAI *
* \section citations-citations Citing libDAI * * If you write a scientific paper describing research that made substantive use * of this program, please: * - mention the fashion in which this software was * used, including the version number, with a citation to the literature, * to allow replication; * - mention this software in the Acknowledgements section. * * An appropriate citation would be:\n * * Joris M. Mooij et al. (2010) "libDAI 0.2.4: A free/open source C++ library for Discrete * Approximate Inference", http://www.libdai.org * * or in BiBTeX format: * * 
 *  \@misc{mooij2010libdai,
 *    author = "Joris M. Mooij et al.",
 *    title = "lib{DAI} 0.2.4: A free/open source {C}++ library for {D}iscrete {A}pproximate {I}nference",
 *    howpublished = "http://www.libdai.org/",
 *    year = 2010
 *  }
 *
* * Moreover, as a personal note, I would appreciate it if you would email * (citations of) papers referencing this work to joris dot mooij at libdai dot org. */ /** \page authors Authors * \section authors-authors People who contributed to libDAI * * \verbinclude AUTHORS */ /** \page build Building libDAI *
* \section build-unix Building libDAI under UNIX variants (Linux / Cygwin / Mac OS X) * * \subsection build-unix-preparations Preparations * * You need: * - a recent version of gcc (at least version 3.4) * - GNU make * - doxygen * - graphviz * - recent boost C++ libraries (at least version 1.34 if you have * a recent version of GCC, otherwise at least version 1.37; however, * version 1.37 shipped with Ubuntu 9.04 is known not to work) * * On Debian/Ubuntu, you can easily install all these packages with a single command: * 
  apt-get install g++ make doxygen graphviz libboost-dev libboost-graph-dev libboost-program-options-dev
* (root permissions needed). * * On Mac OS X (10.4 is known to work), these packages can be installed easily via MacPorts. * If MacPorts is not already installed, install it according to the instructions at http://www.macports.org/. * Then, a simple * 
  sudo port install gmake boost doxygen graphviz
* should be enough to install everything that is needed. * * On Cygwin, the prebuilt Cygwin package boost-1.33.1-x is known not to work. * You can however obtain the latest boost version (you need at least 1.37.0) * from http://www.boost.org/ and compile/install it with: * * 
  ./configure
 *  make
 *  make install
 *
* * \subsection build-unix-libdai Building libDAI * * To build the libDAI source, first copy a template Makefile.* to Makefile.conf * (for example, copy Makefile.LINUX to Makefile.conf if you use GNU/Linux). * Then, edit the Makefile.conf template to adapt it to your local setup. * Especially directories may differ from system to system. Platform independent * build options can be set in Makefile.ALL. Finally, run * 
  make
* The build includes a regression test, which may take a while to complete. * * If the build is successful, you can test the example program: * 
  examples/example tests/alarm.fg
* or the more extensive test program: * 
  tests/testdai --aliases tests/aliases.conf --filename tests/alarm.fg --methods JTREE_HUGIN BP_SEQMAX
* * *
* \section build-windows Building libDAI under Windows * * \subsection build-windows-preparations Preparations * * You need: * - A recent version of MicroSoft Visual Studio (2008 is known to work) * - recent boost C++ libraries (version 1.37 or higher) * - GNU make (can be obtained from http://gnuwin32.sourceforge.net) * * For the regression test, you need: * - GNU diff, GNU sed (can be obtained from http://gnuwin32.sourceforge.net) * * \subsection build-windows-libdai Building libDAI * * To build the source, copy Makefile.WINDOWS to Makefile.conf. Then, edit * Makefile.conf to adapt it to your local setup. Platform independent * build options can be set in Makefile.ALL. Finally, run (from the command line) * 
  make
* The build includes a regression test, which may take a while to complete. * * If the build is successful, you can test the example program: * 
  examples\\example tests\\alarm.fg
* or the more extensive test program: * 
  tests\\testdai --aliases tests\\aliases.conf --filename tests\\alarm.fg --methods JTREE_HUGIN BP_SEQMAX
* * *
* \section build-matlab Building the libDAI MatLab interface * * You need: * - MatLab * - The platform-dependent requirements described above * * First, you need to build the libDAI source as described above for your * platform. By default, the MatLab interface is disabled, so before compiling the * source, you have to enable it in Makefile.ALL by setting * 
  WITH_MATLAB=true
* Also, you have to configure the MatLab-specific parts of * Makefile.conf to match your system (in particular, the Makefile variables ME, * MATLABDIR and MEX). The MEX file extension depends on your platform; for a * 64-bit linux x86_64 system this would be "ME=.mexa64", for a 32-bit linux x86 * system "ME=.mexglx". If you are unsure about your MEX file * extension: it needs to be the same as what the MatLab command "mexext" returns. * The required MEX files are built by issuing * 
  make
* from the command line. The MatLab interface is much less powerful than using * libDAI from C++. There are two reasons for this: (i) it is boring to write MEX * files; (ii) the large performance penalty paid when large data structures (like * factor graphs) have to be converted between their native C++ data structure to * something that MatLab understands. * * A simple example of how to use the MatLab interface is the following (entered * at the MatLab prompt), which performs exact inference by the junction tree * algorithm and approximate inference by belief propagation on the ALARM network: * 
  cd path_to_libdai/matlab
 *  [psi] = dai_readfg ('../examples/alarm.fg');
 *  [logZ,q,md,qv,qf] = dai (psi, 'JTREE', '[updates=HUGIN,verbose=0]')
 *  [logZ,q,md,qv,qf] = dai (psi, 'BP', '[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0]')
* where "path_to_libdai" has to be replaced with the directory in which libDAI * was installed. For other algorithms and some default parameters, see the file * tests/aliases.conf. * *
* \section build-doxygen Building the documentation * * Install doxygen, graphviz and a TeX distribution and use * 
  make doc
* to build the documentation. If the documentation is not clear enough, feel free * to send me an email (or even better, to improve the documentation and send a patch!). * The documentation can also be browsed online at http://www.libdai.org. */ /** \page changelog Change Log * \verbinclude ChangeLog */ /** \page terminology Terminology and conventions * * \section terminology-graphicalmodels Graphical models * * Commonly used graphical models are Bayesian networks and Markov random fields. * In libDAI, both types of graphical models are represented by a slightly more * general type of graphical model: a factor graph [\ref KFL01]. * * An example of a Bayesian network is: * \dot * digraph bayesnet { * size="1,1"; * x0 [label="0"]; * x1 [label="1"]; * x2 [label="2"]; * x3 [label="3"]; * x4 [label="4"]; * x0 -> x1; * x0 -> x2; * x1 -> x3; * x1 -> x4; * x2 -> x4; * } * \enddot * The probability distribution of a Bayesian network factorizes as: * \f[ P(\mathbf{x}) = \prod_{i\in\mathcal{V}} P(x_i \,|\, x_{\mathrm{pa}(i)}) \f] * where \f$\mathrm{pa}(i)\f$ are the parents of node \a i in a DAG. * * The same probability distribution can be represented as a Markov random field: * \dot * graph mrf { * size="1.5,1.5"; * x0 [label="0"]; * x1 [label="1"]; * x2 [label="2"]; * x3 [label="3"]; * x4 [label="4"]; * x0 -- x1; * x0 -- x2; * x1 -- x2; * x1 -- x3; * x1 -- x4; * x2 -- x4; * } * \enddot * * The probability distribution of a Markov random field factorizes as: * \f[ P(\mathbf{x}) = \frac{1}{Z} \prod_{C\in\mathcal{C}} \psi_C(x_C) \f] * where \f$ \mathcal{C} \f$ are the cliques of an undirected graph, * \f$ \psi_C(x_C) \f$ are "potentials" or "compatibility functions", and * \f$ Z \f$ is the partition sum which properly normalizes the probability * distribution. * * Finally, the same probability distribution can be represented as a factor graph: * \dot * graph factorgraph { * size="1.8,1"; * x0 [label="0"]; * x1 [label="1"]; * x2 [label="2"]; * x3 [label="3"]; * x4 [label="4"]; * f01 [shape="box",label=""]; * f02 [shape="box",label=""]; * f13 [shape="box",label=""]; * f124 [shape="box",label=""]; * x0 -- f01; * x1 -- f01; * x0 -- f02; * x2 -- f02; * x1 -- f13; * x3 -- f13; * x1 -- f124; * x2 -- f124; * x4 -- f124; * } * \enddot * * The probability distribution of a factor graph factorizes as: * \f[ P(\mathbf{x}) = \frac{1}{Z} \prod_{I\in \mathcal{F}} f_I(x_I) \f] * where \f$ \mathcal{F} \f$ are the factor nodes of a factor graph (a * bipartite graph consisting of variable nodes and factor nodes), * \f$ f_I(x_I) \f$ are the factors, and \f$ Z \f$ is the partition sum * which properly normalizes the probability distribution. * * Looking at the expressions for the joint probability distributions, * it is obvious that Bayesian networks and Markov random fields can * both be easily represented as factor graphs. Factor graphs most * naturally express the factorization structure of a probability * distribution, and hence are a convenient representation for approximate * inference algorithms, which all try to exploit this factorization. * This is why libDAI uses a factor graph as representation of a * graphical model, implemented in the dai::FactorGraph class. * * \section terminology-inference Inference tasks * * Given a factor graph, specified by the variable nodes \f$\{x_i\}_{i\in\mathcal{V}}\f$ * the factor nodes \f$ \mathcal{F} \f$, the graph structure, and the factors * \f$\{f_I(x_I)\}_{I\in\mathcal{F}}\f$, the following tasks are important: * * - Calculating the partition sum: * \f[ Z = \sum_{\mathbf{x}_{\mathcal{V}}} \prod_{I \in \mathcal{F}} f_I(x_I) \f] * - Calculating the marginal distribution of a subset of variables * \f$\{x_i\}_{i\in A}\f$: * \f[ P(\mathbf{x}_{A}) = \frac{1}{Z} \sum_{\mathbf{x}_{\mathcal{V}\setminus A}} \prod_{I \in \mathcal{F}} f_I(x_I) \f] * - Calculating the MAP state which has the maximum probability mass: * \f[ \mathrm{argmax}_{\mathbf{x}}\,\prod_{I\in\mathcal{F}} f_I(x_I) \f] * * libDAI offers several inference algorithms, which solve (a subset of) these tasks either * approximately or exactly, for factor graphs with discrete variables. The following * algorithms are implemented: * * Exact inference: * - Brute force enumeration: dai::ExactInf * - Junction-tree method: dai::JTree * * Approximate inference: * - Mean Field: dai::MF * - (Loopy) Belief Propagation: dai::BP [\ref KFL01] * - Fractional Belief Propagation: dai::FBP [\ref WiH03] * - Tree-Reweighted Belief Propagation: dai::TRWBP [\ref WJW03] * - Tree Expectation Propagation: dai::TreeEP [\ref MiQ04] * - Generalized Belief Propagation: dai::HAK [\ref YFW05] * - Double-loop GBP: dai::HAK [\ref HAK03] * - Loop Corrected Belief Propagation: dai::MR [\ref MoR05] and dai::LC [\ref MoK07] * - Gibbs sampling: dai::Gibbs * - Conditioned Belief Propagation: dai::CBP [\ref EaG09] * * Not all inference tasks are implemented by each method: calculating MAP states * is only possible with dai::JTree and dai::BP, calculating partition sums is * not possible with dai::MR, dai::LC and dai::Gibbs. * * \section terminology-learning Parameter learning * * In addition, libDAI supports parameter learning of conditional probability * tables by Expectation Maximization (or Maximum Likelihood, if there is no * missing data). This is implemented in dai::EMAlg. * * \section terminology-variables-states Variables and states * * Linear states are a concept that is used often in libDAI, for example for storing * and accessing factors, which are functions mapping from states of a set of variables * to the real numbers. Internally, a factor is stored as an array, and the array index * of an entry corresponds with the linear state of the set of variables. Below we will * define variables, states and linear states of (sets of) variables. * * \subsection terminology-variables Variables * * Each (random) \a variable has a unique identifier, its \a label (which has * a non-negative integer value). If two variables have the same * label, they are considered as identical. A variable can take on a finite * number of different values or \a states. * * We use the following notational conventions. The discrete * random variable with label \f$l\f$ is denoted as \f$x_l\f$, and the number * of possible values of this variable as \f$S_{x_l}\f$ or simply \f$S_l\f$. * The set of possible values of variable \f$x_l\f$ is denoted * \f$X_l := \{0,1,\dots,S_l-1\}\f$ and called its \a state \a space. * * \subsection terminology-variable-sets Sets of variables and the canonical ordering * * Let \f$A := \{x_{l_1},x_{l_2},\dots,x_{l_n}\}\f$ be a set of variables. * * The \a canonical \a ordering of the variables in \a A is induced by their labels. * That is: if \f$l_1 < l_2\f$, then \f$x_{l_1}\f$ occurs before \f$x_{l_2}\f$ in the * canonical ordering. Below, we will assume that \f$(l_i)_{i=1}^n\f$ is * ordered according to the canonical ordering, i.e., \f$l_1 < l_2 < \dots < l_n\f$. * * \subsection terminology-variable-states States and linear states of sets of variables * * A \a state of the variables in \a A refers to a joint assignment of the * variables, or in other words, to an element of the Cartesian product * \f$ \prod_{i=1}^n X_{l_i}\f$ of the state spaces of the variables in \a A. * Note that a state can also be interpreted as a mapping from variables (or * variable labels) to the natural numbers, which assigns to a variable (or its * label) the corresponding state of the variable. * * A state of \a n variables can be represented as an n-tuple of * non-negative integers: \f$(s_1,s_2,\dots,s_n)\f$ corresponds to the * joint assignment \f$x_{l_1} = s_1, \dots, x_{l_n} = s_n\f$. * Alternatively, a state can be represented compactly as one non-negative integer; * this representation is called a \a linear \a state. The linear state * \a s corresponding to the state \f$(s_1,s_2,\dots,s_n)\f$ would be: * \f[ * s := \sum_{i=1}^n s_i \prod_{j=1}^{i-1} S_{l_j} * = s_1 + s_2 S_{l_1} + s_3 S_{l_1} S_{l_2} + \dots + s_n S_{l_1} \cdots S_{l_{n-1}}. * \f] * * Vice versa, given a linear state \a s for the variables \a A, the * corresponding state \f$s_i\f$ of the \a i 'th variable \f$x_{l_i}\f$ (according to * the canonical ordering of the variables in \a A) is given by * \f[ * s_i = \left\lfloor\frac{s \mbox { mod } \prod_{j=1}^i S_{l_j}}{\prod_{j=1}^{i-1} S_{l_j}}\right\rfloor. * \f] * * Finally, the \a number \a of \a states of the set of variables \a A is simply the * number of different joint assignments of the variables, that is, \f$\prod_{i=1}^n S_{l_i}\f$. */ /** \page fileformats libDAI file formats * * \section fileformats-factorgraph Factor graph (.fg) file format * * This section describes the .fg file format used in libDAI to store factor graphs. * Markov Random Fields are special cases of factor graphs, as are Bayesian * networks. A factor graph can be specified as follows: for each factor, one has * to specify which variables occur in the factor, what their respective * cardinalities (i.e., number of possible values) are, and a table listing all * the values of that factor for all possible configurations of these variables. * * A .fg file is not much more than that. It starts with a line containing the * number of factors in that graph, followed by an empty line. Then all factors * are specified, using one block for each factor, where the blocks are seperated * by empty lines. Each variable occurring in the factor graph has a unique * identifier, its label (which should be a nonnegative integer). Comment lines * which start with # are ignored. * * \subsection fileformats-factorgraph-factor Factor block format * * Each block describing a factor starts with a line containing the number of * variables in that factor. The second line contains the labels of these * variables, seperated by spaces (labels are nonnegative integers and to avoid * confusion, it is suggested to start counting at 0). The third line contains * the number of possible values of each of these variables, also seperated by * spaces. Note that there is some redundancy here, since if a variable appears * in more than one factor, the cardinality of that variable appears several * times in the .fg file; obviously, these cardinalities should be consistent. * The fourth line contains the number of nonzero entries * in the factor table. The rest of the lines contain these nonzero entries; * each line consists of a table index, followed by white-space, followed by the * value corresponding to that table index. The most difficult part is getting * the indexing right. The convention that is used is that the left-most * variables cycle through their values the fastest (similar to MatLab indexing * of multidimensional arrays). * * \subsubsection fileformats-factorgraph-factor-example Example * * An example block describing one factor is: * * 
 *  3
 *  4 8 7
 *  3 2 2
 *  11
 *  0 0.1
 *  1 3.5
 *  2 2.8
 *  3 6.3
 *  4 8.4
 *  6 7.4
 *  7 2.4
 *  8 8.9
 *  9 1.3
 *  10 1.6
 *  12 6.4
 *  11 2.6
 *
* * which corresponds to the following factor: * * \f[ * \begin{array}{ccc|c} * x_4 & x_8 & x_7 & \mbox{value}\\ * \hline * 0 & 0 & 0 & 0.1\\ * 1 & 0 & 0 & 3.5\\ * 2 & 0 & 0 & 2.8\\ * 0 & 1 & 0 & 6.3\\ * 1 & 1 & 0 & 8.4\\ * 2 & 1 & 0 & 0.0\\ * 0 & 0 & 1 & 7.4\\ * 1 & 0 & 1 & 2.4\\ * 2 & 0 & 1 & 8.9\\ * 0 & 1 & 1 & 1.3\\ * 1 & 1 & 1 & 1.6\\ * 2 & 1 & 1 & 2.6 * \end{array} * \f] * * Note that the value of \f$x_4\f$ changes fastest, followed by that of \f$x_8\f$, and \f$x_7\f$ * varies the slowest, corresponding to the second line of the block ("4 8 7"). * Further, \f$x_4\f$ can take on three values, and \f$x_8\f$ and \f$x_7\f$ each have two possible * values, as described in the third line of the block ("3 2 2"). The table * contains 11 non-zero entries (all except for the fifth entry). Note that the * eleventh and twelveth entries are interchanged. * * A final note: the internal representation in libDAI of the factor above is * different, because the variables are ordered according to their indices * (i.e., the ordering would be \f$x_4 x_7 x_8\f$) and the values of the table are * stored accordingly, with the variable having the smallest index changing * fastest: * * \f[ * \begin{array}{ccc|c} * x_4 & x_7 & x_8 & \mbox{value}\\ * \hline * 0 & 0 & 0 & 0.1\\ * 1 & 0 & 0 & 3.5\\ * 2 & 0 & 0 & 2.8\\ * 0 & 1 & 0 & 7.4\\ * 1 & 1 & 0 & 2.4\\ * 2 & 1 & 0 & 8.9\\ * 0 & 0 & 1 & 6.3\\ * 1 & 0 & 1 & 8.4\\ * 2 & 0 & 1 & 0.0\\ * 0 & 1 & 1 & 1.3\\ * 1 & 1 & 1 & 1.6\\ * 2 & 1 & 1 & 2.6 * \end{array} * \f] * * * \section fileformats-evidence Evidence (.tab) file format * * This section describes the .tab fileformat used in libDAI to store "evidence", * i.e., a data set consisting of multiple samples, where each sample is the * observed joint state of some variables. * * A .tab file is a tabular data file, consisting of a header line, followed by * an empty line, followed by the data points, with one line for each data point. * Each line (apart from the empty one) should have the same number of columns, * where columns are separated by one tab character. Each column corresponds to * a variable. The header line consists of the variable labels (corresponding to * dai::Var::label()). The other lines are observed joint states of the variables, i.e., * each line corresponds to a joint observation of the variables, and each column * of a line contains the state of the variable associated with that column. * Missing data is handled simply by having two consecutive tab characters, * without any characters in between. * * \subsection fileformats-evidence-example Example * * 
 *  1       3       2
 *
 *  0       0       1
 *  1       0       1
 *  1               1
 *
* * This would correspond to a data set consisting of three observations concerning * the variables with labels 1, 3 and 2; the first observation being * \f$x_1 = 0, x_3 = 0, x_2 = 1\f$, the second observation being * \f$x_1 = 1, x_3 = 0, x_2 = 1\f$, and the third observation being * \f$x_1 = 1, x_2 = 1\f$ (where the state of \f$x_3\f$ is missing). * * \section fileformats-emalg Expectation Maximization (.em) file format * * This section describes the file format of .em files, which are used * to specify a particular EM algorithm. The .em files are complementary * to .fg files; in other words, an .em file without a corresponding .fg * file is useless. Furthermore, one also needs a corresponding .tab file * containing the data used for parameter learning. * * An .em file starts with a line specifying the number of maximization steps, * followed by an empty line. Then, each maximization step is described in a * block, which should satisfy the format described in the next subsection. * * \subsection fileformats-emalg-maximizationstep Maximization Step block format * * A maximization step block of an .em file starts with a single line * describing the number of shared parameters blocks that will follow. * Then, each shared parameters block follows, in the format described in * the next subsection. * * \subsection fileformats-emalg-sharedparameters Shared parameters block format * * A shared parameters block of an .em file starts with a single line * consisting of the name of a ParameterEstimation subclass * and its parameters in the format of a PropertySet. For example: * 
  CondProbEstimation [target_dim=2,total_dim=4,pseudo_count=1]
* The next line contains the number of factors that share their parameters. * Then, each of these factors is specified on separate lines (possibly * seperated by empty lines), where each line consists of several fields * seperated by a space or a tab character. The first field contains * the index of the factor in the factor graph. The following fields should * contain the variable labels of the variables on which that factor depends, * in a specific ordering. This ordering can be different from the canonical * ordering of the variables used internally in libDAI (which would be sorted * ascendingly according to the variable labels). The ordering of the variables * specifies the implicit ordering of the shared parameters: when iterating * over all shared parameters, the corresponding index of the first variable * changes fastest (in the inner loop), and the corresponding index of the * last variable changes slowest (in the outer loop). By choosing the right * ordering, it is possible to let different factors (depending on different * variables) share parameters in parameter learning using EM. This convention * is similar to the convention used in factor blocks in a factor graph .fg * file (see \ref fileformats-factorgraph-factor). * * \section fileformats-aliases Aliases file format * * An aliases file is basically a list of "macros" and the strings that they * should be substituted with. * * Each line of the aliases file can be either empty, contain a comment * (if the first character is a '#') or contain an alias. In the latter case, * the line should contain a colon; the part before the colon contains the * name of the alias, the part after the colon the string that it should be * substituted with. Any whitespace before and after the colon is ignored. * * For example, the following line would define the alias \c BP_SEQFIX * as a shorthand for "BP[updates=SEQFIX,tol=1e-9,maxiter=10000,logdomain=0]": * 
 *  BP_SEQFIX:  BP[updates=SEQFIX,tol=1e-9,maxiter=10000,logdomain=0]
 *
* * Aliases files can be used to store default options for algorithms. */ /** \page bibliography Bibliography * \anchor EaG09 \ref EaG09 * F. Eaton and Z. Ghahramani (2009): * "Choosing a Variable to Clamp", * Proceedings of the Twelfth International Conference on Artificial Intelligence and Statistics (AISTATS 2009) 5:145-152, * http://jmlr.csail.mit.edu/proceedings/papers/v5/eaton09a/eaton09a.pdf * * \anchor EMK06 \ref EMK06 * G. Elidan and I. McGraw and D. Koller (2006): * "Residual Belief Propagation: Informed Scheduling for Asynchronous Message Passing", * Proceedings of the 22nd Annual Conference on Uncertainty in Artificial Intelligence (UAI-06), * http://uai.sis.pitt.edu/papers/06/UAI2006_0091.pdf * * \anchor HAK03 \ref HAK03 * T. Heskes and C. A. Albers and H. J. Kappen (2003): * "Approximate Inference and Constrained Optimization", * Proceedings of the 19th Annual Conference on Uncertainty in Artificial Intelligence (UAI-03) pp. 313-320, * http://www.snn.ru.nl/reports/Heskes.uai2003.ps.gz * * \anchor KFL01 \ref KFL01 * F. R. Kschischang and B. J. Frey and H.-A. Loeliger (2001): * "Factor Graphs and the Sum-Product Algorithm", * IEEE Transactions on Information Theory 47(2):498-519, * http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?arnumber=910572 * * \anchor KoF09 \ref KoF09 * D. Koller and N. Friedman (2009): * Probabilistic Graphical Models - Principles and Techniques, * The MIT Press, Cambridge, Massachusetts, London, England. * \anchor Min05 \ref Min05 * T. Minka (2005): * "Divergence measures and message passing", * MicroSoft Research Technical Report MSR-TR-2005-173, * http://research.microsoft.com/en-us/um/people/minka/papers/message-passing/minka-divergence.pdf * * \anchor MiQ04 \ref MiQ04 * T. Minka and Y. Qi (2004): * "Tree-structured Approximations by Expectation Propagation", * Advances in Neural Information Processing Systems (NIPS) 16, * http://books.nips.cc/papers/files/nips16/NIPS2003_AA25.pdf * * \anchor MoK07 \ref MoK07 * J. M. Mooij and H. J. Kappen (2007): * "Loop Corrections for Approximate Inference on Factor Graphs", * Journal of Machine Learning Research 8:1113-1143, * http://www.jmlr.org/papers/volume8/mooij07a/mooij07a.pdf * * \anchor MoK07b \ref MoK07b * J. M. Mooij and H. J. Kappen (2007): * "Sufficient Conditions for Convergence of the Sum-Product Algorithm", * IEEE Transactions on Information Theory 53(12):4422-4437, * http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?arnumber=4385778 * * \anchor MoR05 \ref MoR05 * A. Montanari and T. Rizzo (2005): * "How to Compute Loop Corrections to the Bethe Approximation", * Journal of Statistical Mechanics: Theory and Experiment 2005(10)-P10011, * http://stacks.iop.org/1742-5468/2005/P10011 * * \anchor StW99 \ref StW99 * A. Steger and N. C. Wormald (1999): * "Generating Random Regular Graphs Quickly", * Combinatorics, Probability and Computing Vol 8, Issue 4, pp. 377-396, * http://www.math.uwaterloo.ca/~nwormald/papers/randgen.pdf * * \anchor WiH03 \ref WiH03 * W. Wiegerinck and T. Heskes (2003): * "Fractional Belief Propagation", * Advances in Neural Information Processing Systems (NIPS) 15, pp. 438-445, * http://books.nips.cc/papers/files/nips15/LT16.pdf * * \anchor WJW03 \ref WJW03 * M. J. Wainwright, T. S. Jaakkola and A. S. Willsky (2003): * "Tree-reweighted belief propagation algorithms and approximate ML estimation by pseudo-moment matching", * 9th Workshop on Artificial Intelligence and Statistics, * http://www.eecs.berkeley.edu/~wainwrig/Papers/WJW_AIStat03.pdf * * \anchor YFW05 \ref YFW05 * J. S. Yedidia and W. T. Freeman and Y. Weiss (2005): * "Constructing Free-Energy Approximations and Generalized Belief Propagation Algorithms", * IEEE Transactions on Information Theory 51(7):2282-2312, * http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?arnumber=1459044 */ /** \page discussion Ideas not worth exploring * \section discuss_extendedgraphs Extended factorgraphs/regiongraphs * * A FactorGraph and a RegionGraph are often equipped with * additional properties for nodes and edges. The code to initialize those * is often quite similar. Maybe one could abstract this, e.g.: * \code * template * class ExtFactorGraph : public FactorGraph { * public: * std::vector node1Props; * std::vector node2Props; * std::vector > edgeProps; * // ... * } * \endcode * * Advantages: * - Less code duplication. * - Easier maintainability. * - Easier to write new inference algorithms. * * Disadvantages: * - Cachability may be worse. * - A problem is the case where there are no properties for either type of nodes or for edges. * Maybe this can be solved using specializations, or using variadac template arguments? * Another possible solution would be to define a "class Empty {}", and add some code * that checks for the typeid, comparing it with Empty, and doing something special in that case * (e.g., not allocating memory). * - The main disadvantage of this approach seems to be that it leads to even more entanglement. * Therefore this is probably a bad idea. * * \section discuss_templates Polymorphism by template parameterization * * Instead of polymorphism by inheritance, use polymorphism by template parameterization. * For example, the real reason for introducing the complicated inheritance scheme of dai::InfAlg * was for functions like dai::calcMarginal. Instead, one could use a template function: * \code * template * Factor calcMarginal( const InfAlg &obj, const VarSet &ns, bool reInit ); * \endcode * This would assume that the type InfAlg supports certain methods. Ideally, one would use * concepts to define different classes of inference algorithms with different capabilities, * for example the ability to calculate logZ, the ability to calculate marginals, the ability to * calculate bounds, the ability to calculate MAP states, etc. Then, one would use traits * classes in order to be able to query the capabilities of the model. For example, one would be * able to query whether the inference algorithm supports calculation of logZ. Unfortunately, * this is compile-time polymorphism, whereas tests/testdai needs runtime polymorphism. * Therefore this is probably a bad idea. */ libDAI-0.2.4/include/dai/hak.h0000644000263000017630000001412311334764775014573 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines class HAK, which implements a variant of Generalized Belief Propagation. /// \idea Implement more general region graphs and corresponding Generalized Belief Propagation updates as described in [\ref YFW05]. #ifndef __defined_libdai_hak_h #define __defined_libdai_hak_h #include #include #include #include #include namespace dai { /// Approximate inference algorithm: implementation of single-loop ("Generalized Belief Propagation") and double-loop algorithms by Heskes, Albers and Kappen [\ref HAK03] class HAK : public DAIAlgRG { private: /// Outer region beliefs std::vector _Qa; /// Inner region beliefs std::vector _Qb; /// Messages from outer to inner regions std::vector > _muab; /// Messages from inner to outer regions std::vector > _muba; /// Maximum difference encountered so far Real _maxdiff; /// Number of iterations needed size_t _iters; public: /// Parameters for HAK struct Properties { /// Enumeration of possible cluster choices /** The following cluster choices are defined: * - MIN minimal clusters, i.e., one outer region for each maximal factor * - DELTA one outer region for each variable and its Markov blanket * - LOOP one cluster for each loop of length at most \a Properties::loopdepth, and in addition one cluster for each maximal factor * - BETHE Bethe approximation (one outer region for each maximal factor, inner regions are single variables) */ DAI_ENUM(ClustersType,MIN,BETHE,DELTA,LOOP); /// Enumeration of possible message initializations DAI_ENUM(InitType,UNIFORM,RANDOM); /// Verbosity (amount of output sent to stderr) size_t verbose; /// Maximum number of iterations size_t maxiter; /// Tolerance for convergence test Real tol; /// Damping constant (0.0 means no damping, 1.0 is maximum damping) Real damping; /// How to choose the outer regions ClustersType clusters; /// How to initialize the messages InitType init; /// Use single-loop (GBP) or double-loop (HAK) bool doubleloop; /// Depth of loops (only relevant for \a clusters == \c ClustersType::LOOP) size_t loopdepth; } props; /// Name of this inference algorithm static const char *Name; public: /// \name Constructors/destructors //@{ /// Default constructor HAK() : DAIAlgRG(), _Qa(), _Qb(), _muab(), _muba(), _maxdiff(0.0), _iters(0U), props() {} /// Construct from FactorGraph \a fg and PropertySet \a opts /** \param opts Parameters @see Properties */ HAK( const FactorGraph &fg, const PropertySet &opts ); /// Construct from RegionGraph \a rg and PropertySet \a opts HAK( const RegionGraph &rg, const PropertySet &opts ); //@} /// \name General InfAlg interface //@{ virtual HAK* clone() const { return new HAK(*this); } virtual std::string identify() const; virtual Factor belief( const VarSet &vs ) const; virtual std::vector beliefs() const; virtual Real logZ() const; virtual void init(); virtual void init( const VarSet &vs ); virtual Real run(); virtual Real maxDiff() const { return _maxdiff; } virtual size_t Iterations() const { return _iters; } virtual void setProperties( const PropertySet &opts ); virtual PropertySet getProperties() const; virtual std::string printProperties() const; //@} /// \name Additional interface specific for HAK //@{ /// Returns reference to message from outer region \a alpha to its \a _beta 'th neighboring inner region Factor & muab( size_t alpha, size_t _beta ) { return _muab[alpha][_beta]; } /// Returns reference to message the \a _beta 'th neighboring inner region of outer region \a alpha to that outer region Factor & muba( size_t alpha, size_t _beta ) { return _muba[alpha][_beta]; } /// Returns belief of outer region \a alpha const Factor& Qa( size_t alpha ) const { return _Qa[alpha]; }; /// Returns belief of inner region \a beta const Factor& Qb( size_t beta ) const { return _Qb[beta]; }; /// Runs single-loop algorithm (algorithm 1 in [\ref HAK03]) Real doGBP(); /// Runs double-loop algorithm (as described in section 4.2 of [\ref HAK03]), which always convergences Real doDoubleLoop(); //@} private: /// Helper function for constructors void construct(); /// Recursive procedure for finding clusters of variables containing loops of length at most \a length /** \param fg the factor graph * \param allcl the clusters found so far * \param newcl partial candidate cluster * \param root start (and end) point of the loop * \param length number of variables that may be added to \a newcl * \param vars neighboring variables of \a newcl * \return allcl all clusters of variables with loops of length at most \a length passing through root */ void findLoopClusters( const FactorGraph &fg, std::set &allcl, VarSet newcl, const Var & root, size_t length, VarSet vars ); }; } // end of namespace dai #endif libDAI-0.2.4/include/dai/exactinf.h0000644000263000017630000000712711334764775015637 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines ExactInf class, which can be used for exact inference on small factor graphs. #ifndef __defined_libdai_exactinf_h #define __defined_libdai_exactinf_h #include #include #include #include namespace dai { /// Exact inference algorithm using brute force enumeration (mainly useful for testing purposes) /** Inference is done simply by multiplying all factors together into one large factor, * and then calculating marginals and partition sum from the product. * \note This inference method can easily exhaust all available memory; in that case, one * may try the JTree class instead. */ class ExactInf : public DAIAlgFG { public: /// Parameters for ExactInf struct Properties { /// Verbosity (amount of output sent to stderr) size_t verbose; } props; /// Name of this inference algorithm static const char *Name; private: /// All single variable marginals std::vector _beliefsV; /// All factor variable marginals std::vector _beliefsF; /// Logarithm of partition sum Real _logZ; public: /// \name Constructors/destructors //@{ /// Default constructor ExactInf() : DAIAlgFG(), props(), _beliefsV(), _beliefsF(), _logZ(0) {} /// Construct from FactorGraph \a fg and PropertySet \a opts /** \param opts Parameters @see Properties */ ExactInf( const FactorGraph &fg, const PropertySet &opts ) : DAIAlgFG(fg), props(), _beliefsV(), _beliefsF(), _logZ() { setProperties( opts ); construct(); } //@} /// \name General InfAlg interface //@{ virtual ExactInf* clone() const { return new ExactInf(*this); } virtual std::string identify() const; virtual Factor belief( const Var &v ) const { return beliefV( findVar( v ) ); } virtual Factor belief( const VarSet &vs ) const; virtual Factor beliefV( size_t i ) const { return _beliefsV[i]; } virtual Factor beliefF( size_t I ) const { return _beliefsF[I]; } virtual std::vector beliefs() const; virtual Real logZ() const { return _logZ; } virtual void init(); virtual void init( const VarSet &/*ns*/ ) { DAI_THROW(NOT_IMPLEMENTED); } virtual Real run(); virtual Real maxDiff() const { DAI_THROW(NOT_IMPLEMENTED); return 0.0; } virtual size_t Iterations() const { DAI_THROW(NOT_IMPLEMENTED); return 0; } virtual void setProperties( const PropertySet &opts ); virtual PropertySet getProperties() const; virtual std::string printProperties() const; //@} /// \name Additional interface specific for JTree //@{ /// Calculates marginal probability distribution for variables \a vs /** \note The complexity of this calculation is exponential in the number of variables. */ Factor calcMarginal( const VarSet &vs ) const; //@} private: /// Helper function for constructors void construct(); }; } // end of namespace dai #endif libDAI-0.2.4/include/dai/enum.h0000644000263000017630000000631611334764775015001 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines the DAI_ENUM macro, which can be used to define an \c enum with additional functionality. #ifndef __defined_libdai_enum_h #define __defined_libdai_enum_h #include #include #include /// Extends the C++ \c enum type by supporting input/output streaming and conversion to and from const char* and \c size_t /** For more details see the source code. * * \par Example: * \code * DAI_ENUM(colors,RED,GREEN,BLUE) * \endcode * defines a class \a colors encapsulating an * \code * enum {RED, GREEN, BLUE}; * \endcode * which offers additional functionality over the plain \c enum keyword. */ #define DAI_ENUM(x,val0,...) class x {\ public:\ enum value {val0,__VA_ARGS__};\ \ x() : v(val0) {}\ \ x(value w) : v(w) {}\ \ x(char const *w) {\ static char const* labelstring = #val0 "," #__VA_ARGS__;\ size_t pos_begin = 0;\ size_t i = 0;\ for( size_t pos_end = 0; ; pos_end++ ) {\ if( (labelstring[pos_end] == ',') || (labelstring[pos_end] == '\0') ) {\ if( (strlen( w ) == pos_end - pos_begin) && (strncmp( labelstring + pos_begin, w, pos_end - pos_begin ) == 0) ) {\ v = (value)i;\ return;\ } else {\ i++;\ pos_begin = pos_end + 1;\ }\ }\ if( labelstring[pos_end] == '\0' )\ break;\ }\ DAI_THROWE(UNKNOWN_ENUM_VALUE,"'" + std::string(w) + "' is not in [" + std::string(labelstring) + "]");\ }\ \ operator value() const { return v; }\ \ operator size_t() const { return (size_t)v; }\ \ operator char const*() const {\ static char labelstring[] = #val0 "," #__VA_ARGS__;\ size_t pos_begin = 0;\ size_t i = 0;\ for( size_t pos_end = 0; ; pos_end++ )\ if( (labelstring[pos_end] == ',') || (labelstring[pos_end] == '\0') ) {\ if( (size_t)v == i ) {\ labelstring[pos_end] = '\0';\ return labelstring + pos_begin;\ } else {\ i++;\ pos_begin = pos_end + 1;\ }\ }\ }\ \ friend std::istream& operator >> (std::istream& is, x& y) {\ std::string s;\ is >> s;\ y = x(s.c_str());\ return is;\ }\ \ friend std::ostream& operator << (std::ostream& os, const x& y) {\ os << (const char *)y;\ return os;\ }\ \ protected:\ value v;\ }; #endif libDAI-0.2.4/include/dai/mf.h0000644000263000017630000000672111334764775014437 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines class MF which implements the Mean Field algorithm #ifndef __defined_libdai_mf_h #define __defined_libdai_mf_h #include #include #include #include namespace dai { /// Approximate inference algorithm "Mean Field" /** The Mean Field algorithm iteratively calculates approximations of * single variable marginals (beliefs). The update equation for * a single belief \f$b_i\f$ is given by: * \f[ b_i^{\mathrm{new}}(x_i) \propto \prod_{I\in N_i} \exp \left( \sum_{x_{N_I \setminus \{i\}}} \log f_I(x_I) \prod_{j \in N_I \setminus \{i\}} b_j(x_j) \right) \f] * These update equations are performed for all variables until convergence. */ class MF : public DAIAlgFG { private: /// Current approximations of single variable marginals std::vector _beliefs; /// Maximum difference encountered so far Real _maxdiff; /// Number of iterations needed size_t _iters; public: /// Parameters for MF struct Properties { /// Verbosity (amount of output sent to stderr) size_t verbose; /// Maximum number of iterations size_t maxiter; /// Tolerance for convergence test Real tol; /// Damping constant (0.0 means no damping, 1.0 is maximum damping) Real damping; } props; /// Name of this inference algorithm static const char *Name; public: /// \name Constructors/destructors //@{ /// Default constructor MF() : DAIAlgFG(), _beliefs(), _maxdiff(0.0), _iters(0U), props() {} /// Construct from FactorGraph \a fg and PropertySet \a opts /** \param opts Parameters @see Properties */ MF( const FactorGraph &fg, const PropertySet &opts ) : DAIAlgFG(fg), _beliefs(), _maxdiff(0.0), _iters(0U), props() { setProperties( opts ); construct(); } //@} /// \name General InfAlg interface //@{ virtual MF* clone() const { return new MF(*this); } virtual std::string identify() const; virtual Factor belief( const Var &v ) const { return beliefV( findVar( v ) ); } virtual Factor belief( const VarSet &vs ) const; virtual Factor beliefV( size_t i ) const; virtual std::vector beliefs() const; virtual Real logZ() const; virtual void init(); virtual void init( const VarSet &ns ); virtual Real run(); virtual Real maxDiff() const { return _maxdiff; } virtual size_t Iterations() const { return _iters; } virtual void setProperties( const PropertySet &opts ); virtual PropertySet getProperties() const; virtual std::string printProperties() const; //@} private: /// Helper function for constructors void construct(); /// Calculates an updated belief of variable \a i Factor calcNewBelief( size_t i ); }; } // end of namespace dai #endif libDAI-0.2.4/include/dai/smallset.h0000644000263000017630000002143111334764775015654 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2002 Martijn Leisink [martijn@mbfys.kun.nl] * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2002-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines the SmallSet<> class, which represents a set (optimized for a small number of elements). #ifndef __defined_libdai_smallset_h #define __defined_libdai_smallset_h #include #include namespace dai { /// Represents a set; the implementation is optimized for a small number of elements. /** SmallSet uses an ordered std::vector<T> to represent a set; this is faster than * using a std::set<T> if the number of elements is small. * \tparam T Should be less-than-comparable. */ template class SmallSet { private: /// The elements in this set std::vector _elements; public: /// \name Constructors and destructors //@{ /// Default constructor (constructs an empty set) SmallSet() : _elements() {} /// Construct a set consisting of one element SmallSet( const T &t ) : _elements() { _elements.push_back( t ); } /// Construct a set consisting of two elements SmallSet( const T &t1, const T &t2 ) { if( t1 < t2 ) { _elements.push_back( t1 ); _elements.push_back( t2 ); } else if( t2 < t1 ) { _elements.push_back( t2 ); _elements.push_back( t1 ); } else _elements.push_back( t1 ); } /// Construct a SmallSet from a range of elements. /** \tparam TIterator Iterates over instances of type \a T. * \param begin Points to first element to be added. * \param end Points just beyond last element to be added. * \param sizeHint For efficiency, the number of elements can be speficied by \a sizeHint. */ template SmallSet( TIterator begin, TIterator end, size_t sizeHint=0 ) { _elements.reserve( sizeHint ); _elements.insert( _elements.begin(), begin, end ); std::sort( _elements.begin(), _elements.end() ); typename std::vector::iterator new_end = std::unique( _elements.begin(), _elements.end() ); _elements.erase( new_end, _elements.end() ); } //@} /// \name Operators for set-theoretic operations //@{ /// Set-minus operator: returns all elements in \c *this, except those in \a x SmallSet operator/ ( const SmallSet& x ) const { SmallSet res; std::set_difference( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end(), inserter( res._elements, res._elements.begin() ) ); return res; } /// Set-union operator: returns all elements in \c *this, plus those in \a x SmallSet operator| ( const SmallSet& x ) const { SmallSet res; std::set_union( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end(), inserter( res._elements, res._elements.begin() ) ); return res; } /// Set-intersection operator: returns all elements in \c *this that are also contained in \a x SmallSet operator& ( const SmallSet& x ) const { SmallSet res; std::set_intersection( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end(), inserter( res._elements, res._elements.begin() ) ); return res; } /// Erases from \c *this all elements in \a x SmallSet& operator/= ( const SmallSet& x ) { return (*this = (*this / x)); } /// Erases one element SmallSet& operator/= ( const T &t ) { typename std::vector::iterator pos = lower_bound( _elements.begin(), _elements.end(), t ); if( pos != _elements.end() ) if( *pos == t ) // found element, delete it _elements.erase( pos ); return *this; } /// Adds to \c *this all elements in \a x SmallSet& operator|= ( const SmallSet& x ) { return( *this = (*this | x) ); } /// Adds one element SmallSet& operator|= ( const T& t ) { typename std::vector::iterator pos = lower_bound( _elements.begin(), _elements.end(), t ); if( pos == _elements.end() || *pos != t ) // insert it _elements.insert( pos, t ); return *this; } /// Erases from \c *this all elements not in \a x SmallSet& operator&= ( const SmallSet& x ) { return (*this = (*this & x)); } /// Returns \c true if \c *this is a subset of \a x bool operator<< ( const SmallSet& x ) const { return std::includes( x._elements.begin(), x._elements.end(), _elements.begin(), _elements.end() ); } /// Returns \c true if \a x is a subset of \c *this bool operator>> ( const SmallSet& x ) const { return std::includes( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end() ); } //@} /// \name Queries //@{ /// Returns \c true if \c *this and \a x have elements in common bool intersects( const SmallSet& x ) const { return( (*this & x).size() > 0 ); } /// Returns \c true if \c *this contains the element \a t bool contains( const T &t ) const { return std::binary_search( _elements.begin(), _elements.end(), t ); } /// Returns number of elements typename std::vector::size_type size() const { return _elements.size(); } /// Returns whether \c *this is empty bool empty() const { return _elements.size() == 0; } /// Returns reference to the elements std::vector& elements() { return _elements; } /// Returns constant reference to the elements const std::vector& elements() const { return _elements; } //@} /// Constant iterator over the elements typedef typename std::vector::const_iterator const_iterator; /// Iterator over the elements typedef typename std::vector::iterator iterator; /// Constant reverse iterator over the elements typedef typename std::vector::const_reverse_iterator const_reverse_iterator; /// Reverse iterator over the elements typedef typename std::vector::reverse_iterator reverse_iterator; /// \name Iterator interface //@{ /// Returns iterator that points to the first element iterator begin() { return _elements.begin(); } /// Returns constant iterator that points to the first element const_iterator begin() const { return _elements.begin(); } /// Returns iterator that points beyond the last element iterator end() { return _elements.end(); } /// Returns constant iterator that points beyond the last element const_iterator end() const { return _elements.end(); } /// Returns reverse iterator that points to the last element reverse_iterator rbegin() { return _elements.rbegin(); } /// Returns constant reverse iterator that points to the last element const_reverse_iterator rbegin() const { return _elements.rbegin(); } /// Returns reverse iterator that points beyond the first element reverse_iterator rend() { return _elements.rend(); } /// Returns constant reverse iterator that points beyond the first element const_reverse_iterator rend() const { return _elements.rend(); } /// Returns reference to first element T& front() { return _elements.at(0); } /// Returns constant reference to first element const T& front() const { return _elements.at(0); } //@} /// \name Comparison operators //@{ /// Returns \c true if \a a and \a b are identical friend bool operator==( const SmallSet &a, const SmallSet &b ) { return (a._elements == b._elements); } /// Returns \c true if \a a and \a b are not identical friend bool operator!=( const SmallSet &a, const SmallSet &b ) { return !(a._elements == b._elements); } /// Lexicographical comparison of elements friend bool operator<( const SmallSet &a, const SmallSet &b ) { return a._elements < b._elements; } //@} }; } // end of namespace dai #endif libDAI-0.2.4/include/dai/varset.h0000644000263000017630000001642611334764775015344 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2002 Martijn Leisink [martijn@mbfys.kun.nl] * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2002-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines the VarSet class, which represents a set of random variables. #ifndef __defined_libdai_varset_h #define __defined_libdai_varset_h #include #include #include #include #include #include namespace dai { // Predefine for definitions of calcLinearState() and calcState() class VarSet; /// Calculates the linear index in the Cartesian product of the variables in \a vs that corresponds to a particular joint assignment of the variables, specified by \a state. /** \param vs Set of variables for which the linear state should be calculated; * \param state Specifies the states of some variables. * \return The linear index in the Cartesian product of the variables in \a vs * corresponding with the joint assignment specified by \a state, where variables * for which no state is specified are assumed to be in state 0. * * The linear index is calculated as follows. The variables in \a vs are * ordered according to their label (in ascending order); say \a vs corresponds with * the set \f$\{x_{l(0)},x_{l(1)},\dots,x_{l(n-1)}\}\f$ with \f$l(0) < l(1) < \dots < l(n-1)\f$, * where variable \f$x_l\f$ has label \a l. Denote by \f$S_l\f$ the number of possible values * ("states") of variable \f$x_l\f$. The argument \a state corresponds * with a mapping \a s that assigns to each variable \f$x_l\f$ a state \f$s(x_l) \in \{0,1,\dots,S_l-1\}\f$, * where \f$s(x_l)=0\f$ if \f$x_l\f$ is not specified in \a state. The linear index \f$S\f$ corresponding * with \a state is now calculated by: * \f{eqnarray*} * S &:=& \sum_{i=0}^{n-1} s(x_{l(i)}) \prod_{j=0}^{i-1} S_{l(j)} \\ * &= & s(x_{l(0)}) + s(x_{l(1)}) S_{l(0)} + s(x_{l(2)}) S_{l(0)} S_{l(1)} + \dots + s(x_{l(n-1)}) S_{l(0)} \cdots S_{l(n-2)}. * \f} * * \note If \a vs corresponds with \f$\{x_l\}_{l\in L}\f$, and \a state specifies a state * for each variable \f$x_l\f$ for \f$l\in L\f$, calcLinearState() induces a mapping * \f$\sigma : \prod_{l\in L} X_l \to \{0,1,\dots,\prod_{l\in L} S_l-1\}\f$ that * maps a joint state to a linear index; this is the inverse of the mapping * \f$\sigma^{-1}\f$ induced by calcState(). * * \see calcState() */ size_t calcLinearState( const VarSet &vs, const std::map &state ); /// Calculates the joint assignment of the variables in \a vs corresponding to the linear index \a linearState. /** \param vs Set of variables to which \a linearState refers * \param linearState should be smaller than vs.nrStates(). * \return A mapping \f$s\f$ that maps each Var \f$x_l\f$ in \a vs to its state \f$s(x_l)\f$, as specified by \a linearState. * * The variables in \a vs are ordered according to their label (in ascending order); say \a vs corresponds with * the set \f$\{x_{l(0)},x_{l(1)},\dots,x_{l(n-1)}\}\f$ with \f$l(0) < l(1) < \dots < l(n-1)\f$, * where variable \f$x_l\f$ has label \a l. Denote by \f$S_l\f$ the number of possible values * ("states") of variable \f$x_l\f$ with label \a l. * The mapping \f$s\f$ returned by this function is defined as: * \f{eqnarray*} * s(x_{l(i)}) = \left\lfloor\frac{S \mbox { mod } \prod_{j=0}^{i} S_{l(j)}}{\prod_{j=0}^{i-1} S_{l(j)}}\right\rfloor \qquad \mbox{for all $i=0,\dots,n-1$}. * \f} * where \f$S\f$ denotes the value of \a linearState. * * \note If \a vs corresponds with \f$\{x_l\}_{l\in L}\f$, calcState() induces a mapping * \f$\sigma^{-1} : \{0,1,\dots,\prod_{l\in L} S_l-1\} \to \prod_{l\in L} X_l\f$ that * maps a linear index to a joint state; this is the inverse of the mapping \f$\sigma\f$ * induced by calcLinearState(). * * \see calcLinearState() */ std::map calcState( const VarSet &vs, size_t linearState ); /// Represents a set of variables. /** \note A VarSet is implemented using a SmallSet instead * of the more natural std::set because of efficiency reasons. * That is, internally, the variables in the set are sorted ascendingly * according to their labels. */ class VarSet : public SmallSet { public: /// \name Constructors and destructors //@{ /// Default constructor (constructs an empty set) VarSet() : SmallSet() {} /// Construct from \link SmallSet \endlink<\link Var \endlink> \a x VarSet( const SmallSet &x ) : SmallSet(x) {} /// Construct a VarSet with one element, \a v VarSet( const Var &v ) : SmallSet(v) {} /// Construct a VarSet with two elements, \a v1 and \a v2 VarSet( const Var &v1, const Var &v2 ) : SmallSet(v1,v2) {} /// Construct a VarSet from the range between \a begin and \a end. /** \tparam VarIterator Iterates over instances of type Var. * \param begin Points to first Var to be added. * \param end Points just beyond last Var to be added. * \param sizeHint For efficiency, the number of elements can be speficied by \a sizeHint. */ template VarSet( VarIterator begin, VarIterator end, size_t sizeHint=0 ) : SmallSet(begin,end,sizeHint) {} //@} /// \name Queries //@{ /// Calculates the number of states of this VarSet, which is simply the number of possible joint states of the variables in \c *this. /** The number of states of the Cartesian product of the variables in this VarSet * is simply the product of the number of states of each variable in this VarSet. * If \c *this corresponds with the set \f$\{x_l\}_{l\in L}\f$, * where variable \f$x_l\f$ has label \f$l\f$, and denoting by \f$S_l\f$ the * number of possible values ("states") of variable \f$x_l\f$, the number of * joint configurations of the variables in \f$\{x_l\}_{l\in L}\f$ is given by \f$\prod_{l\in L} S_l\f$. */ size_t nrStates() const { size_t states = 1; for( VarSet::const_iterator n = begin(); n != end(); n++ ) { size_t newStates = states * n->states(); DAI_ASSERT( newStates >= states ); states = newStates; } return states; } //@} /// \name Input and output //@{ /// Writes a VarSet to an output stream friend std::ostream& operator<<( std::ostream &os, const VarSet &vs ) { os << "{"; for( VarSet::const_iterator v = vs.begin(); v != vs.end(); v++ ) os << (v != vs.begin() ? ", " : "") << *v; os << "}"; return( os ); } //@} }; } // end of namespace dai /** \example example_varset.cpp * This example shows how to use the Var, VarSet and State classes. It also explains the concept of "states" for VarSets. * * \section Output * \verbinclude examples/example_varset.out * * \section Source */ #endif libDAI-0.2.4/include/dai/bbp.h0000644000263000017630000004451611334764775014604 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Frederik Eaton [frederik at ofb dot net] * Copyright (C) 2009-2010 Joris Mooij [joris dot mooij at libdai dot org] */ /// \file /// \brief Defines class BBP, which implements Back-Belief-Propagation /// \todo Clean up code #ifndef ___defined_libdai_bbp_h #define ___defined_libdai_bbp_h #include #include #include #include #include #include #include namespace dai { /// Enumeration of several cost functions that can be used with BBP /** \note This class is meant as a base class for BBPCostFunction, which provides additional functionality. */ DAI_ENUM(BBPCostFunctionBase,CFN_GIBBS_B,CFN_GIBBS_B2,CFN_GIBBS_EXP,CFN_GIBBS_B_FACTOR,CFN_GIBBS_B2_FACTOR,CFN_GIBBS_EXP_FACTOR,CFN_VAR_ENT,CFN_FACTOR_ENT,CFN_BETHE_ENT); /// Predefined cost functions that can be used with BBP class BBPCostFunction : public BBPCostFunctionBase { public: /// Default constructor BBPCostFunction() : BBPCostFunctionBase() {} /// Construct from BBPCostFunctionBase \a x BBPCostFunction( const BBPCostFunctionBase &x ) : BBPCostFunctionBase(x) {} /// Returns whether this cost function depends on having a Gibbs state bool needGibbsState() const; /// Evaluates cost function in state \a stateP using the information in inference algorithm \a ia Real evaluate( const InfAlg &ia, const std::vector *stateP ) const; /// Assignment operator BBPCostFunction& operator=( const BBPCostFunctionBase &x ) { if( this != &x ) { (BBPCostFunctionBase)*this = x; } return *this; } }; /// Implements BBP (Back-Belief-Propagation) [\ref EaG09] /** \author Frederik Eaton */ class BBP { private: /// \name Input variables //@{ /// Stores a BP_dual helper object BP_dual _bp_dual; /// Pointer to the factor graph const FactorGraph *_fg; /// Pointer to the approximate inference algorithm (currently, only BP objects are supported) const InfAlg *_ia; //@} /// \name Output variables //@{ /// Variable factor adjoints std::vector _adj_psi_V; /// Factor adjoints std::vector _adj_psi_F; /// Variable->factor message adjoints (indexed [i][_I]) std::vector > _adj_n; /// Factor->variable message adjoints (indexed [i][_I]) std::vector > _adj_m; /// Normalized variable belief adjoints std::vector _adj_b_V; /// Normalized factor belief adjoints std::vector _adj_b_F; //@} /// \name Internal state variables //@{ /// Initial variable factor adjoints std::vector _init_adj_psi_V; /// Initial factor adjoints std::vector _init_adj_psi_F; /// Unnormalized variable->factor message adjoint (indexed [i][_I]) std::vector > _adj_n_unnorm; /// Unnormalized factor->variable message adjoint (indexed [i][_I]) std::vector > _adj_m_unnorm; /// Updated normalized variable->factor message adjoint (indexed [i][_I]) std::vector > _new_adj_n; /// Updated normalized factor->variable message adjoint (indexed [i][_I]) std::vector > _new_adj_m; /// Unnormalized variable belief adjoints std::vector _adj_b_V_unnorm; /// Unnormalized factor belief adjoints std::vector _adj_b_F_unnorm; /// _Tmsg[i][_I] (see eqn. (41) in [\ref EaG09]) std::vector > _Tmsg; /// _Umsg[I][_i] (see eqn. (42) in [\ref EaG09]) std::vector > _Umsg; /// _Smsg[i][_I][_j] (see eqn. (43) in [\ref EaG09]) std::vector > > _Smsg; /// _Rmsg[I][_i][_J] (see eqn. (44) in [\ref EaG09]) std::vector > > _Rmsg; /// Number of iterations done size_t _iters; //@} /// \name Index cache management (for performance) //@{ /// Index type typedef std::vector _ind_t; /// Cached indices (indexed [i][_I]) std::vector > _indices; /// Prepares index cache _indices /** \see bp.cpp */ void RegenerateInds(); /// Returns an index from the cache const _ind_t& _index(size_t i, size_t _I) const { return _indices[i][_I]; } //@} /// \name Initialization helper functions //@{ /// Calculate T values; see eqn. (41) in [\ref EaG09] void RegenerateT(); /// Calculate U values; see eqn. (42) in [\ref EaG09] void RegenerateU(); /// Calculate S values; see eqn. (43) in [\ref EaG09] void RegenerateS(); /// Calculate R values; see eqn. (44) in [\ref EaG09] void RegenerateR(); /// Calculate _adj_b_V_unnorm and _adj_b_F_unnorm from _adj_b_V and _adj_b_F void RegenerateInputs(); /// Initialise members for factor adjoints /** \pre RegenerateInputs() should be called first */ void RegeneratePsiAdjoints(); /// Initialise members for message adjoints for parallel algorithm /** \pre RegenerateInputs() should be called first */ void RegenerateParMessageAdjoints(); /// Initialise members for message adjoints for sequential algorithm /** Same as RegenerateMessageAdjoints, but calls sendSeqMsgN rather * than updating _adj_n (and friends) which are unused in the sequential algorithm. * \pre RegenerateInputs() should be called first */ void RegenerateSeqMessageAdjoints(); /// Called by \a init, recalculates intermediate values void Regenerate(); //@} /// \name Accessors/mutators //@{ /// Returns reference to T value; see eqn. (41) in [\ref EaG09] Prob & T(size_t i, size_t _I) { return _Tmsg[i][_I]; } /// Returns constant reference to T value; see eqn. (41) in [\ref EaG09] const Prob & T(size_t i, size_t _I) const { return _Tmsg[i][_I]; } /// Returns reference to U value; see eqn. (42) in [\ref EaG09] Prob & U(size_t I, size_t _i) { return _Umsg[I][_i]; } /// Returns constant reference to U value; see eqn. (42) in [\ref EaG09] const Prob & U(size_t I, size_t _i) const { return _Umsg[I][_i]; } /// Returns reference to S value; see eqn. (43) in [\ref EaG09] Prob & S(size_t i, size_t _I, size_t _j) { return _Smsg[i][_I][_j]; } /// Returns constant reference to S value; see eqn. (43) in [\ref EaG09] const Prob & S(size_t i, size_t _I, size_t _j) const { return _Smsg[i][_I][_j]; } /// Returns reference to R value; see eqn. (44) in [\ref EaG09] Prob & R(size_t I, size_t _i, size_t _J) { return _Rmsg[I][_i][_J]; } /// Returns constant reference to R value; see eqn. (44) in [\ref EaG09] const Prob & R(size_t I, size_t _i, size_t _J) const { return _Rmsg[I][_i][_J]; } /// Returns reference to variable->factor message adjoint Prob& adj_n(size_t i, size_t _I) { return _adj_n[i][_I]; } /// Returns constant reference to variable->factor message adjoint const Prob& adj_n(size_t i, size_t _I) const { return _adj_n[i][_I]; } /// Returns reference to factor->variable message adjoint Prob& adj_m(size_t i, size_t _I) { return _adj_m[i][_I]; } /// Returns constant reference to factor->variable message adjoint const Prob& adj_m(size_t i, size_t _I) const { return _adj_m[i][_I]; } //@} /// \name Parallel algorithm //@{ /// Calculates new variable->factor message adjoint /** Increases variable factor adjoint according to eqn. (27) in [\ref EaG09] and * calculates the new variable->factor message adjoint according to eqn. (29) in [\ref EaG09]. */ void calcNewN( size_t i, size_t _I ); /// Calculates new factor->variable message adjoint /** Increases factor adjoint according to eqn. (28) in [\ref EaG09] and * calculates the new factor->variable message adjoint according to the r.h.s. of eqn. (30) in [\ref EaG09]. */ void calcNewM( size_t i, size_t _I ); /// Calculates unnormalized variable->factor message adjoint from the normalized one void calcUnnormMsgN( size_t i, size_t _I ); /// Calculates unnormalized factor->variable message adjoint from the normalized one void calcUnnormMsgM( size_t i, size_t _I ); /// Updates (un)normalized variable->factor message adjoints void upMsgN( size_t i, size_t _I ); /// Updates (un)normalized factor->variable message adjoints void upMsgM( size_t i, size_t _I ); /// Do one parallel update of all message adjoints void doParUpdate(); //@} /// \name Sequential algorithm //@{ /// Helper function for sendSeqMsgM(): increases factor->variable message adjoint by \a p and calculates the corresponding unnormalized adjoint void incrSeqMsgM( size_t i, size_t _I, const Prob& p ); // DISABLED BECAUSE IT IS BUGGY: // void updateSeqMsgM( size_t i, size_t _I ); /// Sets normalized factor->variable message adjoint and calculates the corresponding unnormalized adjoint void setSeqMsgM( size_t i, size_t _I, const Prob &p ); /// Implements routine Send-n in Figure 5 in [\ref EaG09] void sendSeqMsgN( size_t i, size_t _I, const Prob &f ); /// Implements routine Send-m in Figure 5 in [\ref EaG09] void sendSeqMsgM( size_t i, size_t _I ); //@} /// Computes the adjoint of the unnormed probability vector from the normalizer and the adjoint of the normalized probability vector /** \see eqn. (13) in [\ref EaG09] */ Prob unnormAdjoint( const Prob &w, Real Z_w, const Prob &adj_w ); /// Calculates averaged L1 norm of unnormalized message adjoints Real getUnMsgMag(); /// Calculates averaged L1 norms of current and new normalized message adjoints void getMsgMags( Real &s, Real &new_s ); /// Returns indices and magnitude of the largest normalized factor->variable message adjoint void getArgmaxMsgM( size_t &i, size_t &_I, Real &mag ); /// Returns magnitude of the largest (in L1-norm) normalized factor->variable message adjoint Real getMaxMsgM(); /// Calculates sum of L1 norms of all normalized factor->variable message adjoints Real getTotalMsgM(); /// Calculates sum of L1 norms of all updated normalized factor->variable message adjoints Real getTotalNewMsgM(); /// Calculates sum of L1 norms of all normalized variable->factor message adjoints Real getTotalMsgN(); /// Returns a vector of Probs (filled with zeroes) with state spaces corresponding to the factors in the factor graph \a fg std::vector getZeroAdjF( const FactorGraph &fg ); /// Returns a vector of Probs (filled with zeroes) with state spaces corresponding to the variables in the factor graph \a fg std::vector getZeroAdjV( const FactorGraph &fg ); public: /// \name Constructors/destructors //@{ /// Construct BBP object from a InfAlg \a ia and a PropertySet \a opts /** \param ia should be a BP object or something compatible * \param opts Parameters @see Properties */ BBP( const InfAlg *ia, const PropertySet &opts ) : _bp_dual(ia), _fg(&(ia->fg())), _ia(ia) { props.set(opts); } //@} /// \name Initialization //@{ /// Initializes from given belief adjoints \a adj_b_V, \a adj_b_F and initial factor adjoints \a adj_psi_V, \a adj_psi_F void init( const std::vector &adj_b_V, const std::vector &adj_b_F, const std::vector &adj_psi_V, const std::vector &adj_psi_F ) { _adj_b_V = adj_b_V; _adj_b_F = adj_b_F; _init_adj_psi_V = adj_psi_V; _init_adj_psi_F = adj_psi_F; Regenerate(); } /// Initializes from given belief adjoints \a adj_b_V and \a adj_b_F (setting initial factor adjoints to zero) void init( const std::vector &adj_b_V, const std::vector &adj_b_F ) { init( adj_b_V, adj_b_F, getZeroAdjV(*_fg), getZeroAdjF(*_fg) ); } /// Initializes variable belief adjoints \a adj_b_V (and sets factor belief adjoints and initial factor adjoints to zero) void init_V( const std::vector &adj_b_V ) { init( adj_b_V, getZeroAdjF(*_fg) ); } /// Initializes factor belief adjoints \a adj_b_F (and sets variable belief adjoints and initial factor adjoints to zero) void init_F( const std::vector &adj_b_F ) { init( getZeroAdjV(*_fg), adj_b_F ); } /// Initializes with adjoints calculated from cost function \a cfn, and state \a stateP /** Uses the internal pointer to an inference algorithm in combination with the cost function and state for initialization. * \param cfn Cost function used for initialization; * \param stateP is a Gibbs state and can be NULL; it will be initialised using a Gibbs run. */ void initCostFnAdj( const BBPCostFunction &cfn, const std::vector *stateP ); //@} /// \name BBP Algorithm //@{ /// Perform iterative updates until change is less than given tolerance void run(); //@} /// \name Query results //@{ /// Returns reference to variable factor adjoint Prob& adj_psi_V(size_t i) { return _adj_psi_V[i]; } /// Returns constant reference to variable factor adjoint const Prob& adj_psi_V(size_t i) const { return _adj_psi_V[i]; } /// Returns reference to factor adjoint Prob& adj_psi_F(size_t I) { return _adj_psi_F[I]; } /// Returns constant reference to factor adjoint const Prob& adj_psi_F(size_t I) const { return _adj_psi_F[I]; } /// Returns reference to variable belief adjoint Prob& adj_b_V(size_t i) { return _adj_b_V[i]; } /// Returns constant reference to variable belief adjoint const Prob& adj_b_V(size_t i) const { return _adj_b_V[i]; } /// Returns reference to factor belief adjoint Prob& adj_b_F(size_t I) { return _adj_b_F[I]; } /// Returns constant reference to factor belief adjoint const Prob& adj_b_F(size_t I) const { return _adj_b_F[I]; } /// Return number of iterations done so far size_t Iterations() { return _iters; } //@} public: /// Parameters for BBP /* PROPERTIES(props,BBP) { /// Enumeration of possible update schedules /// The following update schedules are defined: /// - SEQ_FIX fixed sequential updates /// - SEQ_MAX maximum residual updates (inspired by [\ref EMK06]) /// - SEQ_BP_REV schedule used by BP, but reversed /// - SEQ_BP_FWD schedule used by BP /// - PAR parallel updates DAI_ENUM(UpdateType,SEQ_FIX,SEQ_MAX,SEQ_BP_REV,SEQ_BP_FWD,PAR); /// Verbosity (amount of output sent to stderr) size_t verbose; /// Maximum number of iterations size_t maxiter; /// Tolerance for convergence test /// \note Not used for updates = SEQ_BP_REV, SEQ_BP_FWD Real tol; /// Damping constant (0 for none); damping = 1 - lambda where lambda is the damping constant used in [\ref EaG09] Real damping; /// Update schedule UpdateType updates; // DISABLED BECAUSE IT IS BUGGY: // bool clean_updates; } */ /* {{{ GENERATED CODE: DO NOT EDIT. Created by ./scripts/regenerate-properties include/dai/bbp.h src/bbp.cpp */ struct Properties { /// Enumeration of possible update schedules /** The following update schedules are defined: * - SEQ_FIX fixed sequential updates * - SEQ_MAX maximum residual updates (inspired by [\ref EMK06]) * - SEQ_BP_REV schedule used by BP, but reversed * - SEQ_BP_FWD schedule used by BP * - PAR parallel updates */ DAI_ENUM(UpdateType,SEQ_FIX,SEQ_MAX,SEQ_BP_REV,SEQ_BP_FWD,PAR); /// Verbosity (amount of output sent to stderr) size_t verbose; /// Maximum number of iterations size_t maxiter; /// Tolerance for convergence test /** \note Not used for updates = SEQ_BP_REV, SEQ_BP_FWD */ Real tol; /// Damping constant (0 for none); damping = 1 - lambda where lambda is the damping constant used in [\ref EaG09] Real damping; /// Update schedule UpdateType updates; /// Set members from PropertySet /** \throw UNKNOWN_PROPERTY if a Property key is not recognized * \throw NOT_ALL_PROPERTIES_SPECIFIED if an expected Property is missing */ void set(const PropertySet &opts); /// Get members into PropertySet PropertySet get() const; /// Convert to a string which can be parsed as a PropertySet std::string toString() const; } props; /* }}} END OF GENERATED CODE */ }; /// Function to verify the validity of adjoints computed by BBP using numerical differentiation. /** Factors containing a variable are multiplied by small adjustments to verify accuracy of calculated variable factor adjoints. * \param bp BP object; * \param state Global state of all variables; * \param bbp_props BBP parameters; * \param cfn Cost function to be used; * \param h Size of perturbation. * \relates BBP */ Real numericBBPTest( const InfAlg &bp, const std::vector *state, const PropertySet &bbp_props, const BBPCostFunction &cfn, Real h ); } // end of namespace dai #endif libDAI-0.2.4/include/dai/graph.h0000644000263000017630000002625311334764775015140 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines the GraphAL class, which represents an undirected graph as an adjacency list #ifndef __defined_libdai_graph_h #define __defined_libdai_graph_h #include #include #include #include #include namespace dai { /// Represents the neighborhood structure of nodes in an undirected graph. /** A graph has nodes connected by edges. Nodes are indexed by an unsigned integer. * If there are nrNodes() nodes, they are numbered 0,1,2,...,nrNodes()-1. An edge * between node \a n1 and node \a n2 is represented by a GraphAL::Edge(\a n1,\a n2). * * GraphAL is implemented as a sparse adjacency list, i.e., it stores for each node a list of * its neighboring nodes. The list of neighboring nodes is implemented as a vector of Neighbor * structures (accessible by the nb() method). Thus, each node has an associated variable of * type GraphAL::Neighbors, which is a vector of Neighbor structures, describing its * neighboring nodes. */ class GraphAL { public: /// Describes the neighbor relationship of two nodes in a GraphAL. /** Sometimes we want to do an action, such as sending a * message, for all edges in a graph. However, most graphs * will be sparse, so we need some way of storing a set of * the neighbors of a node, which is both fast and * memory-efficient. We also need to be able to go between * viewing node \a a as a neighbor of node \a b, and node \a b * as a neighbor of node \a a. The Neighbor struct solves * both of these problems. Each node has a list of neighbors, * stored as a std::vector<\link Neighbor \endlink>, and * extra information is included in the Neighbor struct which * allows us to access a node as a neighbor of its neighbor * (the \c dual member). * * By convention, variable identifiers naming indices into a * vector of neighbors are prefixed with an underscore ("_"). * The neighbor list which they point into is then understood * from context. For example: * * \code * Real MR::T( size_t i, size_t _j ); * \endcode * * Here, \a i is the "absolute" index of node i, but \a _j is * understood as a "relative" index, giving node \a j 's entry in * nb(i). The corresponding Neighbor structure can be * accessed as nb(i,_j) or nb(i)[_j]. The * absolute index of \a _j, which would be called \a j, can be * recovered from the \c node member: nb(i,_j).node. * The \c iter member gives the relative index \a _j, and the * \c dual member gives the "dual" relative index, i.e., the * index of \a i in \a j 's neighbor list. * * \code * Neighbor n = nb(i,_j); * n.node == j && * n.iter == _j && * nb(n.node,n.dual).node == i * \endcode * * There is no easy way to transform a pair of absolute node * indices \a i and \a j into a Neighbor structure relative * to one of the nodes. Such a feature has never yet been * found to be necessary. Iteration over edges can always be * accomplished using the Neighbor lists, and by writing * functions that accept relative indices: * \code * for( size_t i = 0; i < nrNodes(); ++i ) * foreach( const Neighbor &j, nb(i) ) * T( i, j.iter ); * \endcode */ struct Neighbor { /// Corresponds to the index of this Neighbor entry in the vector of neighbors size_t iter; /// Contains the number of the neighboring node size_t node; /// Contains the "dual" iter size_t dual; /// Default constructor Neighbor() {} /// Constructor that sets the Neighbor members according to the parameters Neighbor( size_t iter, size_t node, size_t dual ) : iter(iter), node(node), dual(dual) {} /// Cast to \c size_t returns \c node member operator size_t () const { return node; } }; /// Describes the neighbors of some node. typedef std::vector Neighbors; /// Represents an edge: an Edge(\a n1,\a n2) corresponds to the edge between node \a n1 and node \a n2. typedef std::pair Edge; private: /// Contains for each node a vector of its neighbors std::vector _nb; /// Used internally by isTree() typedef std::vector levelType; public: /// \name Constructors and destructors //@{ /// Default constructor (creates an empty graph). GraphAL() : _nb() {} /// Constructs GraphAL with \a nr nodes and no edges. GraphAL( size_t nr ) : _nb( nr ) {} /// Constructs GraphAL from a range of edges. /** \tparam EdgeInputIterator Iterator that iterates over instances of GraphAL::Edge. * \param nr The number of nodes. * \param begin Points to the first edge. * \param end Points just beyond the last edge. */ template GraphAL( size_t nr, EdgeInputIterator begin, EdgeInputIterator end ) : _nb() { construct( nr, begin, end ); } //@} /// \name Accessors and mutators //@{ /// Returns constant reference to the \a _n2 'th neighbor of node \a n1 const Neighbor & nb( size_t n1, size_t _n2 ) const { DAI_DEBASSERT( n1 < _nb.size() ); DAI_DEBASSERT( _n2 < _nb[n1].size() ); return _nb[n1][_n2]; } /// Returns reference to the \a _n2 'th neighbor of node \a n1 Neighbor & nb( size_t n1, size_t _n2 ) { DAI_DEBASSERT( n1 < _nb.size() ); DAI_DEBASSERT( _n2 < _nb[n1].size() ); return _nb[n1][_n2]; } /// Returns constant reference to all neighbors of node \a n const Neighbors & nb( size_t n ) const { DAI_DEBASSERT( n < _nb.size() ); return _nb[n]; } /// Returns reference to all neighbors of node \a n Neighbors & nb( size_t n ) { DAI_DEBASSERT( n < _nb.size() ); return _nb[n]; } //@} /// \name Adding nodes and edges //@{ /// (Re)constructs GraphAL from a range of edges. /** \tparam EdgeInputIterator Iterator that iterates over instances of GraphAL::Edge. * \param nr The number of nodes. * \param begin Points to the first edge. * \param end Points just beyond the last edge. */ template void construct( size_t nr, EdgeInputIterator begin, EdgeInputIterator end ); /// Adds a node without neighbors and returns the index of the added node. size_t addNode() { _nb.push_back( Neighbors() ); return _nb.size() - 1; } /// Adds a node, with neighbors specified by a range of nodes. /** \tparam NodeInputIterator Iterator that iterates over instances of \c size_t. * \param begin Points to the first index of the nodes that should become neighbors of the added node. * \param end Points just beyond the last index of the nodes that should become neighbors of the added node. * \param sizeHint For improved efficiency, the size of the range may be specified by \a sizeHint. * \returns Index of the added node. */ template size_t addNode( NodeInputIterator begin, NodeInputIterator end, size_t sizeHint = 0 ) { Neighbors nbsnew; nbsnew.reserve( sizeHint ); size_t iter = 0; for( NodeInputIterator it = begin; it != end; ++it ) { DAI_ASSERT( *it < nrNodes() ); Neighbor nb1new( iter, *it, nb(*it).size() ); Neighbor nb2new( nb(*it).size(), nrNodes(), iter++ ); nbsnew.push_back( nb1new ); nb( *it ).push_back( nb2new ); } _nb.push_back( nbsnew ); return _nb.size() - 1; } /// Adds an edge between node \a n1 and node \a n2. /** If \a check == \c true, only adds the edge if it does not exist already. */ void addEdge( size_t n1, size_t n2, bool check = true ); //@} /// \name Erasing nodes and edges //@{ /// Removes node \a n and all incident edges; indices of other nodes are changed accordingly. void eraseNode( size_t n ); /// Removes edge between node \a n1 and node \a n2. void eraseEdge( size_t n1, size_t n2 ); //@} /// \name Queries //@{ /// Returns number of nodes size_t nrNodes() const { return _nb.size(); } /// Calculates the number of edges, time complexity: O(nrNodes()) size_t nrEdges() const { size_t sum = 0; for( size_t i = 0; i < nrNodes(); i++ ) sum += nb(i).size(); return sum; } /// Returns true if the graph is connected bool isConnected() const; /// Returns true if the graph is a tree, i.e., if it is singly connected and connected. bool isTree() const; /// Checks internal consistency void checkConsistency() const; //@} /// \name Input and output //@{ /// Writes this GraphAL to an output stream in GraphALViz .dot syntax void printDot( std::ostream& os ) const; //@} }; template void GraphAL::construct( size_t nr, EdgeInputIterator begin, EdgeInputIterator end ) { _nb.clear(); _nb.resize( nr ); for( EdgeInputIterator e = begin; e != end; e++ ) { #ifdef DAI_DEBUG addEdge( e->first, e->second, true ); #else addEdge( e->first, e->second, false ); #endif } } /// Creates a fully-connected graph with \a N nodes GraphAL createGraphFull( size_t N ); /// Creates a two-dimensional rectangular grid of \a n1 by \a n2 nodes, which can be \a periodic GraphAL createGraphGrid( size_t n1, size_t n2, bool periodic ); /// Creates a three-dimensional rectangular grid of \a n1 by \a n2 by \a n3 nodes, which can be \a periodic GraphAL createGraphGrid3D( size_t n1, size_t n2, size_t n3, bool periodic ); /// Creates a graph consisting of a single loop of \a N nodes GraphAL createGraphLoop( size_t N ); /// Creates a random tree-structured graph of \a N nodes GraphAL createGraphTree( size_t N ); /// Creates a random regular graph of \a N nodes with uniform connectivity \a d GraphAL createGraphRegular( size_t N, size_t d ); } // end of namespace dai #endif libDAI-0.2.4/include/dai/var.h0000644000263000017630000000743311334764775014626 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2002 Martijn Leisink [martijn@mbfys.kun.nl] * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2002-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines class Var, which represents a discrete random variable. #ifndef __defined_libdai_var_h #define __defined_libdai_var_h #include #include namespace dai { /// Represents a discrete random variable. /** A Var stores the \a label of the variable (a nonnegative integer-valued * unique ID) and the number of possible values (\a states) of that variable. * Two Var objects with the same label are assumed to be identical (i.e., it * is assumed that they have the same number of possible states). * * In the documentation, we use the following notational conventions. The discrete * random variable with label \f$l\f$ is denoted as \f$x_l\f$, and the number * of possible values of this variable as \f$S_l\f$; this is represented in * code by the object Var(\f$l\f$,\f$S_l\f$). The set of possible values of * variable \f$x_l\f$ is denoted \f$X_l := \{0,1,\dots,S_l-1\}\f$. */ class Var { private: /// Label of the variable (its unique ID) size_t _label; /// Number of possible values size_t _states; public: /// Default constructor (creates a variable with label -1 and 0 states) Var() : _label(-1), _states(0) {} /// Constructs a variable with a given label and number of states Var( size_t label, size_t states ) : _label(label), _states(states) {} /// Returns the label size_t label() const { return _label; } /// Returns reference to label size_t& label() { return _label; } /// Returns the number of states size_t states () const { return _states; } /// Returns reference to number of states size_t& states () { return _states; } /// Smaller-than operator (only compares labels) bool operator < ( const Var& n ) const { return( _label < n._label ); } /// Larger-than operator (only compares labels) bool operator > ( const Var& n ) const { return( _label > n._label ); } /// Smaller-than-or-equal-to operator (only compares labels) bool operator <= ( const Var& n ) const { #ifdef DAI_DEBUG if( _label == n._label ) DAI_ASSERT( _states == n._states ); #endif return( _label <= n._label ); } /// Larger-than-or-equal-to operator (only compares labels) bool operator >= ( const Var& n ) const { #ifdef DAI_DEBUG if( _label == n._label ) DAI_ASSERT( _states == n._states ); #endif return( _label >= n._label ); } /// Not-equal-to operator (only compares labels) bool operator != ( const Var& n ) const { #ifdef DAI_DEBUG if( _label == n._label ) DAI_ASSERT( _states == n._states ); #endif return( _label != n._label ); } /// Equal-to operator (only compares labels) bool operator == ( const Var& n ) const { #ifdef DAI_DEBUG if( _label == n._label ) DAI_ASSERT( _states == n._states ); #endif return( _label == n._label ); } /// Writes a Var to an output stream friend std::ostream& operator << ( std::ostream& os, const Var& n ) { return( os << "x" << n.label() ); } }; } // end of namespace dai #endif libDAI-0.2.4/Makefile.MACOSX0000644000263000017630000000354011334764775014131 0ustar jorismkyb# This file is part of libDAI - http://www.libdai.org/ # # libDAI is licensed under the terms of the GNU General Public License version # 2, or (at your option) any later version. libDAI is distributed without any # warranty. See the file COPYING for more details. # # Copyright (C) 2009-2010 Joris Mooij [joris dot mooij at libdai dot org] # This template contains configurations for compiling libDAI under Mac OS X # # To use it, simply copy this file to 'Makefile.conf' and adapt 'Makefile.conf' # to your local setup # OPERATING SYSTEM # Choose OS from {LINUX, WINDOWS, CYGWIN, MACOSX} OS=MACOSX # FILE EXTENSIONS # Static library LE=.a # Object file OE=.o # Binary executable EE= # MatLab compiled MEX file ME=.mexglx # COMPILER # Compile using GNU C++ Compiler CC=g++ # Output filename option of the compiler CCO=-o # Flags for the C++ compiler CCFLAGS=-Wno-deprecated -Wall -W -Wextra -fPIC -DMACOSX # Flags to add in debugging mode (if DEBUG=true) CCDEBUGFLAGS=-O3 -g -DDAI_DEBUG # Flags to add in non-debugging mode (if DEBUG=false) CCNODEBUGFLAGS=-O3 # Standard include directories CCINC=-Iinclude -I/opt/local/include # LINKER # Standard libraries to include LIBS=-ldai # For linking with the BOOST Program Options library BOOSTLIBS=-lboost_program_options-mt # Additional library search paths for linker CCLIB=-Llib -L/opt/local/lib # MATLAB # Replace the following by the directory where MatLab has been installed MATLABDIR=/agbs/share/sw/matlab # The following should resolve to the MatLab mex compile command MEX=$(MATLABDIR)/bin/mex # Specify the same C++ compiler and flags to mex MEXFLAGS=CXX\#$(CC) CXXFLAGS\#'$(CCFLAGS)' # SWIG PYTHON INTERFACE # The following should resolve to the SWIG command SWIG=swig # Location of Python header files INCLUDE_PYTHON=/usr/include/python2.5 # Location of Boost C++ library header files INCLUDE_BOOST=/usr/include/boost libDAI-0.2.4/doxygen.conf0000644000263000017630000017607111334764775014036 0ustar jorismkyb# Doxyfile 1.5.9 # This file describes the settings to be used by the documentation system # doxygen (www.doxygen.org) for a project # # All text after a hash (#) is considered a comment and will be ignored # The format is: # TAG = value [value, ...] # For lists items can also be appended using: # TAG += value [value, ...] # Values that contain spaces should be placed between quotes (" ") #--------------------------------------------------------------------------- # Project related configuration options #--------------------------------------------------------------------------- # This tag specifies the encoding used for all characters in the config file # that follow. The default is UTF-8 which is also the encoding used for all # text before the first occurrence of this tag. Doxygen uses libiconv (or the # iconv built into libc) for the transcoding. See # http://www.gnu.org/software/libiconv for the list of possible encodings. DOXYFILE_ENCODING = UTF-8 # The PROJECT_NAME tag is a single word (or a sequence of words surrounded # by quotes) that should identify the project. PROJECT_NAME = libDAI # The PROJECT_NUMBER tag can be used to enter a project or revision number. # This could be handy for archiving the generated documentation or # if some version control system is used. PROJECT_NUMBER = # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) # base path where the generated documentation will be put. # If a relative path is entered, it will be relative to the location # where doxygen was started. If left blank the current directory will be used. OUTPUT_DIRECTORY = doc # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create # 4096 sub-directories (in 2 levels) under the output directory of each output # format and will distribute the generated files over these directories. # Enabling this option can be useful when feeding doxygen a huge amount of # source files, where putting all generated files in the same directory would # otherwise cause performance problems for the file system. CREATE_SUBDIRS = NO # The OUTPUT_LANGUAGE tag is used to specify the language in which all # documentation generated by doxygen is written. Doxygen will use this # information to generate all constant output in the proper language. # The default language is English, other supported languages are: # Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional, # Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German, # Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English # messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian, # Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrilic, Slovak, # Slovene, Spanish, Swedish, Ukrainian, and Vietnamese. OUTPUT_LANGUAGE = English # If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will # include brief member descriptions after the members that are listed in # the file and class documentation (similar to JavaDoc). # Set to NO to disable this. BRIEF_MEMBER_DESC = YES # If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend # the brief description of a member or function before the detailed description. # Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the # brief descriptions will be completely suppressed. REPEAT_BRIEF = YES # This tag implements a quasi-intelligent brief description abbreviator # that is used to form the text in various listings. Each string # in this list, if found as the leading text of the brief description, will be # stripped from the text and the result after processing the whole list, is # used as the annotated text. Otherwise, the brief description is used as-is. # If left blank, the following values are used ("$name" is automatically # replaced with the name of the entity): "The $name class" "The $name widget" # "The $name file" "is" "provides" "specifies" "contains" # "represents" "a" "an" "the" ABBREVIATE_BRIEF = # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then # Doxygen will generate a detailed section even if there is only a brief # description. ALWAYS_DETAILED_SEC = YES # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all # inherited members of a class in the documentation of that class as if those # members were ordinary class members. Constructors, destructors and assignment # operators of the base classes will not be shown. INLINE_INHERITED_MEMB = NO # If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full # path before files name in the file list and in the header files. If set # to NO the shortest path that makes the file name unique will be used. FULL_PATH_NAMES = YES # If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag # can be used to strip a user-defined part of the path. Stripping is # only done if one of the specified strings matches the left-hand part of # the path. The tag can be used to show relative paths in the file list. # If left blank the directory from which doxygen is run is used as the # path to strip. STRIP_FROM_PATH = # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of # the path mentioned in the documentation of a class, which tells # the reader which header file to include in order to use a class. # If left blank only the name of the header file containing the class # definition is used. Otherwise one should specify the include paths that # are normally passed to the compiler using the -I flag. STRIP_FROM_INC_PATH = include/ # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter # (but less readable) file names. This can be useful is your file systems # doesn't support long names like on DOS, Mac, or CD-ROM. SHORT_NAMES = NO # If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen # will interpret the first line (until the first dot) of a JavaDoc-style # comment as the brief description. If set to NO, the JavaDoc # comments will behave just like regular Qt-style comments # (thus requiring an explicit @brief command for a brief description.) JAVADOC_AUTOBRIEF = NO # If the QT_AUTOBRIEF tag is set to YES then Doxygen will # interpret the first line (until the first dot) of a Qt-style # comment as the brief description. If set to NO, the comments # will behave just like regular Qt-style comments (thus requiring # an explicit \brief command for a brief description.) QT_AUTOBRIEF = NO # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen # treat a multi-line C++ special comment block (i.e. a block of //! or /// # comments) as a brief description. This used to be the default behaviour. # The new default is to treat a multi-line C++ comment block as a detailed # description. Set this tag to YES if you prefer the old behaviour instead. MULTILINE_CPP_IS_BRIEF = NO # If the INHERIT_DOCS tag is set to YES (the default) then an undocumented # member inherits the documentation from any documented member that it # re-implements. INHERIT_DOCS = YES # If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce # a new page for each member. If set to NO, the documentation of a member will # be part of the file/class/namespace that contains it. SEPARATE_MEMBER_PAGES = NO # The TAB_SIZE tag can be used to set the number of spaces in a tab. # Doxygen uses this value to replace tabs by spaces in code fragments. TAB_SIZE = 4 # This tag can be used to specify a number of aliases that acts # as commands in the documentation. An alias has the form "name=value". # For example adding "sideeffect=\par Side Effects:\n" will allow you to # put the command \sideeffect (or @sideeffect) in the documentation, which # will result in a user-defined paragraph with heading "Side Effects:". # You can put \n's in the value part of an alias to insert newlines. ALIASES = "idea=\xrefitem ideas \"Idea\" \"Ideas worth exploring\"" # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C # sources only. Doxygen will then generate output that is more tailored for C. # For instance, some of the names that are used will be different. The list # of all members will be omitted, etc. OPTIMIZE_OUTPUT_FOR_C = NO # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java # sources only. Doxygen will then generate output that is more tailored for # Java. For instance, namespaces will be presented as packages, qualified # scopes will look different, etc. OPTIMIZE_OUTPUT_JAVA = NO # Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran # sources only. Doxygen will then generate output that is more tailored for # Fortran. OPTIMIZE_FOR_FORTRAN = NO # Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL # sources. Doxygen will then generate output that is tailored for # VHDL. OPTIMIZE_OUTPUT_VHDL = NO # Doxygen selects the parser to use depending on the extension of the files it parses. # With this tag you can assign which parser to use for a given extension. # Doxygen has a built-in mapping, but you can override or extend it using this tag. # The format is ext=language, where ext is a file extension, and language is one of # the parsers supported by doxygen: IDL, Java, Javascript, C#, C, C++, D, PHP, # Objective-C, Python, Fortran, VHDL, C, C++. For instance to make doxygen treat # .inc files as Fortran files (default is PHP), and .f files as C (default is Fortran), # use: inc=Fortran f=C. Note that for custom extensions you also need to set FILE_PATTERNS otherwise the files are not read by doxygen. EXTENSION_MAPPING = # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want # to include (a tag file for) the STL sources as input, then you should # set this tag to YES in order to let doxygen match functions declarations and # definitions whose arguments contain STL classes (e.g. func(std::string); v.s. # func(std::string) {}). This also make the inheritance and collaboration # diagrams that involve STL classes more complete and accurate. BUILTIN_STL_SUPPORT = YES # If you use Microsoft's C++/CLI language, you should set this option to YES to # enable parsing support. CPP_CLI_SUPPORT = NO # Set the SIP_SUPPORT tag to YES if your project consists of sip sources only. # Doxygen will parse them like normal C++ but will assume all classes use public # instead of private inheritance when no explicit protection keyword is present. SIP_SUPPORT = NO # For Microsoft's IDL there are propget and propput attributes to indicate getter # and setter methods for a property. Setting this option to YES (the default) # will make doxygen to replace the get and set methods by a property in the # documentation. This will only work if the methods are indeed getting or # setting a simple type. If this is not the case, or you want to show the # methods anyway, you should set this option to NO. IDL_PROPERTY_SUPPORT = YES # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC # tag is set to YES, then doxygen will reuse the documentation of the first # member in the group (if any) for the other members of the group. By default # all members of a group must be documented explicitly. DISTRIBUTE_GROUP_DOC = NO # Set the SUBGROUPING tag to YES (the default) to allow class member groups of # the same type (for instance a group of public functions) to be put as a # subgroup of that type (e.g. under the Public Functions section). Set it to # NO to prevent subgrouping. Alternatively, this can be done per class using # the \nosubgrouping command. SUBGROUPING = YES # When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum # is documented as struct, union, or enum with the name of the typedef. So # typedef struct TypeS {} TypeT, will appear in the documentation as a struct # with name TypeT. When disabled the typedef will appear as a member of a file, # namespace, or class. And the struct will be named TypeS. This can typically # be useful for C code in case the coding convention dictates that all compound # types are typedef'ed and only the typedef is referenced, never the tag name. TYPEDEF_HIDES_STRUCT = NO # The SYMBOL_CACHE_SIZE determines the size of the internal cache use to # determine which symbols to keep in memory and which to flush to disk. # When the cache is full, less often used symbols will be written to disk. # For small to medium size projects (<1000 input files) the default value is # probably good enough. For larger projects a too small cache size can cause # doxygen to be busy swapping symbols to and from disk most of the time # causing a significant performance penality. # If the system has enough physical memory increasing the cache will improve the # performance by keeping more symbols in memory. Note that the value works on # a logarithmic scale so increasing the size by one will rougly double the # memory usage. The cache size is given by this formula: # 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0, # corresponding to a cache size of 2^16 = 65536 symbols SYMBOL_CACHE_SIZE = 0 #--------------------------------------------------------------------------- # Build related configuration options #--------------------------------------------------------------------------- # If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in # documentation are documented, even if no documentation was available. # Private class members and static file members will be hidden unless # the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES EXTRACT_ALL = NO # If the EXTRACT_PRIVATE tag is set to YES all private members of a class # will be included in the documentation. EXTRACT_PRIVATE = YES # If the EXTRACT_STATIC tag is set to YES all static members of a file # will be included in the documentation. EXTRACT_STATIC = YES # If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) # defined locally in source files will be included in the documentation. # If set to NO only classes defined in header files are included. EXTRACT_LOCAL_CLASSES = NO # This flag is only useful for Objective-C code. When set to YES local # methods, which are defined in the implementation section but not in # the interface are included in the documentation. # If set to NO (the default) only methods in the interface are included. EXTRACT_LOCAL_METHODS = NO # If this flag is set to YES, the members of anonymous namespaces will be # extracted and appear in the documentation as a namespace called # 'anonymous_namespace{file}', where file will be replaced with the base # name of the file that contains the anonymous namespace. By default # anonymous namespace are hidden. EXTRACT_ANON_NSPACES = NO # If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all # undocumented members of documented classes, files or namespaces. # If set to NO (the default) these members will be included in the # various overviews, but no documentation section is generated. # This option has no effect if EXTRACT_ALL is enabled. HIDE_UNDOC_MEMBERS = NO # If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all # undocumented classes that are normally visible in the class hierarchy. # If set to NO (the default) these classes will be included in the various # overviews. This option has no effect if EXTRACT_ALL is enabled. HIDE_UNDOC_CLASSES = YES # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all # friend (class|struct|union) declarations. # If set to NO (the default) these declarations will be included in the # documentation. HIDE_FRIEND_COMPOUNDS = NO # If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any # documentation blocks found inside the body of a function. # If set to NO (the default) these blocks will be appended to the # function's detailed documentation block. HIDE_IN_BODY_DOCS = NO # The INTERNAL_DOCS tag determines if documentation # that is typed after a \internal command is included. If the tag is set # to NO (the default) then the documentation will be excluded. # Set it to YES to include the internal documentation. INTERNAL_DOCS = NO # If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate # file names in lower-case letters. If set to YES upper-case letters are also # allowed. This is useful if you have classes or files whose names only differ # in case and if your file system supports case sensitive file names. Windows # and Mac users are advised to set this option to NO. CASE_SENSE_NAMES = YES # If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen # will show members with their full class and namespace scopes in the # documentation. If set to YES the scope will be hidden. HIDE_SCOPE_NAMES = NO # If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen # will put a list of the files that are included by a file in the documentation # of that file. SHOW_INCLUDE_FILES = YES # If the INLINE_INFO tag is set to YES (the default) then a tag [inline] # is inserted in the documentation for inline members. INLINE_INFO = YES # If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen # will sort the (detailed) documentation of file and class members # alphabetically by member name. If set to NO the members will appear in # declaration order. SORT_MEMBER_DOCS = NO # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the # brief documentation of file, namespace and class members alphabetically # by member name. If set to NO (the default) the members will appear in # declaration order. SORT_BRIEF_DOCS = NO # If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the # hierarchy of group names into alphabetical order. If set to NO (the default) # the group names will appear in their defined order. SORT_GROUP_NAMES = NO # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be # sorted by fully-qualified names, including namespaces. If set to # NO (the default), the class list will be sorted only by class name, # not including the namespace part. # Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. # Note: This option applies only to the class list, not to the # alphabetical list. SORT_BY_SCOPE_NAME = NO # The GENERATE_TODOLIST tag can be used to enable (YES) or # disable (NO) the todo list. This list is created by putting \todo # commands in the documentation. GENERATE_TODOLIST = YES # The GENERATE_TESTLIST tag can be used to enable (YES) or # disable (NO) the test list. This list is created by putting \test # commands in the documentation. GENERATE_TESTLIST = NO # The GENERATE_BUGLIST tag can be used to enable (YES) or # disable (NO) the bug list. This list is created by putting \bug # commands in the documentation. GENERATE_BUGLIST = NO # The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or # disable (NO) the deprecated list. This list is created by putting # \deprecated commands in the documentation. GENERATE_DEPRECATEDLIST= YES # The ENABLED_SECTIONS tag can be used to enable conditional # documentation sections, marked by \if sectionname ... \endif. ENABLED_SECTIONS = # The MAX_INITIALIZER_LINES tag determines the maximum number of lines # the initial value of a variable or define consists of for it to appear in # the documentation. If the initializer consists of more lines than specified # here it will be hidden. Use a value of 0 to hide initializers completely. # The appearance of the initializer of individual variables and defines in the # documentation can be controlled using \showinitializer or \hideinitializer # command in the documentation regardless of this setting. MAX_INITIALIZER_LINES = 30 # Set the SHOW_USED_FILES tag to NO to disable the list of files generated # at the bottom of the documentation of classes and structs. If set to YES the # list will mention the files that were used to generate the documentation. SHOW_USED_FILES = YES # If the sources in your project are distributed over multiple directories # then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy # in the documentation. The default is NO. SHOW_DIRECTORIES = NO # Set the SHOW_FILES tag to NO to disable the generation of the Files page. # This will remove the Files entry from the Quick Index and from the # Folder Tree View (if specified). The default is YES. SHOW_FILES = YES # Set the SHOW_NAMESPACES tag to NO to disable the generation of the # Namespaces page. # This will remove the Namespaces entry from the Quick Index # and from the Folder Tree View (if specified). The default is YES. SHOW_NAMESPACES = YES # The FILE_VERSION_FILTER tag can be used to specify a program or script that # doxygen should invoke to get the current version for each file (typically from # the version control system). Doxygen will invoke the program by executing (via # popen()) the command , where is the value of # the FILE_VERSION_FILTER tag, and is the name of an input file # provided by doxygen. Whatever the program writes to standard output # is used as the file version. See the manual for examples. FILE_VERSION_FILTER = # The LAYOUT_FILE tag can be used to specify a layout file which will be parsed by # doxygen. The layout file controls the global structure of the generated output files # in an output format independent way. The create the layout file that represents # doxygen's defaults, run doxygen with the -l option. You can optionally specify a # file name after the option, if omitted DoxygenLayout.xml will be used as the name # of the layout file. LAYOUT_FILE = #--------------------------------------------------------------------------- # configuration options related to warning and progress messages #--------------------------------------------------------------------------- # The QUIET tag can be used to turn on/off the messages that are generated # by doxygen. Possible values are YES and NO. If left blank NO is used. QUIET = NO # The WARNINGS tag can be used to turn on/off the warning messages that are # generated by doxygen. Possible values are YES and NO. If left blank # NO is used. WARNINGS = YES # If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings # for undocumented members. If EXTRACT_ALL is set to YES then this flag will # automatically be disabled. WARN_IF_UNDOCUMENTED = YES # If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for # potential errors in the documentation, such as not documenting some # parameters in a documented function, or documenting parameters that # don't exist or using markup commands wrongly. WARN_IF_DOC_ERROR = YES # This WARN_NO_PARAMDOC option can be abled to get warnings for # functions that are documented, but have no documentation for their parameters # or return value. If set to NO (the default) doxygen will only warn about # wrong or incomplete parameter documentation, but not about the absence of # documentation. WARN_NO_PARAMDOC = NO # The WARN_FORMAT tag determines the format of the warning messages that # doxygen can produce. The string should contain the $file, $line, and $text # tags, which will be replaced by the file and line number from which the # warning originated and the warning text. Optionally the format may contain # $version, which will be replaced by the version of the file (if it could # be obtained via FILE_VERSION_FILTER) WARN_FORMAT = "$file:$line: $text" # The WARN_LOGFILE tag can be used to specify a file to which warning # and error messages should be written. If left blank the output is written # to stderr. WARN_LOGFILE = #--------------------------------------------------------------------------- # configuration options related to the input files #--------------------------------------------------------------------------- # The INPUT tag can be used to specify the files and/or directories that contain # documented source files. You may enter file names like "myfile.cpp" or # directories like "/usr/src/myproject". Separate the files or directories # with spaces. INPUT = src \ src/matlab \ include/dai \ include/dai/matlab \ . # This tag can be used to specify the character encoding of the source files # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is # also the default input encoding. Doxygen uses libiconv (or the iconv built # into libc) for the transcoding. See http://www.gnu.org/software/libiconv for # the list of possible encodings. INPUT_ENCODING = UTF-8 # If the value of the INPUT tag contains directories, you can use the # FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp # and *.h) to filter out the source-files in the directories. If left # blank the following patterns are tested: # *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx # *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90 FILE_PATTERNS = # The RECURSIVE tag can be used to turn specify whether or not subdirectories # should be searched for input files as well. Possible values are YES and NO. # If left blank NO is used. RECURSIVE = NO # The EXCLUDE tag can be used to specify files and/or directories that should # excluded from the INPUT source files. This way you can easily exclude a # subdirectory from a directory tree whose root is specified with the INPUT tag. EXCLUDE = # The EXCLUDE_SYMLINKS tag can be used select whether or not files or # directories that are symbolic links (a Unix filesystem feature) are excluded # from the input. EXCLUDE_SYMLINKS = NO # If the value of the INPUT tag contains directories, you can use the # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude # certain files from those directories. Note that the wildcards are matched # against the file with absolute path, so to exclude all test directories # for example use the pattern */test/* EXCLUDE_PATTERNS = # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names # (namespaces, classes, functions, etc.) that should be excluded from the # output. The symbol name can be a fully qualified name, a word, or if the # wildcard * is used, a substring. Examples: ANamespace, AClass, # AClass::ANamespace, ANamespace::*Test EXCLUDE_SYMBOLS = # The EXAMPLE_PATH tag can be used to specify one or more files or # directories that contain example code fragments that are included (see # the \include command). EXAMPLE_PATH = . examples # If the value of the EXAMPLE_PATH tag contains directories, you can use the # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp # and *.h) to filter out the source-files in the directories. If left # blank all files are included. EXAMPLE_PATTERNS = *.cpp *.out COPYING README AUTHORS ChangeLog # If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be # searched for input files to be used with the \include or \dontinclude # commands irrespective of the value of the RECURSIVE tag. # Possible values are YES and NO. If left blank NO is used. EXAMPLE_RECURSIVE = NO # The IMAGE_PATH tag can be used to specify one or more files or # directories that contain image that are included in the documentation (see # the \image command). IMAGE_PATH = # The INPUT_FILTER tag can be used to specify a program that doxygen should # invoke to filter for each input file. Doxygen will invoke the filter program # by executing (via popen()) the command , where # is the value of the INPUT_FILTER tag, and is the name of an # input file. Doxygen will then use the output that the filter program writes # to standard output. # If FILTER_PATTERNS is specified, this tag will be # ignored. INPUT_FILTER = # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern # basis. # Doxygen will compare the file name with each pattern and apply the # filter if there is a match. # The filters are a list of the form: # pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further # info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER # is applied to all files. FILTER_PATTERNS = # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using # INPUT_FILTER) will be used to filter the input files when producing source # files to browse (i.e. when SOURCE_BROWSER is set to YES). FILTER_SOURCE_FILES = NO #--------------------------------------------------------------------------- # configuration options related to source browsing #--------------------------------------------------------------------------- # If the SOURCE_BROWSER tag is set to YES then a list of source files will # be generated. Documented entities will be cross-referenced with these sources. # Note: To get rid of all source code in the generated output, make sure also # VERBATIM_HEADERS is set to NO. SOURCE_BROWSER = NO # Setting the INLINE_SOURCES tag to YES will include the body # of functions and classes directly in the documentation. INLINE_SOURCES = NO # Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct # doxygen to hide any special comment blocks from generated source code # fragments. Normal C and C++ comments will always remain visible. STRIP_CODE_COMMENTS = YES # If the REFERENCED_BY_RELATION tag is set to YES # then for each documented function all documented # functions referencing it will be listed. REFERENCED_BY_RELATION = NO # If the REFERENCES_RELATION tag is set to YES # then for each documented function all documented entities # called/used by that function will be listed. REFERENCES_RELATION = NO # If the REFERENCES_LINK_SOURCE tag is set to YES (the default) # and SOURCE_BROWSER tag is set to YES, then the hyperlinks from # functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will # link to the source code. # Otherwise they will link to the documentation. REFERENCES_LINK_SOURCE = YES # If the USE_HTAGS tag is set to YES then the references to source code # will point to the HTML generated by the htags(1) tool instead of doxygen # built-in source browser. The htags tool is part of GNU's global source # tagging system (see http://www.gnu.org/software/global/global.html). You # will need version 4.8.6 or higher. USE_HTAGS = NO # If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen # will generate a verbatim copy of the header file for each class for # which an include is specified. Set to NO to disable this. VERBATIM_HEADERS = YES #--------------------------------------------------------------------------- # configuration options related to the alphabetical class index #--------------------------------------------------------------------------- # If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index # of all compounds will be generated. Enable this if the project # contains a lot of classes, structs, unions or interfaces. ALPHABETICAL_INDEX = NO # If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then # the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns # in which this list will be split (can be a number in the range [1..20]) COLS_IN_ALPHA_INDEX = 5 # In case all classes in a project start with a common prefix, all # classes will be put under the same header in the alphabetical index. # The IGNORE_PREFIX tag can be used to specify one or more prefixes that # should be ignored while generating the index headers. IGNORE_PREFIX = #--------------------------------------------------------------------------- # configuration options related to the HTML output #--------------------------------------------------------------------------- # If the GENERATE_HTML tag is set to YES (the default) Doxygen will # generate HTML output. GENERATE_HTML = YES # The HTML_OUTPUT tag is used to specify where the HTML docs will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `html' will be used as the default path. HTML_OUTPUT = html # The HTML_FILE_EXTENSION tag can be used to specify the file extension for # each generated HTML page (for example: .htm,.php,.asp). If it is left blank # doxygen will generate files with .html extension. HTML_FILE_EXTENSION = .html # The HTML_HEADER tag can be used to specify a personal HTML header for # each generated HTML page. If it is left blank doxygen will generate a # standard header. HTML_HEADER = # The HTML_FOOTER tag can be used to specify a personal HTML footer for # each generated HTML page. If it is left blank doxygen will generate a # standard footer. HTML_FOOTER = # The HTML_STYLESHEET tag can be used to specify a user-defined cascading # style sheet that is used by each HTML page. It can be used to # fine-tune the look of the HTML output. If the tag is left blank doxygen # will generate a default style sheet. Note that doxygen will try to copy # the style sheet file to the HTML output directory, so don't put your own # stylesheet in the HTML output directory as well, or it will be erased! HTML_STYLESHEET = customdoxygen.css # If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, # files or namespaces will be aligned in HTML using tables. If set to # NO a bullet list will be used. HTML_ALIGN_MEMBERS = YES # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML # documentation will contain sections that can be hidden and shown after the # page has loaded. For this to work a browser that supports # JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox # Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari). HTML_DYNAMIC_SECTIONS = NO # If the GENERATE_DOCSET tag is set to YES, additional index files # will be generated that can be used as input for Apple's Xcode 3 # integrated development environment, introduced with OSX 10.5 (Leopard). # To create a documentation set, doxygen will generate a Makefile in the # HTML output directory. Running make will produce the docset in that # directory and running "make install" will install the docset in # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find # it at startup. # See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html for more information. GENERATE_DOCSET = NO # When GENERATE_DOCSET tag is set to YES, this tag determines the name of the # feed. A documentation feed provides an umbrella under which multiple # documentation sets from a single provider (such as a company or product suite) # can be grouped. DOCSET_FEEDNAME = "Doxygen generated docs" # When GENERATE_DOCSET tag is set to YES, this tag specifies a string that # should uniquely identify the documentation set bundle. This should be a # reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen # will append .docset to the name. DOCSET_BUNDLE_ID = org.doxygen.Project # If the GENERATE_HTMLHELP tag is set to YES, additional index files # will be generated that can be used as input for tools like the # Microsoft HTML help workshop to generate a compiled HTML help file (.chm) # of the generated HTML documentation. GENERATE_HTMLHELP = NO # If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can # be used to specify the file name of the resulting .chm file. You # can add a path in front of the file if the result should not be # written to the html output directory. CHM_FILE = # If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can # be used to specify the location (absolute path including file name) of # the HTML help compiler (hhc.exe). If non-empty doxygen will try to run # the HTML help compiler on the generated index.hhp. HHC_LOCATION = # If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag # controls if a separate .chi index file is generated (YES) or that # it should be included in the master .chm file (NO). GENERATE_CHI = NO # If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING # is used to encode HtmlHelp index (hhk), content (hhc) and project file # content. CHM_INDEX_ENCODING = # If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag # controls whether a binary table of contents is generated (YES) or a # normal table of contents (NO) in the .chm file. BINARY_TOC = NO # The TOC_EXPAND flag can be set to YES to add extra items for group members # to the contents of the HTML help documentation and to the tree view. TOC_EXPAND = NO # If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and QHP_VIRTUAL_FOLDER # are set, an additional index file will be generated that can be used as input for # Qt's qhelpgenerator to generate a Qt Compressed Help (.qch) of the generated # HTML documentation. GENERATE_QHP = NO # If the QHG_LOCATION tag is specified, the QCH_FILE tag can # be used to specify the file name of the resulting .qch file. # The path specified is relative to the HTML output folder. QCH_FILE = # The QHP_NAMESPACE tag specifies the namespace to use when generating # Qt Help Project output. For more information please see # http://doc.trolltech.com/qthelpproject.html#namespace QHP_NAMESPACE = # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating # Qt Help Project output. For more information please see # http://doc.trolltech.com/qthelpproject.html#virtual-folders QHP_VIRTUAL_FOLDER = doc # If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to add. # For more information please see # http://doc.trolltech.com/qthelpproject.html#custom-filters QHP_CUST_FILTER_NAME = # The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the custom filter to add.For more information please see # Qt Help Project / Custom Filters. QHP_CUST_FILTER_ATTRS = # The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this project's # filter section matches. # Qt Help Project / Filter Attributes. QHP_SECT_FILTER_ATTRS = # If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can # be used to specify the location of Qt's qhelpgenerator. # If non-empty doxygen will try to run qhelpgenerator on the generated # .qhp file. QHG_LOCATION = # The DISABLE_INDEX tag can be used to turn on/off the condensed index at # top of each HTML page. The value NO (the default) enables the index and # the value YES disables it. DISABLE_INDEX = NO # This tag can be used to set the number of enum values (range [1..20]) # that doxygen will group on one line in the generated HTML documentation. ENUM_VALUES_PER_LINE = 4 # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index # structure should be generated to display hierarchical information. # If the tag value is set to FRAME, a side panel will be generated # containing a tree-like index structure (just like the one that # is generated for HTML Help). For this to work a browser that supports # JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+, # Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are # probably better off using the HTML help feature. Other possible values # for this tag are: HIERARCHIES, which will generate the Groups, Directories, # and Class Hierarchy pages using a tree view instead of an ordered list; # ALL, which combines the behavior of FRAME and HIERARCHIES; and NONE, which # disables this behavior completely. For backwards compatibility with previous # releases of Doxygen, the values YES and NO are equivalent to FRAME and NONE # respectively. GENERATE_TREEVIEW = NO # If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be # used to set the initial width (in pixels) of the frame in which the tree # is shown. TREEVIEW_WIDTH = 250 # Use this tag to change the font size of Latex formulas included # as images in the HTML documentation. The default is 10. Note that # when you change the font size after a successful doxygen run you need # to manually remove any form_*.png images from the HTML output directory # to force them to be regenerated. FORMULA_FONTSIZE = 10 #--------------------------------------------------------------------------- # configuration options related to the LaTeX output #--------------------------------------------------------------------------- # If the GENERATE_LATEX tag is set to YES (the default) Doxygen will # generate Latex output. GENERATE_LATEX = YES # The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `latex' will be used as the default path. LATEX_OUTPUT = latex # The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be # invoked. If left blank `latex' will be used as the default command name. LATEX_CMD_NAME = latex # The MAKEINDEX_CMD_NAME tag can be used to specify the command name to # generate index for LaTeX. If left blank `makeindex' will be used as the # default command name. MAKEINDEX_CMD_NAME = makeindex # If the COMPACT_LATEX tag is set to YES Doxygen generates more compact # LaTeX documents. This may be useful for small projects and may help to # save some trees in general. COMPACT_LATEX = NO # The PAPER_TYPE tag can be used to set the paper type that is used # by the printer. Possible values are: a4, a4wide, letter, legal and # executive. If left blank a4wide will be used. PAPER_TYPE = a4wide # The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX # packages that should be included in the LaTeX output. EXTRA_PACKAGES = # The LATEX_HEADER tag can be used to specify a personal LaTeX header for # the generated latex document. The header should contain everything until # the first chapter. If it is left blank doxygen will generate a # standard header. Notice: only use this tag if you know what you are doing! LATEX_HEADER = # If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated # is prepared for conversion to pdf (using ps2pdf). The pdf file will # contain links (just like the HTML output) instead of page references # This makes the output suitable for online browsing using a pdf viewer. PDF_HYPERLINKS = YES # If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of # plain latex in the generated Makefile. Set this option to YES to get a # higher quality PDF documentation. USE_PDFLATEX = YES # If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. # command to the generated LaTeX files. This will instruct LaTeX to keep # running if errors occur, instead of asking the user for help. # This option is also used when generating formulas in HTML. LATEX_BATCHMODE = NO # If LATEX_HIDE_INDICES is set to YES then doxygen will not # include the index chapters (such as File Index, Compound Index, etc.) # in the output. LATEX_HIDE_INDICES = NO # If LATEX_SOURCE_CODE is set to YES then doxygen will include source code with syntax highlighting in the LaTeX output. Note that which sources are shown also depends on other settings such as SOURCE_BROWSER. LATEX_SOURCE_CODE = NO #--------------------------------------------------------------------------- # configuration options related to the RTF output #--------------------------------------------------------------------------- # If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output # The RTF output is optimized for Word 97 and may not look very pretty with # other RTF readers or editors. GENERATE_RTF = NO # The RTF_OUTPUT tag is used to specify where the RTF docs will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `rtf' will be used as the default path. RTF_OUTPUT = rtf # If the COMPACT_RTF tag is set to YES Doxygen generates more compact # RTF documents. This may be useful for small projects and may help to # save some trees in general. COMPACT_RTF = NO # If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated # will contain hyperlink fields. The RTF file will # contain links (just like the HTML output) instead of page references. # This makes the output suitable for online browsing using WORD or other # programs which support those fields. # Note: wordpad (write) and others do not support links. RTF_HYPERLINKS = NO # Load stylesheet definitions from file. Syntax is similar to doxygen's # config file, i.e. a series of assignments. You only have to provide # replacements, missing definitions are set to their default value. RTF_STYLESHEET_FILE = # Set optional variables used in the generation of an rtf document. # Syntax is similar to doxygen's config file. RTF_EXTENSIONS_FILE = #--------------------------------------------------------------------------- # configuration options related to the man page output #--------------------------------------------------------------------------- # If the GENERATE_MAN tag is set to YES (the default) Doxygen will # generate man pages GENERATE_MAN = NO # The MAN_OUTPUT tag is used to specify where the man pages will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `man' will be used as the default path. MAN_OUTPUT = man # The MAN_EXTENSION tag determines the extension that is added to # the generated man pages (default is the subroutine's section .3) MAN_EXTENSION = .3 # If the MAN_LINKS tag is set to YES and Doxygen generates man output, # then it will generate one additional man file for each entity # documented in the real man page(s). These additional files # only source the real man page, but without them the man command # would be unable to find the correct page. The default is NO. MAN_LINKS = NO #--------------------------------------------------------------------------- # configuration options related to the XML output #--------------------------------------------------------------------------- # If the GENERATE_XML tag is set to YES Doxygen will # generate an XML file that captures the structure of # the code including all documentation. GENERATE_XML = NO # The XML_OUTPUT tag is used to specify where the XML pages will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `xml' will be used as the default path. XML_OUTPUT = xml # The XML_SCHEMA tag can be used to specify an XML schema, # which can be used by a validating XML parser to check the # syntax of the XML files. XML_SCHEMA = # The XML_DTD tag can be used to specify an XML DTD, # which can be used by a validating XML parser to check the # syntax of the XML files. XML_DTD = # If the XML_PROGRAMLISTING tag is set to YES Doxygen will # dump the program listings (including syntax highlighting # and cross-referencing information) to the XML output. Note that # enabling this will significantly increase the size of the XML output. XML_PROGRAMLISTING = YES #--------------------------------------------------------------------------- # configuration options for the AutoGen Definitions output #--------------------------------------------------------------------------- # If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will # generate an AutoGen Definitions (see autogen.sf.net) file # that captures the structure of the code including all # documentation. Note that this feature is still experimental # and incomplete at the moment. GENERATE_AUTOGEN_DEF = NO #--------------------------------------------------------------------------- # configuration options related to the Perl module output #--------------------------------------------------------------------------- # If the GENERATE_PERLMOD tag is set to YES Doxygen will # generate a Perl module file that captures the structure of # the code including all documentation. Note that this # feature is still experimental and incomplete at the # moment. GENERATE_PERLMOD = NO # If the PERLMOD_LATEX tag is set to YES Doxygen will generate # the necessary Makefile rules, Perl scripts and LaTeX code to be able # to generate PDF and DVI output from the Perl module output. PERLMOD_LATEX = NO # If the PERLMOD_PRETTY tag is set to YES the Perl module output will be # nicely formatted so it can be parsed by a human reader. # This is useful # if you want to understand what is going on. # On the other hand, if this # tag is set to NO the size of the Perl module output will be much smaller # and Perl will parse it just the same. PERLMOD_PRETTY = YES # The names of the make variables in the generated doxyrules.make file # are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. # This is useful so different doxyrules.make files included by the same # Makefile don't overwrite each other's variables. PERLMOD_MAKEVAR_PREFIX = #--------------------------------------------------------------------------- # Configuration options related to the preprocessor #--------------------------------------------------------------------------- # If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will # evaluate all C-preprocessor directives found in the sources and include # files. ENABLE_PREPROCESSING = YES # If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro # names in the source code. If set to NO (the default) only conditional # compilation will be performed. Macro expansion can be done in a controlled # way by setting EXPAND_ONLY_PREDEF to YES. MACRO_EXPANSION = YES # If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES # then the macro expansion is limited to the macros specified with the # PREDEFINED and EXPAND_AS_DEFINED tags. EXPAND_ONLY_PREDEF = YES # If the SEARCH_INCLUDES tag is set to YES (the default) the includes files # in the INCLUDE_PATH (see below) will be search if a #include is found. SEARCH_INCLUDES = YES # The INCLUDE_PATH tag can be used to specify one or more directories that # contain include files that are not input files but should be processed by # the preprocessor. INCLUDE_PATH = # You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard # patterns (like *.h and *.hpp) to filter out the header-files in the # directories. If left blank, the patterns specified with FILE_PATTERNS will # be used. INCLUDE_FILE_PATTERNS = # The PREDEFINED tag can be used to specify one or more macro names that # are defined before the preprocessor is started (similar to the -D option of # gcc). The argument of the tag is a list of macros of the form: name # or name=definition (no spaces). If the definition and the = are # omitted =1 is assumed. To prevent a macro definition from being # undefined via #undef or recursively expanded use the := operator # instead of the = operator. PREDEFINED = DAI_WITH_BP \ DAI_WITH_FBP \ DAI_WITH_TRWBP \ DAI_WITH_MF \ DAI_WITH_HAK \ DAI_WITH_LC \ DAI_WITH_TREEEP \ DAI_WITH_JTREE \ DAI_WITH_MR \ DAI_WITH_CBP \ DAI_DEBUG \ DAI_DATE \ DAI_VERSION # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then # this tag can be used to specify a list of macro names that should be expanded. # The macro definition that is found in the sources will be used. # Use the PREDEFINED tag if you want to use a different macro definition. EXPAND_AS_DEFINED = # If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then # doxygen's preprocessor will remove all function-like macros that are alone # on a line, have an all uppercase name, and do not end with a semicolon. Such # function macros are typically used for boiler-plate code, and will confuse # the parser if not removed. SKIP_FUNCTION_MACROS = NO #--------------------------------------------------------------------------- # Configuration::additions related to external references #--------------------------------------------------------------------------- # The TAGFILES option can be used to specify one or more tagfiles. # Optionally an initial location of the external documentation # can be added for each tagfile. The format of a tag file without # this location is as follows: # # TAGFILES = file1 file2 ... # Adding location for the tag files is done as follows: # # TAGFILES = file1=loc1 "file2 = loc2" ... # where "loc1" and "loc2" can be relative or absolute paths or # URLs. If a location is present for each tag, the installdox tool # does not have to be run to correct the links. # Note that each tag file must have a unique name # (where the name does NOT include the path) # If a tag file is not located in the directory in which doxygen # is run, you must also specify the path to the tagfile here. TAGFILES = # When a file name is specified after GENERATE_TAGFILE, doxygen will create # a tag file that is based on the input files it reads. GENERATE_TAGFILE = # If the ALLEXTERNALS tag is set to YES all external classes will be listed # in the class index. If set to NO only the inherited external classes # will be listed. ALLEXTERNALS = NO # If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed # in the modules index. If set to NO, only the current project's groups will # be listed. EXTERNAL_GROUPS = YES # The PERL_PATH should be the absolute path and name of the perl script # interpreter (i.e. the result of `which perl'). PERL_PATH = /usr/bin/perl #--------------------------------------------------------------------------- # Configuration options related to the dot tool #--------------------------------------------------------------------------- # If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will # generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base # or super classes. Setting the tag to NO turns the diagrams off. Note that # this option is superseded by the HAVE_DOT option below. This is only a # fallback. It is recommended to install and use dot, since it yields more # powerful graphs. CLASS_DIAGRAMS = YES # You can define message sequence charts within doxygen comments using the \msc # command. Doxygen will then run the mscgen tool (see # http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the # documentation. The MSCGEN_PATH tag allows you to specify the directory where # the mscgen tool resides. If left empty the tool is assumed to be found in the # default search path. MSCGEN_PATH = # If set to YES, the inheritance and collaboration graphs will hide # inheritance and usage relations if the target is undocumented # or is not a class. HIDE_UNDOC_RELATIONS = YES # If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is # available from the path. This tool is part of Graphviz, a graph visualization # toolkit from AT&T and Lucent Bell Labs. The other options in this section # have no effect if this option is set to NO (the default) HAVE_DOT = NO # By default doxygen will write a font called FreeSans.ttf to the output # directory and reference it in all dot files that doxygen generates. This # font does not include all possible unicode characters however, so when you need # these (or just want a differently looking font) you can specify the font name # using DOT_FONTNAME. You need need to make sure dot is able to find the font, # which can be done by putting it in a standard location or by setting the # DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory # containing the font. DOT_FONTNAME = FreeSans # The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs. # The default size is 10pt. DOT_FONTSIZE = 10 # By default doxygen will tell dot to use the output directory to look for the # FreeSans.ttf font (which doxygen will put there itself). If you specify a # different font using DOT_FONTNAME you can set the path where dot # can find it using this tag. DOT_FONTPATH = # If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen # will generate a graph for each documented class showing the direct and # indirect inheritance relations. Setting this tag to YES will force the # the CLASS_DIAGRAMS tag to NO. CLASS_GRAPH = YES # If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen # will generate a graph for each documented class showing the direct and # indirect implementation dependencies (inheritance, containment, and # class references variables) of the class with other documented classes. COLLABORATION_GRAPH = YES # If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen # will generate a graph for groups, showing the direct groups dependencies GROUP_GRAPHS = YES # If the UML_LOOK tag is set to YES doxygen will generate inheritance and # collaboration diagrams in a style similar to the OMG's Unified Modeling # Language. UML_LOOK = NO # If set to YES, the inheritance and collaboration graphs will show the # relations between templates and their instances. TEMPLATE_RELATIONS = NO # If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT # tags are set to YES then doxygen will generate a graph for each documented # file showing the direct and indirect include dependencies of the file with # other documented files. INCLUDE_GRAPH = YES # If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and # HAVE_DOT tags are set to YES then doxygen will generate a graph for each # documented header file showing the documented files that directly or # indirectly include this file. INCLUDED_BY_GRAPH = YES # If the CALL_GRAPH and HAVE_DOT options are set to YES then # doxygen will generate a call dependency graph for every global function # or class method. Note that enabling this option will significantly increase # the time of a run. So in most cases it will be better to enable call graphs # for selected functions only using the \callgraph command. CALL_GRAPH = NO # If the CALLER_GRAPH and HAVE_DOT tags are set to YES then # doxygen will generate a caller dependency graph for every global function # or class method. Note that enabling this option will significantly increase # the time of a run. So in most cases it will be better to enable caller # graphs for selected functions only using the \callergraph command. CALLER_GRAPH = NO # If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen # will graphical hierarchy of all classes instead of a textual one. GRAPHICAL_HIERARCHY = YES # If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES # then doxygen will show the dependencies a directory has on other directories # in a graphical way. The dependency relations are determined by the #include # relations between the files in the directories. DIRECTORY_GRAPH = YES # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images # generated by dot. Possible values are png, jpg, or gif # If left blank png will be used. DOT_IMAGE_FORMAT = png # The tag DOT_PATH can be used to specify the path where the dot tool can be # found. If left blank, it is assumed the dot tool can be found in the path. DOT_PATH = # The DOTFILE_DIRS tag can be used to specify one or more directories that # contain dot files that are included in the documentation (see the # \dotfile command). DOTFILE_DIRS = # The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of # nodes that will be shown in the graph. If the number of nodes in a graph # becomes larger than this value, doxygen will truncate the graph, which is # visualized by representing a node as a red box. Note that doxygen if the # number of direct children of the root node in a graph is already larger than # DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note # that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH. DOT_GRAPH_MAX_NODES = 50 # The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the # graphs generated by dot. A depth value of 3 means that only nodes reachable # from the root by following a path via at most 3 edges will be shown. Nodes # that lay further from the root node will be omitted. Note that setting this # option to 1 or 2 may greatly reduce the computation time needed for large # code bases. Also note that the size of a graph can be further restricted by # DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction. MAX_DOT_GRAPH_DEPTH = 0 # Set the DOT_TRANSPARENT tag to YES to generate images with a transparent # background. This is disabled by default, because dot on Windows does not # seem to support this out of the box. Warning: Depending on the platform used, # enabling this option may lead to badly anti-aliased labels on the edges of # a graph (i.e. they become hard to read). DOT_TRANSPARENT = NO # Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output # files in one run (i.e. multiple -o and -T options on the command line). This # makes dot run faster, but since only newer versions of dot (>1.8.10) # support this, this feature is disabled by default. DOT_MULTI_TARGETS = NO # If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will # generate a legend page explaining the meaning of the various boxes and # arrows in the dot generated graphs. GENERATE_LEGEND = YES # If the DOT_CLEANUP tag is set to YES (the default) Doxygen will # remove the intermediate dot files that are used to generate # the various graphs. DOT_CLEANUP = YES #--------------------------------------------------------------------------- # Options related to the search engine #--------------------------------------------------------------------------- # The SEARCHENGINE tag specifies whether or not a search engine should be # used. If set to NO the values of all tags below this one will be ignored. SEARCHENGINE = NO libDAI-0.2.4/Makefile.ALL0000644000263000017630000000223711334764775013551 0ustar jorismkyb# This file is part of libDAI - http://www.libdai.org/ # # libDAI is licensed under the terms of the GNU General Public License version # 2, or (at your option) any later version. libDAI is distributed without any # warranty. See the file COPYING for more details. # # Copyright (C) 2009-2010 Joris Mooij [joris dot mooij at libdai dot org] # This file can be used to configure compile time options of libDAI. # Here the user can enable or disable various approximate inference # methods and additional build targets (documentation, MatLab interface) # and specify whether to build with debug information included. # # It is platform independent and is included by Makefile. # # A boolean variable VAR can be set to true ("VAR=true") or to false ("VAR=") # COMPILATION AND BUILD FLAGS # Enable/disable various approximate inference methods WITH_BP=true WITH_FBP=true WITH_TRWBP=true WITH_MF=true WITH_HAK=true WITH_LC=true WITH_TREEEP=true WITH_JTREE=true WITH_MR=true WITH_GIBBS=true WITH_CBP=true # Build doxygen documentation? WITH_DOC= # Build with debug info? DEBUG=true # Build MatLab interface? WITH_MATLAB= # MatLab version 7.3 (R2006b) or newer? NEW_MATLAB=true