MCMC Class Reference

Superclass of all MCMC inference algorithms. More...

#include <mcmc.h>

Inheritance diagram for MCMC:

List of all members.

Public Member Functions
	MCMC (VariableState *state, long int seed, const bool &trackClauseTrueCnts, MCMCParams *params, Array< Array< Predicate * > * > *queryFormulas=NULL)
	Constructor.
	MCMC (HVariableState *state, long int seed, const bool &trackClauseTrueCnts, MCMCParams *params)
	~MCMC ()
	Destructor.
double	computeHybridClauseValue (int clauseIdx, int c)
double	HybridClauseContPartValue (int contClauseIdx, int c)
double	HybridClauseDisPartValue (int contClauseIdx, int c)
void	updateDisPredValue (int predIdx, int chainIdx, bool updateValue)
void	updateProposalContValue (int contPredIdx, int chainIdx)
double	getProbabilityOfPredH (const int &predIdx, const int &chainIdx, const double &invTemp)
virtual void	printNetwork (ostream &out)
	Prints out the network.
void	printProbabilities (ostream &out)
	Prints the probabilities of each predicate to a stream.
void	getChangedPreds (vector< string > &changedPreds, vector< float > &probs, vector< float > &oldProbs, const float &probDelta)
	Puts the predicates whose probability has changed with respect to the reference vector oldProbs by more than probDelta in string form and the corresponding probabilities of each predicate in two vectors.
double	getProbabilityH (GroundPredicate *const &gndPred)
double	getProbability (GroundPredicate *const &gndPred)
	Gets the probability of a ground predicate.
void	printTruePreds (ostream &out)
	Prints each predicate with a probability of 0.5 or greater to a stream.
void	printTruePredsH (ostream &out)
Public Attributes
Array< Array< double > >	truthValuesCont_
Array< Array< bool > >	hybridClauseDisPartValueMCMC_
Array< Array< double > >	hybridClauseContPartValueMCMC_
Protected Member Functions
void	initTruthValuesAndWts (const int &numChains)
	Initializes truth values and weights in the ground preds.
void	initNumTrue ()
	Initializes structure for holding number of times a predicate was set to true.
void	initNumTrueLits (const int &numChains)
	Initializes the number of true lits in each clause in each chain.
void	randomInitGndPredsTruthValues (const int &numChains)
	Randomly initializes the ground predicate truth values, taking blocks into account.
bool	genTruthValueForProb (const double &p)
	Generates a truth value based on a probability.
double	getProbabilityOfPred (const int &predIdx, const int &chainIdx, const double &invTemp)
	Computes the probability of a ground predicate in a chain.
void	setOthersInBlockToFalse (const int &chainIdx, const int &atomIdx, const int &blockIdx)
	Sets the truth values of all atoms for a given chain in a block except for the one given.
void	performGibbsStep (const int &chainIdx, const bool &burningIn, GroundPredicateHashArray &affectedGndPreds, Array< int > &affectedGndPredIndices)
	Performs one step of Gibbs sampling in one chain.
void	updateWtsForGndPredsH (GroundPredicateHashArray &gndPreds, Array< int > &gndPredIndices, const int &chainIdx)
	Updates the weights of affected ground predicates.
void	updateWtsForGndPreds (GroundPredicateHashArray &gndPreds, Array< int > &gndPredIndices, const int &chainIdx)
	Updates the weights of affected ground predicates.
int	gibbsSampleFromBlock (const int &chainIdx, const int &blockIndex, const double &invTemp)
	Chooses an atom from a block according to their probabilities.
void	gndPredFlippedUpdates (const int &gndPredIdx, const int &chainIdx, GroundPredicateHashArray &affectedGndPreds, Array< int > &affectedGndPredIndices)
	Updates information when a ground predicate is flipped and retrieves the Markov blanket of the ground predicate.
double	getProbTrue (const int &predIdx) const
void	setProbTrue (const int &predIdx, const double &p)
void	saveLowStateToChain (const int &chainIdx)
	The atom assignment in the best state is saved to a chain in the ground predicates.
void	setMCMCParameters (MCMCParams *params)
	Sets the user-set parameters for this MCMC algorithm.
void	scaleSamples (double factor)
	Increase or decrease the number of MCMC samples by a multiplicative factor.
Protected Attributes
int	numChains_
int	burnMinSteps_
int	burnMaxSteps_
int	minSteps_
int	maxSteps_
int	maxSeconds_
Array< Array< bool > >	truthValues_
Array< Array< double > >	wtsWhenFalse_
Array< Array< double > >	wtsWhenTrue_
Array< double >	numTrue_
Array< Array< int > >	numTrueLits_

---

Detailed Description

Superclass of all MCMC inference algorithms.

This class does not implement all pure virtual functions of Inference and is thus an abstract class.

Definition at line 80 of file mcmc.h.

---

Constructor & Destructor Documentation

MCMC::MCMC	(	VariableState *	state,
		long int	seed,
		const bool &	trackClauseTrueCnts,
		MCMCParams *	params,
		Array< Array< Predicate * > * > *	queryFormulas = NULL
	)			[inline]

Constructor.

User-set parameters are set.

See also:

Inference::Constructor(VariableState*, long int, const bool&, GibbsParams*)

Definition at line 90 of file mcmc.h.

References MCMCParams::burnMaxSteps, burnMaxSteps_, MCMCParams::burnMinSteps, burnMinSteps_, MCMCParams::maxSeconds, maxSeconds_, MCMCParams::maxSteps, maxSteps_, MCMCParams::minSteps, minSteps_, MCMCParams::numChains, and numChains_.

    : Inference(state, seed, trackClauseTrueCnts, queryFormulas)
  {
      // User-set parameters
    numChains_ = params->numChains;
    burnMinSteps_ = params->burnMinSteps;
    burnMaxSteps_ = params->burnMaxSteps;
    minSteps_ = params->minSteps;
    maxSteps_ = params->maxSteps;
    maxSeconds_ = params->maxSeconds;
  }

---

Member Function Documentation

void MCMC::getChangedPreds	(	vector< string > &	changedPreds,
		vector< float > &	probs,
		vector< float > &	oldProbs,
		const float &	probDelta
	)			[inline, virtual]

Puts the predicates whose probability has changed with respect to the reference vector oldProbs by more than probDelta in string form and the corresponding probabilities of each predicate in two vectors.

Parameters:

	changedPreds	Predicates whose probability have changed more than probDelta are put here.
	probs	The probabilities corresponding to the predicates in changedPreds are put here.
	oldProbs	Reference probabilities for checking for changes.
	probDelta	If probability of an atom has changed more than this value, then it is considered to have changed.

Implements Inference.

Definition at line 468 of file mcmc.h.

References VariableState::getNumAtoms(), getProbTrue(), VariableState::printGndPred(), and Inference::state_.

  {
    changedPreds.clear();
    probs.clear();
    int numAtoms = state_->getNumAtoms();
      // Atoms may have been added to the state, previous prob. was 0
    oldProbs.resize(numAtoms, 0);
    for (int i = 0; i < numAtoms; i++)
    {
      double prob = getProbTrue(i);
      if (abs(prob - oldProbs[i]) > probDelta)
      {
          // Truth value has changed: Store new value (not smoothed) in oldProbs
          // and add to two return vectors
        oldProbs[i] = prob;
          // Uniform smoothing
        prob = (prob*10000 + 1/2.0)/(10000 + 1.0);
        ostringstream oss(ostringstream::out);
        state_->printGndPred(i, oss);
        changedPreds.push_back(oss.str());
        probs.push_back(prob);
      }
    }    
  }

double MCMC::getProbability

(

GroundPredicate *const &

gndPred

)

[inline, virtual]

Gets the probability of a ground predicate.

Parameters:

gndPred

GroundPredicate whose probability is being retrieved.

Returns:

Probability of gndPred if present in state, otherwise 0.

Implements Inference.

Definition at line 510 of file mcmc.h.

References VariableState::getGndPredIndex(), getProbTrue(), and Inference::state_.

  {
    int idx = state_->getGndPredIndex(gndPred);
    double prob = 0.0;
    if (idx >= 0) prob = getProbTrue(idx);
      // Uniform smoothing
    return (prob*10000 + 1/2.0)/(10000 + 1.0);
  }

void MCMC::initTruthValuesAndWts

(

const int &

numChains

)

[inline, protected]

Initializes truth values and weights in the ground preds.

Parameters:

	numChains	Number of chains for which the values should be initialized.
	startIdx	All predicates with index greater than or equal to this will be initialized.

Definition at line 557 of file mcmc.h.

References VariableState::getNumAtoms(), VariableState::getNumClauses(), Array< Type >::growToSize(), numTrueLits_, Inference::state_, truthValues_, wtsWhenFalse_, and wtsWhenTrue_.

Referenced by SimulatedTempering::init(), and GibbsSampler::init().

  {
    int numPreds = state_->getNumAtoms();
    truthValues_.growToSize(numPreds);
    wtsWhenFalse_.growToSize(numPreds);
    wtsWhenTrue_.growToSize(numPreds);
    for (int i = 0; i < numPreds; i++)
    {
      truthValues_[i].growToSize(numChains, false);
      wtsWhenFalse_[i].growToSize(numChains, 0);
      wtsWhenTrue_[i].growToSize(numChains, 0);
    }
    
    int numClauses = state_->getNumClauses();
    numTrueLits_.growToSize(numClauses);
    for (int i = 0; i < numClauses; i++)
    {
      numTrueLits_[i].growToSize(numChains, 0);
    }
  }

void MCMC::initNumTrueLits

(

const int &

numChains

)

[inline, protected]

Initializes the number of true lits in each clause in each chain.

Parameters:

numChains

Number of chains for which the initialization should take place.

Definition at line 596 of file mcmc.h.

References VariableState::getAtomInClause(), VariableState::getGndClause(), VariableState::getGndPred(), VariableState::getNumAtoms(), VariableState::getNumClauses(), VariableState::getNumTrueLits(), GroundPredicate::getTruthValue(), VariableState::incrementNumTrueLits(), numTrueLits_, VariableState::resetMakeBreakCostWatch(), Inference::state_, and truthValues_.

Referenced by SimulatedTempering::init(), and GibbsSampler::init().

  {
      // Single chain
    if (numChains == 1) state_->resetMakeBreakCostWatch();
    for (int i = 0; i < state_->getNumClauses(); i++)
    {
      GroundClause* gndClause = state_->getGndClause(i);
      for (int j = 0; j < gndClause->getNumGroundPredicates(); j++)
      {
        const int atomIdx = abs(state_->getAtomInClause(j, i)) - 1;
        const bool sense = gndClause->getGroundPredicateSense(j);
        if (numChains > 1)
        {
          for (int c = 0; c < numChains; c++)
          {
            if (truthValues_[atomIdx][c] == sense)
            {
              numTrueLits_[i][c]++;
              assert(numTrueLits_[i][c] <= state_->getNumAtoms());
            }
          }
        }
        else
        { // Single chain
          GroundPredicate* gndPred = state_->getGndPred(atomIdx);
          if (gndPred->getTruthValue() == sense)
            state_->incrementNumTrueLits(i);
          assert(state_->getNumTrueLits(i) <= state_->getNumAtoms());
        }        
      }
    }
  }

void MCMC::randomInitGndPredsTruthValues

(

const int &

numChains

)

[inline, protected]

Randomly initializes the ground predicate truth values, taking blocks into account.

Parameters:

numChains

Number of chains for which the initialization should take place.

Definition at line 636 of file mcmc.h.

References genTruthValueForProb(), Domain::getBlockEvidence(), VariableState::getBlockIndex(), VariableState::getDomain(), VariableState::getGndPred(), VariableState::getIndexOfGroundPredicate(), Domain::getNumPredBlocks(), Domain::getRandomPredInBlock(), numChains_, setOthersInBlockToFalse(), GroundPredicate::setTruthValue(), Array< Type >::size(), Inference::state_, and truthValues_.

Referenced by GibbsSampler::init().

  {
    for (int c = 0; c < numChains; c++)
    {
      if (mcmcdebug) cout << "Chain " << c << ":" << endl;
        // For each block: select one to set to true
      for (int i = 0; i < state_->getDomain()->getNumPredBlocks(); i++)
      {
          // If evidence atom exists, then all others are false
        if (state_->getDomain()->getBlockEvidence(i))
        {
            // If 2nd argument is -1, then all are set to false
          setOthersInBlockToFalse(c, -1, i);
          continue;
        }

        bool ok = false;
        while (!ok)
        {
          const Predicate* pred = state_->getDomain()->getRandomPredInBlock(i);
          GroundPredicate* gndPred = new GroundPredicate((Predicate*)pred);
          int idx = state_->getIndexOfGroundPredicate(gndPred);
            
          delete gndPred;
          delete pred;

          if (idx >= 0)
          {
              // Truth values are stored differently for multi-chain
            if (numChains_ > 1)
              truthValues_[idx][c] = true;
            else
            {
              GroundPredicate* gndPred = state_->getGndPred(i);
              gndPred->setTruthValue(true);
            }
            setOthersInBlockToFalse(c, idx, i);
            ok = true;
          }
        }
      }
      
        // Random tv for all not in blocks
      for (int i = 0; i < truthValues_.size(); i++)
      {
          // Predicates in blocks have been handled above
        if (state_->getBlockIndex(i) == -1)
        {
          bool tv = genTruthValueForProb(0.5);
            // Truth values are stored differently for multi-chain
          if (numChains_ > 1)
            truthValues_[i][c] = tv;
          else
          {
            GroundPredicate* gndPred = state_->getGndPred(i);
            gndPred->setTruthValue(tv);
          }
          if (mcmcdebug) cout << "Pred " << i << " set to " << tv << endl;
        }
      }
    }
  }

bool MCMC::genTruthValueForProb

(

const double &

p

)

[inline, protected]

Generates a truth value based on a probability.

Parameters:

p

Number between 0 and 1. With probability p, truth value will be true and with probability 1 - p, it will be false.

Definition at line 705 of file mcmc.h.

Referenced by SimulatedTempering::infer(), performGibbsStep(), and randomInitGndPredsTruthValues().

  {
    if (p == 1.0) return true;
    if (p == 0.0) return false;
    bool r = random() <= p*RAND_MAX;
    return r;
  }

double MCMC::getProbabilityOfPred	(	const int &	predIdx,
		const int &	chainIdx,
		const double &	invTemp
	)			[inline, protected]

Computes the probability of a ground predicate in a chain.

Parameters:

	predIdx	Index of predicate.
	chainIdx	Index of chain.
	invTemp	InvTemp used in simulated tempering.

Returns:

Probability of predicate.

Definition at line 722 of file mcmc.h.

References VariableState::getGndPred(), GroundPredicate::getWtWhenFalse(), GroundPredicate::getWtWhenTrue(), numChains_, Inference::state_, wtsWhenFalse_, and wtsWhenTrue_.

Referenced by gibbsSampleFromBlock(), SimulatedTempering::infer(), and performGibbsStep().

  {
      // Different for multi-chain
    if (numChains_ > 1)
    {
      return 1.0 /
             ( 1.0 + exp((wtsWhenFalse_[predIdx][chainIdx] - 
                          wtsWhenTrue_[predIdx][chainIdx]) *
                          invTemp));      
    }
    else
    {
      GroundPredicate* gndPred = state_->getGndPred(predIdx);
      return 1.0 /
             ( 1.0 + exp((gndPred->getWtWhenFalse() - 
                          gndPred->getWtWhenTrue()) *
                          invTemp));
    }
  }

void MCMC::setOthersInBlockToFalse	(	const int &	chainIdx,
		const int &	atomIdx,
		const int &	blockIdx
	)			[inline, protected]

Sets the truth values of all atoms for a given chain in a block except for the one given.

Parameters:

	chainIdx	Index of chain for which atoms are being set.
	atomIdx	Index of atom in block exempt from being set to false.
	blockIdx	Index of block whose atoms are set to false.

Definition at line 751 of file mcmc.h.

References Domain::getBlockSize(), VariableState::getDomain(), VariableState::getIndexOfGroundPredicate(), Domain::getPredInBlock(), Inference::state_, and truthValues_.

Referenced by randomInitGndPredsTruthValues().

  {
    int blockSize = state_->getDomain()->getBlockSize(blockIdx);
    for (int i = 0; i < blockSize; i++)
    {
      const Predicate* pred = state_->getDomain()->getPredInBlock(i, blockIdx);
      GroundPredicate* gndPred = new GroundPredicate((Predicate*)pred);
      int idx = state_->getIndexOfGroundPredicate(gndPred);

      delete gndPred;
      delete pred;

        // Pred is in the state
      if (idx >= 0 && idx != atomIdx)
        truthValues_[idx][chainIdx] = false;
    }
  }

void MCMC::performGibbsStep	(	const int &	chainIdx,
		const bool &	burningIn,
		GroundPredicateHashArray &	affectedGndPreds,
		Array< int > &	affectedGndPredIndices
	)			[inline, protected]

Performs one step of Gibbs sampling in one chain.

Parameters:

	chainIdx	Index of chain in which the Gibbs step is performed.
	burningIn	If true, burning-in is occuring. Otherwise, false.
	affectedGndPreds	Used to store GroundPredicates which are affected by changing truth values.
	affectedGndPredIndices	Used to store indices of GroundPredicates which are affected by changing truth values.

Definition at line 780 of file mcmc.h.

References Inference::clauseTrueCnts_, Array< Type >::clear(), HashArray< Type, HashFn, EqualFn >::clear(), genTruthValueForProb(), Domain::getBlockEvidence(), VariableState::getBlockIndex(), Domain::getBlockSize(), VariableState::getDomain(), VariableState::getGndPred(), VariableState::getIndexOfGroundPredicate(), VariableState::getNumAtoms(), VariableState::getNumClauseGndings(), Domain::getNumPredBlocks(), Domain::getPredInBlock(), getProbabilityOfPred(), GroundPredicate::getTruthValue(), gibbsSampleFromBlock(), gndPredFlippedUpdates(), numChains_, numTrue_, GroundPredicate::setTruthValue(), Inference::state_, Inference::trackClauseTrueCnts_, truthValues_, and updateWtsForGndPreds().

Referenced by GibbsSampler::infer().

  {
    if (mcmcdebug) cout << "Gibbs step" << endl;

      // For each block: select one to set to true
    for (int i = 0; i < state_->getDomain()->getNumPredBlocks(); i++)
    {
        // If evidence atom exists, then all others stay false
      if (state_->getDomain()->getBlockEvidence(i)) continue;

      int chosen = gibbsSampleFromBlock(chainIdx, i, 1);
        // Truth values are stored differently for multi-chain
      bool truthValue;
      const Predicate* pred = state_->getDomain()->getPredInBlock(chosen, i);
      GroundPredicate* gndPred = new GroundPredicate((Predicate*)pred);
      int idx = state_->getIndexOfGroundPredicate(gndPred);

      delete gndPred;
      delete pred;
      
        // If gnd pred in state:
      if (idx >= 0)
      {
        gndPred = state_->getGndPred(idx);
        if (numChains_ > 1) truthValue = truthValues_[idx][chainIdx];
        else truthValue = gndPred->getTruthValue();
          // If chosen pred was false, then need to set previous true
          // one to false and update wts
        if (!truthValue)
        {
          int blockSize = state_->getDomain()->getBlockSize(i);
          for (int j = 0; j < blockSize; j++)
          {
              // Truth values are stored differently for multi-chain
            bool otherTruthValue;
            const Predicate* otherPred = 
              state_->getDomain()->getPredInBlock(j, i);
            GroundPredicate* otherGndPred =
              new GroundPredicate((Predicate*)otherPred);
            int otherIdx = state_->getIndexOfGroundPredicate(gndPred);

            delete otherGndPred;
            delete otherPred;
      
              // If gnd pred in state:
            if (otherIdx >= 0)
            {
              otherGndPred = state_->getGndPred(otherIdx);
              if (numChains_ > 1)
                otherTruthValue = truthValues_[otherIdx][chainIdx];
              else
                otherTruthValue = otherGndPred->getTruthValue();
              if (otherTruthValue)
              {
                  // Truth values are stored differently for multi-chain
                if (numChains_ > 1)
                  truthValues_[otherIdx][chainIdx] = false;
                else
                  otherGndPred->setTruthValue(false);
              
                affectedGndPreds.clear();
                affectedGndPredIndices.clear();
                gndPredFlippedUpdates(otherIdx, chainIdx, affectedGndPreds,
                                      affectedGndPredIndices);
                updateWtsForGndPreds(affectedGndPreds, affectedGndPredIndices,
                                     chainIdx);
              }
            }
          }
            // Set truth value and update wts for chosen atom
            // Truth values are stored differently for multi-chain
          if (numChains_ > 1) truthValues_[idx][chainIdx] = true;
          else gndPred->setTruthValue(true);
          affectedGndPreds.clear();
          affectedGndPredIndices.clear();
          gndPredFlippedUpdates(idx, chainIdx, affectedGndPreds,
                                affectedGndPredIndices);
          updateWtsForGndPreds(affectedGndPreds, affectedGndPredIndices,
                               chainIdx);
        }
          // If in actual gibbs sampling phase, track the num of times
          // the ground predicate is set to true
        if (!burningIn) numTrue_[idx]++;
      }
    }

      // Now go through all preds not in blocks
    for (int i = 0; i < state_->getNumAtoms(); i++)
    {
        // Predicates in blocks have been handled above
      if (state_->getBlockIndex(i) >= 0) continue;

      if (mcmcdebug)
      {
        cout << "Chain " << chainIdx << ": Probability of pred "
             << i << " is " << getProbabilityOfPred(i, chainIdx, 1) << endl;
      }
      
      bool newAssignment
        = genTruthValueForProb(getProbabilityOfPred(i, chainIdx, 1));

        // Truth values are stored differently for multi-chain
      bool truthValue;
      GroundPredicate* gndPred = state_->getGndPred(i);
      if (numChains_ > 1) truthValue = truthValues_[i][chainIdx];
      else truthValue = gndPred->getTruthValue();
        // If gndPred is flipped, do updates & find all affected gndPreds
      if (newAssignment != truthValue)
      {
        if (mcmcdebug)
        {
          cout << "Chain " << chainIdx << ": Changing truth value of pred "
               << i << " to " << newAssignment << endl;
        }
        
        if (numChains_ > 1) truthValues_[i][chainIdx] = newAssignment;
        else gndPred->setTruthValue(newAssignment);
        affectedGndPreds.clear();
        affectedGndPredIndices.clear();
        gndPredFlippedUpdates(i, chainIdx, affectedGndPreds,
                              affectedGndPredIndices);
        updateWtsForGndPreds(affectedGndPreds, affectedGndPredIndices,
                             chainIdx);
      }

        // If in actual gibbs sampling phase, track the num of times
        // the ground predicate is set to true
      if (!burningIn && newAssignment) numTrue_[i]++;
    }
      // If keeping track of true clause groundings
    if (!burningIn && trackClauseTrueCnts_)
      state_->getNumClauseGndings(clauseTrueCnts_, true);

    if (mcmcdebug) cout << "End of Gibbs step" << endl;
  }

void MCMC::updateWtsForGndPredsH	(	GroundPredicateHashArray &	gndPreds,
		Array< int > &	gndPredIndices,
		const int &	chainIdx
	)			[inline, protected]

Updates the weights of affected ground predicates.

These are the ground predicates which are in clauses of predicates which have had their truth value changed.

Parameters:

	gndPreds	Ground predicates whose weights should be updated.
	chainIdx	Index of chain where updating occurs.

Definition at line 926 of file mcmc.h.

References HVariableState::getClauseCost(), HVariableState::getGndClause(), HVariableState::getNegOccurenceArray(), HVariableState::getNumTrueLits(), HVariableState::getPosOccurenceArray(), GroundClause::getWt(), Inference::hstate_, GroundClause::isHardClause(), numChains_, numTrueLits_, Array< Type >::size(), HashArray< Type, HashFn, EqualFn >::size(), truthValues_, wtsWhenFalse_, and wtsWhenTrue_.

Referenced by HMCSAT::infer().

  {
          if (mcmcdebug) cout << "Entering updateWtsForGndPreds" << endl;
          // for each ground predicate whose MB has changed
          for (int g = 0; g < gndPreds.size(); g++)
          {
                  double wtIfNoChange = 0, wtIfInverted = 0, wt;
                  // Ground clauses in which this pred occurs
                  Array<int>& negGndClauses =
                          hstate_->getNegOccurenceArray(gndPredIndices[g] + 1);
                  Array<int>& posGndClauses =
                          hstate_->getPosOccurenceArray(gndPredIndices[g] + 1);

                  int gndClauseIdx;
                  bool sense;
                  if (mcmcdebug)
                  {
                          cout << "Ground clauses in which pred " << g << " occurs neg.: "
                                  << negGndClauses.size() << endl;
                          cout << "Ground clauses in which pred " << g << " occurs pos.: "
                                  << posGndClauses.size() << endl;
                  }

                  for (int i = 0; i < negGndClauses.size() + posGndClauses.size(); i++)
                  {
                          if (i < negGndClauses.size())
                          {
                                  gndClauseIdx = negGndClauses[i];
                                  if (mcmcdebug) cout << "Neg. in clause " << gndClauseIdx << endl;
                                  sense = false;
                          }
                          else
                          {
                                  gndClauseIdx = posGndClauses[i - negGndClauses.size()];
                                  if (mcmcdebug) cout << "Pos. in clause " << gndClauseIdx << endl;
                                  sense = true;
                          }

                          GroundClause* gndClause = hstate_->getGndClause(gndClauseIdx);
                          if (gndClause->isHardClause())
                                  wt = hstate_->getClauseCost(gndClauseIdx);
                          else
                                  wt = gndClause->getWt();
                          // NumTrueLits are stored differently for multi-chain
                          int numSatLiterals;
                          if (numChains_ > 1)
                                  numSatLiterals = numTrueLits_[gndClauseIdx][chainIdx];
                          else
                                  numSatLiterals = hstate_->getNumTrueLits(gndClauseIdx);
                          if (numSatLiterals > 1)
                          {
                                  // Some other literal is making it sat, so it doesn't matter
                                  // if pos. clause. If neg., nothing can be done to unsatisfy it.
                                  if (wt > 0)
                                  {
                                          wtIfNoChange += wt;
                                          wtIfInverted += wt;
                                  }
                          }
                          else 
                                  if (numSatLiterals == 1) 
                                  {
                                          if (wt > 0) wtIfNoChange += wt;
                                          // Truth values are stored differently for multi-chain
                                          bool truthValue;
                                          if (numChains_ > 1)
                                                  truthValue = truthValues_[gndPredIndices[g]][chainIdx];
                                          else
                                                  truthValue = gndPreds[g]->getTruthValue();
                                          // If the current truth value is the same as its sense in gndClause
                                          if (truthValue == sense) 
                                          {
                                                  // This gndPred is the only one making this function satisfied
                                                  if (wt < 0) wtIfInverted += abs(wt);
                                          }
                                          else 
                                          {
                                                  // Some other literal is making it satisfied
                                                  if (wt > 0) wtIfInverted += wt;
                                          }
                                  }
                                  else
                                          if (numSatLiterals == 0) 
                                          {
                                                  // None satisfy, so when gndPred switch to its negative, it'll satisfy
                                                  if (wt > 0) wtIfInverted += wt;
                                                  else if (wt < 0) wtIfNoChange += abs(wt);
                                          }
                  } // for each ground clause that gndPred appears in

                  if (mcmcdebug)
                  {
                          cout << "wtIfNoChange of pred " << g << ": "
                                  << wtIfNoChange << endl;
                          cout << "wtIfInverted of pred " << g << ": "
                                  << wtIfInverted << endl;
                  }

                  // Clause info is stored differently for multi-chain
                  if (numChains_ > 1)
                  {
                          if (truthValues_[gndPredIndices[g]][chainIdx]) 
                          {
                                  wtsWhenTrue_[gndPredIndices[g]][chainIdx] = wtIfNoChange;
                                  wtsWhenFalse_[gndPredIndices[g]][chainIdx] = wtIfInverted;
                          }
                          else 
                          {
                                  wtsWhenFalse_[gndPredIndices[g]][chainIdx] = wtIfNoChange;
                                  wtsWhenTrue_[gndPredIndices[g]][chainIdx] = wtIfInverted;
                          }
                  }
                  else
                  { // Single chain
                          if (gndPreds[g]->getTruthValue())
                          {
                                  gndPreds[g]->setWtWhenTrue(wtIfNoChange);
                                  gndPreds[g]->setWtWhenFalse(wtIfInverted);
                          }
                          else
                          {
                                  gndPreds[g]->setWtWhenFalse(wtIfNoChange);
                                  gndPreds[g]->setWtWhenTrue(wtIfInverted);            
                          }
                  }
          } // for each ground predicate whose MB has changed
          if (mcmcdebug) cout << "Leaving updateWtsForGndPreds" << endl;
  }

void MCMC::updateWtsForGndPreds	(	GroundPredicateHashArray &	gndPreds,
		Array< int > &	gndPredIndices,
		const int &	chainIdx
	)			[inline, protected]

Updates the weights of affected ground predicates.

These are the ground predicates which are in clauses of predicates which have had their truth value changed.

Parameters:

	gndPreds	Ground predicates whose weights should be updated.
	chainIdx	Index of chain where updating occurs.

Definition at line 1067 of file mcmc.h.

References VariableState::getClauseCost(), VariableState::getGndClause(), VariableState::getNegOccurenceArray(), VariableState::getNumTrueLits(), VariableState::getPosOccurenceArray(), GroundClause::getWt(), GroundClause::isHardClause(), numChains_, numTrueLits_, Array< Type >::size(), HashArray< Type, HashFn, EqualFn >::size(), Inference::state_, truthValues_, wtsWhenFalse_, and wtsWhenTrue_.

Referenced by SimulatedTempering::infer(), MCSAT::infer(), GibbsSampler::infer(), and performGibbsStep().

  {
    if (mcmcdebug) cout << "Entering updateWtsForGndPreds" << endl;
      // for each ground predicate whose MB has changed
    for (int g = 0; g < gndPreds.size(); g++)
    {
      double wtIfNoChange = 0, wtIfInverted = 0, wt;
        // Ground clauses in which this pred occurs
      Array<int>& negGndClauses =
        state_->getNegOccurenceArray(gndPredIndices[g] + 1);
      Array<int>& posGndClauses =
        state_->getPosOccurenceArray(gndPredIndices[g] + 1);
      int gndClauseIdx;
      bool sense;
      
      if (mcmcdebug)
      {
        cout << "Ground clauses in which pred " << g << " occurs neg.: "
             << negGndClauses.size() << endl;
        cout << "Ground clauses in which pred " << g << " occurs pos.: "
             << posGndClauses.size() << endl;
      }
      
      for (int i = 0; i < negGndClauses.size() + posGndClauses.size(); i++)
      {
        if (i < negGndClauses.size())
        {
          gndClauseIdx = negGndClauses[i];
          if (mcmcdebug) cout << "Neg. in clause " << gndClauseIdx << endl;
          sense = false;
        }
        else
        {
          gndClauseIdx = posGndClauses[i - negGndClauses.size()];
          if (mcmcdebug) cout << "Pos. in clause " << gndClauseIdx << endl;
          sense = true;
        }
        
        GroundClause* gndClause = state_->getGndClause(gndClauseIdx);
        if (gndClause->isHardClause())
          wt = state_->getClauseCost(gndClauseIdx);
        else
          wt = gndClause->getWt();
          // NumTrueLits are stored differently for multi-chain
        int numSatLiterals;
        if (numChains_ > 1)
          numSatLiterals = numTrueLits_[gndClauseIdx][chainIdx];
        else
          numSatLiterals = state_->getNumTrueLits(gndClauseIdx);

        if (numSatLiterals > 1)
        {
            // Some other literal is making it sat, so it doesn't matter
            // if pos. clause. If neg., nothing can be done to unsatisfy it.
          if (wt > 0)
          {
            wtIfNoChange += wt;
            wtIfInverted += wt;
          }
        }
        else 
        if (numSatLiterals == 1) 
        {
          if (wt > 0) wtIfNoChange += wt;
            // Truth values are stored differently for multi-chain
          bool truthValue;
          if (numChains_ > 1)
            truthValue = truthValues_[gndPredIndices[g]][chainIdx];
          else
            truthValue = gndPreds[g]->getTruthValue();
            // If the current truth value is the same as its sense in gndClause
          if (truthValue == sense) 
          {
            // This gndPred is the only one making this function satisfied
            if (wt < 0) wtIfInverted += abs(wt);
          }
          else 
          {
              // Some other literal is making it satisfied
            if (wt > 0) wtIfInverted += wt;
          }
        }
        else
        if (numSatLiterals == 0) 
        {
          // None satisfy, so when gndPred switch to its negative, it'll satisfy
          if (wt > 0) wtIfInverted += wt;
          else if (wt < 0) wtIfNoChange += abs(wt);
        }
      } // for each ground clause that gndPred appears in

      if (mcmcdebug)
      {
        cout << "wtIfNoChange of pred " << g << ": "
             << wtIfNoChange << endl;
        cout << "wtIfInverted of pred " << g << ": "
             << wtIfInverted << endl;
      }

        // Clause info is stored differently for multi-chain
      if (numChains_ > 1)
      {
        if (truthValues_[gndPredIndices[g]][chainIdx]) 
        {
          wtsWhenTrue_[gndPredIndices[g]][chainIdx] = wtIfNoChange;
          wtsWhenFalse_[gndPredIndices[g]][chainIdx] = wtIfInverted;
        }
        else 
        {
          wtsWhenFalse_[gndPredIndices[g]][chainIdx] = wtIfNoChange;
          wtsWhenTrue_[gndPredIndices[g]][chainIdx] = wtIfInverted;
        }
      }
      else
      { // Single chain
        if (gndPreds[g]->getTruthValue())
        {
          gndPreds[g]->setWtWhenTrue(wtIfNoChange);
          gndPreds[g]->setWtWhenFalse(wtIfInverted);
        }
        else
        {
          gndPreds[g]->setWtWhenFalse(wtIfNoChange);
          gndPreds[g]->setWtWhenTrue(wtIfInverted);            
        }
      }
    } // for each ground predicate whose MB has changed
    if (mcmcdebug) cout << "Leaving updateWtsForGndPreds" << endl;
  }

int MCMC::gibbsSampleFromBlock	(	const int &	chainIdx,
		const int &	blockIndex,
		const double &	invTemp
	)			[inline, protected]

Chooses an atom from a block according to their probabilities.

Parameters:

	chainIdx	Index of chain.
	block	Block of predicate indices from which one is chosen.
	invTemp	InvTemp used in simulated tempering.

Returns:

Index of chosen atom in the block.

Definition at line 1208 of file mcmc.h.

References Array< Type >::append(), Domain::getBlockSize(), VariableState::getDomain(), VariableState::getIndexOfGroundPredicate(), Domain::getPredInBlock(), getProbabilityOfPred(), and Inference::state_.

Referenced by SimulatedTempering::infer(), and performGibbsStep().

  {
    Array<double> numerators;
    double denominator = 0;

    int blockSize = state_->getDomain()->getBlockSize(blockIndex);
    for (int i = 0; i < blockSize; i++)
    {
      const Predicate* pred =
        state_->getDomain()->getPredInBlock(i, blockIndex);
      GroundPredicate* gndPred = new GroundPredicate((Predicate*)pred);
      int idx = state_->getIndexOfGroundPredicate(gndPred);
      
      delete gndPred;
      delete pred;

        // Prob is 0 if atom not in state
      double prob = 0.0;
        // Pred is in the state; otherwise, prob is zero
      if (idx >= 0)
        prob = getProbabilityOfPred(idx, chainIdx, invTemp);

      numerators.append(prob);
      denominator += prob;
    }

    double r = random();
    double numSum = 0.0;
    for (int i = 0; i < blockSize; i++)
    {
      numSum += numerators[i];
      if (r < ((numSum / denominator) * RAND_MAX))
      {
        return i;
      }
    }
    return blockSize - 1;
  }

void MCMC::gndPredFlippedUpdates	(	const int &	gndPredIdx,
		const int &	chainIdx,
		GroundPredicateHashArray &	affectedGndPreds,
		Array< int > &	affectedGndPredIndices
	)			[inline, protected]

Updates information when a ground predicate is flipped and retrieves the Markov blanket of the ground predicate.

Parameters:

	gndPredIdx	Index of ground pred which was flipped.
	chainIdx	Index of chain in which the flipping occured.
	affectedGndPreds	Holds the Markov blanket of the ground predicate.

Definition at line 1256 of file mcmc.h.

References Array< Type >::append(), HashArray< Type, HashFn, EqualFn >::append(), VariableState::decrementNumTrueLits(), VariableState::getGndClause(), VariableState::getGndPred(), VariableState::getGndPredHashArrayPtr(), GroundClause::getGroundPredicate(), GroundClause::getGroundPredicateIndex(), VariableState::getNegOccurenceArray(), VariableState::getNumAtoms(), GroundClause::getNumGroundPredicates(), VariableState::getPosOccurenceArray(), GroundPredicate::getTruthValue(), VariableState::incrementNumTrueLits(), numChains_, numTrueLits_, Array< Type >::size(), HashArray< Type, HashFn, EqualFn >::size(), Inference::state_, and truthValues_.

Referenced by SimulatedTempering::infer(), and performGibbsStep().

  {
    if (mcmcdebug) cout << "Entering gndPredFlippedUpdates" << endl;
    int numAtoms = state_->getNumAtoms();
    GroundPredicate* gndPred = state_->getGndPred(gndPredIdx);
    affectedGndPreds.append(gndPred, numAtoms);
    affectedGndPredIndices.append(gndPredIdx);
    assert(affectedGndPreds.size() <= numAtoms);

    Array<int>& negGndClauses =
      state_->getNegOccurenceArray(gndPredIdx + 1);
    Array<int>& posGndClauses =
      state_->getPosOccurenceArray(gndPredIdx + 1);
    int gndClauseIdx;
    GroundClause* gndClause; 
    bool sense;

      // Find the Markov blanket of this ground predicate
    for (int i = 0; i < negGndClauses.size() + posGndClauses.size(); i++)
    {
      if (i < negGndClauses.size())
      {
        gndClauseIdx = negGndClauses[i];
        sense = false;
      }
      else
      {
        gndClauseIdx = posGndClauses[i - negGndClauses.size()];
        sense = true;
      }
      gndClause = state_->getGndClause(gndClauseIdx);

        // Different for multi-chain
      if (numChains_ > 1)
      {
        if (truthValues_[gndPredIdx][chainIdx] == sense)
          numTrueLits_[gndClauseIdx][chainIdx]++;
        else
          numTrueLits_[gndClauseIdx][chainIdx]--;
      }
      else
      { // Single chain
        if (gndPred->getTruthValue() == sense)
          state_->incrementNumTrueLits(gndClauseIdx);
        else
          state_->decrementNumTrueLits(gndClauseIdx);
      }
      
      for (int j = 0; j < gndClause->getNumGroundPredicates(); j++)
      {
        const GroundPredicateHashArray* gpha = state_->getGndPredHashArrayPtr();
        GroundPredicate* pred = 
          (GroundPredicate*)gndClause->getGroundPredicate(j,
            (GroundPredicateHashArray*)gpha);
        affectedGndPreds.append(pred, numAtoms);
        affectedGndPredIndices.append(
                               abs(gndClause->getGroundPredicateIndex(j)) - 1);
        assert(affectedGndPreds.size() <= numAtoms);
      }
    }
    if (mcmcdebug) cout << "Leaving gndPredFlippedUpdates" << endl;
  }

void MCMC::saveLowStateToChain

(

const int &

chainIdx

)

[inline, protected]

The atom assignment in the best state is saved to a chain in the ground predicates.

Parameters:

chainIdx

Index of chain to which the atom assigment is saved

Definition at line 1335 of file mcmc.h.

References VariableState::getNumAtoms(), VariableState::getValueOfLowAtom(), Inference::state_, and truthValues_.

Referenced by SimulatedTempering::init(), and GibbsSampler::init().

  {
    for (int i = 0; i < state_->getNumAtoms(); i++)
      truthValues_[i][chainIdx] = state_->getValueOfLowAtom(i + 1);
  }

void MCMC::setMCMCParameters

(

MCMCParams *

params

)

[inline, protected]

Sets the user-set parameters for this MCMC algorithm.

Parameters:

params

MCMC parameters for this algorithm.

Definition at line 1346 of file mcmc.h.

References MCMCParams::burnMaxSteps, burnMaxSteps_, MCMCParams::burnMinSteps, burnMinSteps_, MCMCParams::maxSeconds, maxSeconds_, MCMCParams::maxSteps, maxSteps_, MCMCParams::minSteps, minSteps_, MCMCParams::numChains, and numChains_.

  {
      // User-set parameters
    numChains_ = params->numChains;
    burnMinSteps_ = params->burnMinSteps;
    burnMaxSteps_ = params->burnMaxSteps;
    minSteps_ = params->minSteps;
    maxSteps_ = params->maxSteps;
    maxSeconds_ = params->maxSeconds;    
  }

void MCMC::scaleSamples

(

double

factor

)

[inline, protected, virtual]

Increase or decrease the number of MCMC samples by a multiplicative factor.

(For MaxWalkSAT, this could perhaps change the number of flips or something that trades off speed and accuracy.)

Reimplemented from Inference.

Definition at line 1357 of file mcmc.h.

References maxSteps_, and minSteps_.

  {
    minSteps_ = (int)(minSteps_ * factor);
    maxSteps_ = (int)(maxSteps_ * factor);
  }

---

The documentation for this class was generated from the following file:

• src/infer/mcmc.h

---