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; } }