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)
	Constructor.
	~MCMC ()
	Destructor.
void	printProbabilities (ostream &out)
	Prints the probabilities of each predicate to a stream.
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.
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	updateWtsForGndPreds (GroundPredicateHashArray &gndPreds, Array< int > &gndPredIndices, const int &chainIdx)
	Updates the weights of affected ground predicates.
int	gibbsSampleFromBlock (const int &chainIdx, const Array< int > &block, 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.
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 79 of file mcmc.h.

---

Constructor & Destructor Documentation

MCMC::MCMC	(	VariableState *	state,
		long int	seed,
		const bool &	trackClauseTrueCnts,
		MCMCParams *	params
	)			[inline]

Constructor.

User-set parameters are set.

See also:

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

Definition at line 89 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)
  {
      // User-set parameters
    numChains_ = params->numChains;
    burnMinSteps_ = params->burnMinSteps;
    burnMaxSteps_ = params->burnMaxSteps;
    minSteps_ = params->minSteps;
    maxSteps_ = params->maxSteps;
    maxSeconds_ = params->maxSeconds;
  }

---

Member Function Documentation

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 129 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 163 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 200 of file mcmc.h.

References VariableState::getAtomInClause(), VariableState::getGndClause(), VariableState::getNumAtoms(), VariableState::getNumClauses(), numTrueLits_, Inference::state_, and truthValues_.

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

  {
    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;
        for (int c = 0; c < numChains; c++)
        {
          if (truthValues_[atomIdx][c] == gndClause->getGroundPredicateSense(j))
          {
            numTrueLits_[i][c]++;
            assert(numTrueLits_[i][c] <= 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 227 of file mcmc.h.

References genTruthValueForProb(), VariableState::getBlockArray(), VariableState::getBlockEvidence(), VariableState::getBlockIndex(), VariableState::getNumBlocks(), setOthersInBlockToFalse(), Array< Type >::size(), Inference::state_, and truthValues_.

Referenced by GibbsSampler::init().

  {
    for (int c = 0; c < numChains; c++)
    {
        // For each block: select one to set to true
      for (int i = 0; i < state_->getNumBlocks(); i++)
      {
          // If evidence atom exists, then all others are false
        if (state_->getBlockEvidence(i))
        {
            // If 2nd argument is -1, then all are set to false
          setOthersInBlockToFalse(c, -1, i);
          continue;
        }
        
        Array<int>& block = state_->getBlockArray(i);
        int chosen = random() % block.size();
        truthValues_[block[chosen]][c] = true;
        setOthersInBlockToFalse(c, chosen, i);
      }
      
        // 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);
          truthValues_[i][c] = tv;
        }
      }
    }
  }

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 267 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 284 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 313 of file mcmc.h.

References VariableState::getBlockArray(), Array< Type >::size(), Inference::state_, and truthValues_.

Referenced by randomInitGndPredsTruthValues().

  {
    Array<int>& block = state_->getBlockArray(blockIdx);
    for (int i = 0; i < block.size(); i++)
    {
      if (i != atomIdx)
        truthValues_[block[i]][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 334 of file mcmc.h.

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

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

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

      // For each block: select one to set to true
    for (int i = 0; i < state_->getNumBlocks(); i++)
    {
        // If evidence atom exists, then all others stay false
      if (state_->getBlockEvidence(i)) continue;
 
      Array<int>& block = state_->getBlockArray(i);
        // chosen is index in the block, block[chosen] is index in gndPreds_
      int chosen = gibbsSampleFromBlock(chainIdx, block, 1);
        // Truth values are stored differently for multi-chain
      bool truthValue;
      GroundPredicate* gndPred = state_->getGndPred(block[chosen]);
      if (numChains_ > 1) truthValue = truthValues_[block[chosen]][chainIdx];
      else truthValue = gndPred->getTruthValue();
        // If chosen pred was false, then need to set previous true
        // one to false and update wts
      if (!truthValue)
      {
        for (int j = 0; j < block.size(); j++)
        {
            // Truth values are stored differently for multi-chain
          bool otherTruthValue;
          GroundPredicate* otherGndPred = state_->getGndPred(block[j]);
          if (numChains_ > 1)
            otherTruthValue = truthValues_[block[j]][chainIdx];
          else
            otherTruthValue = otherGndPred->getTruthValue();
          if (otherTruthValue)
          {
              // Truth values are stored differently for multi-chain
            if (numChains_ > 1)
              truthValues_[block[j]][chainIdx] = false;
            else
              otherGndPred->setTruthValue(false);
              
            affectedGndPreds.clear();
            affectedGndPredIndices.clear();
            gndPredFlippedUpdates(block[j], 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_[block[chosen]][chainIdx] = true;
        else gndPred->setTruthValue(true);
        affectedGndPreds.clear();
        affectedGndPredIndices.clear();
        gndPredFlippedUpdates(block[chosen], 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_[block[chosen]]++;
    }

      // 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::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 458 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 Array< int > &	block,
		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 598 of file mcmc.h.

References Array< Type >::append(), getProbabilityOfPred(), and Array< Type >::size().

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

  {
    Array<double> numerators;
    double denominator = 0;
    
    for (int i = 0; i < block.size(); i++)
    {
      double prob = getProbabilityOfPred(block[i], chainIdx, invTemp);
      numerators.append(prob);
      denominator += prob;
    }
    double r = random();
    double numSum = 0.0;
    for (int i = 0; i < block.size(); i++)
    {
      numSum += numerators[i];
      if (r < ((numSum / denominator) * RAND_MAX))
      {
        return i;
      }
    }
    return block.size() - 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 631 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 710 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 721 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;    
  }

---

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

• src/infer/mcmc.h

---