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<Factor> 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<Factor> 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;
}
//send the messages to all the factor nodes connected to this node
void Node::sendMessage()
{
Link *link;
Factor *factor;
double cnt;
double *msgs;
double *outMsgs = new double[2];
for (int lindex = 0; lindex < links_->size(); lindex++)
{
link = (*links_)[lindex];
factor = link->getFactor();
cnt = link->getCount(); (void) cnt;
//subtract the msg recieved from this factor node
msgs = (*msgsArr_)[lindex];
for (int i = 0; i < 2; i++)
{
outMsgs[i] = msgProds_[i] - msgs[i];
}
//Assumes pass by value copy of the messages
factor->receiveMessage(outMsgs, link);
}
delete [] outMsgs;
}
void
VarElim::absorveEvidence (void)
{
if (Globals::verbosity > 2) {
Util::printDashedLine();
cout << "(initial factor list)" << endl;
printActiveFactors();
}
const VarNodes& varNodes = fg.varNodes();
for (size_t i = 0; i < varNodes.size(); i++) {
if (varNodes[i]->hasEvidence()) {
if (Globals::verbosity > 1) {
cout << "-> aborving evidence on ";
cout << varNodes[i]->label() << " = " ;
cout << varNodes[i]->getEvidence() << endl;
}
const vector<size_t>& idxs =
varFactors_.find (varNodes[i]->varId())->second;
for (size_t j = 0; j < idxs.size(); j++) {
Factor* factor = factorList_[idxs[j]];
if (factor->nrArguments() == 1) {
factorList_[idxs[j]] = 0;
} else {
factorList_[idxs[j]]->absorveEvidence (
varNodes[i]->varId(), varNodes[i]->getEvidence());
}
}
}
}
}
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;
}
// compute policy value (decomposed along different rewards)
vector<Factor> FactoredMDP::policyValueDecomp(const vector<Factor> &Pi)
{
VarSet states = m_S_set[0] | m_Z_set[0] | m_P_set[0];
vector<Factor> V(m_rewards.size(), Factor(states,0.0)),
V2(m_rewards.size(), Factor(states, 0.0));
VarSet elim_vars = allVars(m_mdp) / m_A_set;
for (int i = 0; i < 2; i++) elim_vars /= m_S_set[i] | m_Z_set[i] | m_P_set[i];
FactorGraph r_mdp = variableElimination(m_mdp, elim_vars);
for (int t = m_horizon-1; t >= 0; t--) {
if (m_verbose) cerr << "Computing policy value " << t << endl;
for (int i = 0; i < m_rewards.size(); i++) V2[i].fill(0.0);
for (State s(states); s.valid(); s++) {
FactorGraph r_mdp2 = addEvidence(r_mdp, s);
State a(m_A_set, (int)Pi[max((int)Pi.size()-m_horizon+t,0)][s]);
for (int i = 0; i < m_rewards.size(); i++) {
V2[i][s] += m_rewards[i][a(m_rewards[i].vars())+s(m_rewards[i].vars())];
}
Factor f = jointDistribution(addEvidence(r_mdp2, a));
for (int i = 0; i < m_rewards.size(); i++) {
V2[i][s] += (f.p() * V[i].p()).sum();
}
}
for (int i = 0; i < m_rewards.size(); i++) V[i] = V2[i];
}
return V;
}
void GI_libDAI::copyLabels_MSRC(vector<std::size_t>& labels,
labelType* nodeLabels,
BP& bp,
FactorGraph& fg)
{
labelType voidLabel = classIdxToLabel[0];
labelType moutainLabel = classIdxToLabel[4161600];
labelType horseLabel = classIdxToLabel[8323328];
INFERENCE_PRINT("[gi_libDAI] copyLabels_MSRC void=%d, moutain=%d, horse=%d\n",
(int)voidLabel, (int)moutainLabel, (int)horseLabel);
int label;
int n = slice->getNbSupernodes();
for(int sid = 0; sid < n; sid++) {
label = labels[sid];
//if(lossPerLabel == 0 && label > 20) // void label
if(label == voidLabel || label == moutainLabel || label == horseLabel) {
//Factor f = bp.beliefV(sid);
Factor f = bp.belief(fg.var(sid));
double maxProb = -1;
for(int i = 0; i < (int)f.states(); i++) {
if(i != voidLabel && i != moutainLabel && i != horseLabel)
if(maxProb < f[i]) {
maxProb = f[i];
label = i;
}
}
//INFERENCE_PRINT("label=%d\n", label);
}
nodeLabels[sid] = label;
}
}
void BruteForceOptMatching::getMaxProbAssignments(
const BP& ia, const FactorGraph& fg, const ConnectedFactorGraph& graph,
McDArray<McVec2i>& pairs) {
for (int i = 0; i < graph.variables.size(); i++) {
McDArray<int> possibleAssignments;
getAssignmentsForVariable(graph.variables[i], possibleAssignments);
Factor belief =
ia.belief(Var(graph.variables[i], possibleAssignments.size() + 1));
float maxVal = -1 * FLT_MAX;
int maxIdx = -1;
for (int j = 0; j < possibleAssignments.size() + 1; j++) {
if (belief.get(j) > maxVal) {
maxVal = belief.get(j);
maxIdx = j;
}
}
int indexOfAssignmentInVertexList =
mapVariableAssignmentToIndexInVertexList(graph.variables[i],
maxIdx);
McVec2i pair =
McVec2i(graph.variables[i], indexOfAssignmentInVertexList);
pairs.append(pair);
}
outputSingleFactorValues(graph);
// std::vector<std::size_t> maxes= ia.findMaximum();
// vector<std::size_t>::iterator it=maxes.begin();
}
//add the factors with appropriate counts, also add the node to the
//corresponding factor
void Node::addFactors(Array<Factor *> * const & allFactors,
LinkIdToTwoWayMessageMap* const & lidToTWMsg)
{
Factor *factor;
Link *link;
double cnt;
ClauseCounter * counter = (ClauseCounter *)superPred_->getClauseCounter();
int numFactors = counter->getNumClauses();
const Array<double> * cnts;
for (int findex = 0; findex < numFactors; findex++)
{
int fid = counter->getClauseId(findex);
cnts = counter->getClauseCounts(findex);
factor = (*allFactors)[fid];
//predIndex is the predicate index in the clause/factor
for (int predIndex = 0; predIndex < cnts->size(); predIndex++)
{
cnt = (*cnts)[predIndex];
if ((*cnts)[predIndex] == 0)
continue;
//index where this node would be stored in the list of factors
int reverseNodeIndex = factor->getNumLinks();
//index where this factor would be stored in the list of nodes
int reverseFactorIndex = getNumLinks();
link = new Link(this, factor, reverseNodeIndex, reverseFactorIndex,
predIndex, cnt);
//now find the messages from parent nodes
LinkId *lid;
TwoWayMessage *tmsg;
double *nodeToFactorMsgs, *factorToNodeMsgs;
LinkIdToTwoWayMessageMap::iterator lidToTMsgItr;
int parentSuperPredId = getParentSuperPredId();
int parentSuperClauseId = factor->getParentSuperClauseId();
lid = new LinkId(predId_, parentSuperPredId, parentSuperClauseId,
predIndex);
lidToTMsgItr = lidToTWMsg->find(lid);
delete lid;
if (lidToTMsgItr != lidToTWMsg->end())
{
tmsg = lidToTMsgItr->second;
nodeToFactorMsgs = tmsg->getNodeToFactorMessage();
factorToNodeMsgs = tmsg->getFactorToNodeMessage();
}
else
{
nodeToFactorMsgs = NULL;
factorToNodeMsgs = NULL;
}
this->addLink(link, nodeToFactorMsgs);
factor->addLink(link,factorToNodeMsgs);
}
}
}
/**
* Free all ressources.
*/
Constraint::~Constraint(void) {
Factor *fact = facts;
while(fact) {
Factor *next = fact->next();
delete fact;
fact = next;
}
sys->removeConstraint(this);
}
// Overload
double Constraint::coefficient(ilp::Var *var) const {
ASSERT(var);
Var *lvar = sys->getVar(var);
ASSERT(lvar);
for(Factor *fact = facts; fact; fact = fact->next())
if(fact->variable() == lvar)
return fact->coefficient();
ASSERT(false);
}
/* appending a factor to a Term is a multiplication by the Factor */
void Term::appendFactor(const Factor& x) {
Term::map_iter_t it = factors.find(x.getId());
if (it == factors.end()) {
// Don't use operator[] -- it requires a default constructor on Factor
// which doesn't exist. A Factor does not have a logical default value.
factors.insert(map<string, Factor>::value_type(x.getId(), x));
} else {
it->second.getPower() += x.getPower();
}
}
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::collectExpectations( 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.nrStates(), 0.0 );
for( size_t entry = 0; entry < b.nrStates(); ++entry )
p.set( entry, b[perm.convertLinearIndex(entry)] ); // apply inverse permutation
(*_expectations) += p;
}
}
Factor MF::calcNewBelief( size_t i ) {
Factor result;
daiforeach( const Neighbor &I, nbV(i) ) {
Factor henk;
daiforeach( 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;
}
Scalar::Term::ProductOfFactors::Node* Scalar::Term::FindTermOfFactorType( Factor::Type factorType )
{
ProductOfFactors::Node* node = productOfFactors.Head();
while( node )
{
Factor* factor = node->data;
if( factor->ReturnType() == factorType )
break;
node = node->Next();
}
return node;
}
void
VarElim::eliminate (VarId elimVar)
{
Factor* result = 0;
vector<size_t>& idxs = varFactors_.find (elimVar)->second;
for (size_t i = 0; i < idxs.size(); i++) {
size_t idx = idxs[i];
if (factorList_[idx]) {
if (result == 0) {
result = new Factor (*factorList_[idx]);
} else {
result->multiply (*factorList_[idx]);
}
delete factorList_[idx];
factorList_[idx] = 0;
}
}
totalFactorSize_ += result->size();
if (result->size() > largestFactorSize_) {
largestFactorSize_ = result->size();
}
if (result != 0 && result->nrArguments() != 1) {
result->sumOut (elimVar);
factorList_.push_back (result);
const VarIds& resultVarIds = result->arguments();
for (size_t i = 0; i < resultVarIds.size(); i++) {
vector<size_t>& idxs =
varFactors_.find (resultVarIds[i])->second;
idxs.push_back (factorList_.size() - 1);
}
}
}
Factor Inference::FactorMarginalization ( Factor A, vec ele)
{
//function B = FactorMarginalization(A,V)
// this function is only for hmm, ele has only one var
// var......
Factor B;
// eliminate te first var
B.var << A.var(1);
B.card << A.card(0);
mat Val = A.val.t();
Val = reshape(Val,B.card(0),B.card(0));
// eliminate the second var
if (ele(0) == A.var(1))
{
Val = Val.t();
B.var << A.var(0);
}
//B.val = log(sum(exp(bsxfun(@minus, Val, max(Val)))))+max(Val);
B.val = zeros<vec>(Val.n_cols);
for (int step = 0; step != Val.n_cols; step ++)
{
B.val(step) = Utils::logsumexp( Val.col(step) );
}
return B;
}
/* !!NOTE!!
* Collection of factors would be more fast if they was stored in a dynamic
* vector. Not done now for debugging purpose but should be performed.
* Another interesting optimization should be to remove factor whose coefficient
* become null.
*/
void Constraint::add(double coef, ilp::Var *var) {
if(var == 0)
cst -= coef;
else {
Var *lvar = sys->getVar(var);
ASSERT(lvar);
for(Factor *fact = facts; fact; fact = fact->next())
if(fact->variable() == lvar) {
fact->add(coef);
return;
}
facts = new Factor(coef, lvar, facts, var);
}
}
void BruteForceOptMatching::outputSingleFactorValues(
const ConnectedFactorGraph& graph) {
// output factor values
for (int j = 0; j < graph.factors.size(); j++) {
Factor fac = graph.factors[j];
if (fac.vars().size() != 1)
continue;
cout << "singvals for var " << fac.vars().front().label() << " :\n";
for (int k = 0; k < fac.nrStates(); k++) {
cout << fac.get(k) << " ";
}
cout << "\n";
}
}
bool Scalar::Term::IsZero( void ) const
{
const ProductOfFactors::Node* node = productOfFactors.Head();
while( node )
{
Factor* factor = node->data;
if( factor->IsZero() )
return true;
node = node->Next();
}
return false;
}
bool
BiobaseTablePssmEntry::is_vertebrate() const
{
for (FactorLinkList::const_iterator f = get_factors().begin();
get_factors().end() != f;
++f)
{
Factor * factor = BiobaseDb::singleton().get_entry< FACTOR_DATA >(f->get()->link);
if (0 != factor && factor->is_vertebrate())
{
return true;
}
}
return false;
}
void Node::tagNeighborsSend(set<Factor*> &sendFactors,
set<Factor*> &receiveFactors,
set<Node*> &receiveNodes)
{
//if(taggedSend_)
// return;
//taggedSend_ = true;
Factor* factor;
for (int lindex = 0; lindex < links_->size(); lindex++)
{
factor = (*links_)[lindex]->getFactor();
sendFactors.insert(factor);
receiveFactors.insert(factor);
factor->tagNeighborsReceive(receiveNodes);
}
}
std::string
EquivalentFactors::get_name_for(partition_ptr_t factor)
{
if (factor->empty())
{
throw std::logic_error("Factor partition empty");
}
Factor * f = BiobaseDb::singleton().get_entry< FACTOR_DATA >(*(factor->begin()));
if (0 == f)
{
throw std::logic_error("Could not find factor in Biobase");
}
return f->get_name();
}
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);
diaforeach( 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++ )
diaforeach( 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++ )
diaforeach( const Neighbor &I, fg().nbV(i) )
calcNewN(i, I.iter);
}
std::vector<std::size_t> ExactInf::findMaximum() const {
Factor P;
for( size_t I = 0; I < nrFactors(); I++ )
P *= factor(I);
size_t linearState = P.p().argmax().first;
// convert to state
map<Var, size_t> state = calcState( P.vars(), linearState );
// convert to desired output data structure
vector<size_t> mapState;
mapState.reserve( nrVars() );
for( size_t i = 0; i < nrVars(); i++ )
mapState.push_back( state[var(i)] );
return mapState;
}
void BruteForceOptMatching::checkAmbiguities(const BP& ia,
const FactorGraph& fg,
const ConnectedFactorGraph& graph,
McDArray<int>& ambiguities) {
for (int h = 0; h < graph.variables.size(); h++) {
McDArray<int> possibleAssignments;
getAssignmentsForVariable(graph.variables[h], possibleAssignments);
Factor belief =
ia.belief(Var(graph.variables[h], possibleAssignments.size() + 1));
float maxProb = belief.max();
int countSame = 0;
for (int k = 0; k < possibleAssignments.size() + 1; k++) {
float curProb = belief.get(k);
if (fabs(curProb - maxProb) < 0.1)
countSame++;
}
/////
cout << "\n Belief for var " << graph.variables[h] << "\n";
for (int k = 0; k < possibleAssignments.size() + 1; k++) {
float curProb = belief.get(k);
cout << curProb << " ";
}
cout << "\n";
////
if (countSame > 1) {
// oh no! We found an ambiguos assignment!
ambiguities.append(graph.variables[h]);
// print it out:
cout << "Found an ambiguous assignemnt to variable "
<< graph.variables[h] << "\n";
for (int k = 0; k < possibleAssignments.size() + 1; k++) {
float curProb = belief.get(k);
cout << curProb << " ";
}
cout << "\n";
}
}
}
int SingularTestObj(){
SparseMatrix A{3,3, true};
A(2, 2) = 1;
A.build();
DenseMatrix b{3};
b(0) = 0;
b(1) = 1;
b(2) = 0;
Factor factor = A.analyze();
bool res = factor.factorize(A);
TINYTEST_ASSERT(!res);
DenseMatrix x = solve(factor, b);
return 1;
}
/*static*/ Scalar::Term* Scalar::Multiply( const Term* termA, const Term* termB )
{
Term* termProduct = new Term();
for( const Term::ProductOfFactors::Node* node = termA->productOfFactors.Head(); node; node = node->Next() )
{
Factor* factor = node->data;
termProduct->productOfFactors.InsertAfter()->data = factor->Clone();
}
for( const Term::ProductOfFactors::Node* node = termB->productOfFactors.Head(); node; node = node->Next() )
{
Factor* factor = node->data;
termProduct->productOfFactors.InsertAfter()->data = factor->Clone();
}
return termProduct;
}
void Node::tagNeighborsReceive(list<Factor*> &sendFactors,
list<Factor*> &receiveFactors,
list<Node*> &sendNodes,
list<Node*> &receiveNodes)
{
//if(taggedReceive_)
// return;
//taggedReceive_ = true;
Factor* factor;
for (int lindex = 0; lindex < links_->size(); lindex++)
{
//cout << "Tagging " << lindex << " of " << links_->size() << endl;
factor = (*links_)[lindex]->getFactor();
receiveFactors.push_back(factor);
factor->tagNeighborsSendReceive(sendFactors, receiveFactors, sendNodes,
receiveNodes);
}
}
void
VarElim::processFactorList (const VarIds& vids)
{
totalFactorSize_ = 0;
largestFactorSize_ = 0;
for (size_t i = 0; i < elimOrder_.size(); i++) {
if (Globals::verbosity >= 2) {
if (Globals::verbosity >= 3) {
Util::printDashedLine();
printActiveFactors();
}
cout << "-> summing out " ;
cout << fg.getVarNode (elimOrder_[i])->label() << endl;
}
eliminate (elimOrder_[i]);
}
Factor* finalFactor = new Factor();
for (size_t i = 0; i < factorList_.size(); i++) {
if (factorList_[i]) {
finalFactor->multiply (*factorList_[i]);
delete factorList_[i];
factorList_[i] = 0;
}
}
VarIds unobservedVids;
for (size_t i = 0; i < vids.size(); i++) {
if (fg.getVarNode (vids[i])->hasEvidence() == false) {
unobservedVids.push_back (vids[i]);
}
}
finalFactor->reorderArguments (unobservedVids);
finalFactor->normalize();
factorList_.push_back (finalFactor);
if (Globals::verbosity > 0) {
cout << "total factor size: " << totalFactorSize_ << endl;
cout << "largest factor size: " << largestFactorSize_ << endl;
cout << endl;
}
}
