trait RecurringCollapseStrategy extends BaseUnweightedSampler with HeuristicCollapseStrategy
In the paper, the authors recommend updating the marginals every N samples and recollapsing every few iterations. In practice, this is pretty slow. This trait will keep a running tally of samples of each of the used variables and recollapse the factor graph (starting from the initial graph) periodically.
 Alphabetic
 By Inheritance
 RecurringCollapseStrategy
 HeuristicCollapseStrategy
 CollapsedProbabilisticGibbs
 ProbabilisticGibbs
 Gibbs
 FactoredAlgorithm
 BaseUnweightedSampler
 Sampler
 Algorithm
 AnyRef
 Any
 Hide All
 Show All
 Public
 All
Type Members

class
StarSampleException
extends AlgorithmException
 Definition Classes
 ProbabilisticGibbs

type
LastUpdate[T] = (T, Int)
 Attributes
 protected
 Definition Classes
 BaseUnweightedSampler

type
Sample = Map[Element[_], Any]
A sample is a map from elements to their values.
A sample is a map from elements to their values.
 Definition Classes
 BaseUnweightedSampler

type
TimesSeen[T] = Map[T, Int]
 Attributes
 protected
 Definition Classes
 BaseUnweightedSampler
Abstract Value Members

abstract
def
burnIn(): Int
Number of samples to throw away initially.
Number of samples to throw away initially.
 Definition Classes
 Gibbs

abstract
def
createBlocks(): List[Block]
Method to create a blocking scheme given information about the model and factors.
Method to create a blocking scheme given information about the model and factors.
 Definition Classes
 Gibbs

abstract
val
dependentAlgorithm: (Universe, List[NamedEvidence[_]]) ⇒ () ⇒ Double
The algorithm to compute probability of specified evidence in a dependent universe.
The algorithm to compute probability of specified evidence in a dependent universe. We use () => Double to represent this algorithm instead of an instance of ProbEvidenceAlgorithm. Typical usage is to return the result of ProbEvidenceAlgorithm.computeProbEvidence when invoked.
 Definition Classes
 FactoredAlgorithm

abstract
val
dependentUniverses: List[(Universe, List[NamedEvidence[_]])]
A list of universes that depend on this universe such that evidence on those universes should be taken into account in this universe.
A list of universes that depend on this universe such that evidence on those universes should be taken into account in this universe.
 Definition Classes
 FactoredAlgorithm

abstract
def
doKill(): Unit
 Attributes
 protected[com.cra.figaro.algorithm]
 Definition Classes
 Algorithm

abstract
def
doResume(): Unit
 Attributes
 protected[com.cra.figaro.algorithm]
 Definition Classes
 Algorithm

abstract
def
doStart(): Unit
 Attributes
 protected[com.cra.figaro.algorithm]
 Definition Classes
 Algorithm

abstract
def
doStop(): Unit
 Attributes
 protected[com.cra.figaro.algorithm]
 Definition Classes
 Algorithm

abstract
def
interval(): Int
Iterations thrown away between samples.
Iterations thrown away between samples.
 Definition Classes
 Gibbs

abstract
val
targetElements: List[Element[_]]
Elements whose samples will be recorded at each iteration.
Elements whose samples will be recorded at each iteration.
 Definition Classes
 Gibbs
Concrete Value Members

final
def
!=(arg0: Any): Boolean
 Definition Classes
 AnyRef → Any

final
def
##(): Int
 Definition Classes
 AnyRef → Any

final
def
==(arg0: Any): Boolean
 Definition Classes
 AnyRef → Any

val
active: Boolean
 Attributes
 protected
 Definition Classes
 Algorithm

def
addFactor[T](factor: Factor[T], map: Map[Variable[_], MultiSet[Factor[T]]]): Unit
add a factor to the list
add a factor to the list
 Definition Classes
 CollapsedProbabilisticGibbs

var
allLastUpdates: Map[Element[_], LastUpdate[_]]
 Attributes
 protected
 Definition Classes
 BaseUnweightedSampler

var
allTimesSeen: Map[Element[_], TimesSeen[_]]
 Attributes
 protected
 Definition Classes
 BaseUnweightedSampler

val
alpha: Int
Only variables with alpha or fewer neighbors in the primal graph are candidates for collapsing.
Only variables with alpha or fewer neighbors in the primal graph are candidates for collapsing.
 Definition Classes
 CollapsedProbabilisticGibbs

val
alphaChoose2: Double
We use ( alpha C 2 ) often, may as well store it.
We use ( alpha C 2 ) often, may as well store it.
 Definition Classes
 CollapsedProbabilisticGibbs

final
def
asInstanceOf[T0]: T0
 Definition Classes
 Any

val
blockSamplerCreate: BlockSamplerCreator
 Definition Classes
 CollapsedProbabilisticGibbs

val
blockSamplers: List[BlockSampler]
 Attributes
 protected
 Definition Classes
 ProbabilisticGibbs

def
cleanUp(): Unit
Called when the algorithm is killed.
Called when the algorithm is killed. By default, does nothing. Can be overridden.
 Definition Classes
 Algorithm

def
clone(): AnyRef
 Attributes
 protected[java.lang]
 Definition Classes
 AnyRef
 Annotations
 @throws( ... )

def
collapseVariables(): Unit
Perform the collapsing step.
Perform the collapsing step.
 Definition Classes
 HeuristicCollapseStrategy → CollapsedProbabilisticGibbs

def
correctBlocks(originalBlocks: List[Block]): List[Block]
We want to alter the original blocks so that we filter out any variables which have been eliminated.
We want to alter the original blocks so that we filter out any variables which have been eliminated. If the original blocks overlapped a lot, then there'll be a lot of redundancy in the filtered blocks, so we take a further step of eliminating any block xs which is fully contained in another block ys.
 Definition Classes
 CollapsedProbabilisticGibbs

val
currentSamples: Map[Variable[_], Int]
The most recent set of samples, used for sampling variables conditioned on the values of other variables.
The most recent set of samples, used for sampling variables conditioned on the values of other variables.
 Definition Classes
 Gibbs

def
distributionDistance[T, U](var1: Variable[T], var2: Variable[U]): Double
Hellinger distance is defined in the source paper (amongst other places).
Hellinger distance is defined in the source paper (amongst other places). It's the sum over all values of X1 and X2 of (sqrt(P(X1,X2))  sqrt(P(X1)*P(X2)))^2
 Definition Classes
 HeuristicCollapseStrategy

def
doSample(): Unit
 Attributes
 protected
 Definition Classes
 ProbabilisticGibbs → BaseUnweightedSampler → Sampler

def
eliminate(variable: Variable[_], factors: MultiSet[Factor[Double]], map: Map[Variable[_], MultiSet[Factor[Double]]]): Unit
Eliminate a variable.
Eliminate a variable. This follows the same approach as in VariableElimination.scala. }
 Definition Classes
 CollapsedProbabilisticGibbs

final
def
eq(arg0: AnyRef): Boolean
 Definition Classes
 AnyRef

def
equals(arg0: Any): Boolean
 Definition Classes
 AnyRef → Any

val
factors: List[Factor[Double]]
List of all factors.
List of all factors.
 Definition Classes
 Gibbs

def
finalize(): Unit
 Attributes
 protected[java.lang]
 Definition Classes
 AnyRef
 Annotations
 @throws( classOf[java.lang.Throwable] )

val
gamma: Int
 Definition Classes
 CollapsedProbabilisticGibbs

final
def
getClass(): Class[_]
 Definition Classes
 AnyRef → Any

def
getFactors(neededElements: List[Element[_]], targetElements: List[Element[_]], upperBounds: Boolean = false): List[Factor[Double]]
All implementations of factored algorithms must specify a way to get the factors from the given universe and dependent universes.
All implementations of factored algorithms must specify a way to get the factors from the given universe and dependent universes.
 Definition Classes
 ProbabilisticGibbs → FactoredAlgorithm

def
getNeededElements(starterElements: List[Element[_]], depth: Int, parameterized: Boolean = false): (List[Element[_]], Boolean)
Get the elements that are needed by the query target variables and the evidence variables.
Get the elements that are needed by the query target variables and the evidence variables. Also compute the values of those variables to the given depth. Only get factors for elements that are actually used by the target variables. This is more efficient. Also, it avoids problems when values of unused elements have not been computed.
In addition to getting all the needed elements, it determines if any of the conditioned, constrained, or dependent universe parent elements has * in its range. If any of these elements has * in its range, the lower and upper bounds of factors will be different, so we need to compute both. If they don't, we don't need to compute bounds.
 Definition Classes
 FactoredAlgorithm

def
getSampleCount: Int
Number of samples taken
Number of samples taken
 Definition Classes
 BaseUnweightedSampler

val
globalGraph: VEGraph
globalGraph lets us traverse the primal graph.
globalGraph lets us traverse the primal graph.
 Definition Classes
 CollapsedProbabilisticGibbs

def
graphHeuristicFunction[T](var1: Variable[T]): Double
Compute the score of a given variable.
Compute the score of a given variable.
 Definition Classes
 HeuristicCollapseStrategy → CollapsedProbabilisticGibbs

def
graphTerm[T](var1: Variable[T]): Double
Returns how many edges would be added to the primal graph by removing var1.
Returns how many edges would be added to the primal graph by removing var1. Note: this is number of edges added, NOT net edges added and removed. Source paper is somewhat ambiguous on whether this should be added or net.
 Definition Classes
 CollapsedProbabilisticGibbs

def
hashCode(): Int
 Definition Classes
 AnyRef → Any

val
hellingerDistances: Map[(Int, Int), Double]
 Definition Classes
 HeuristicCollapseStrategy

def
initUpdates(): Unit
 Attributes
 protected
 Definition Classes
 BaseUnweightedSampler

def
initialize(): Unit
Called when the algorithm is started before running any steps.
Called when the algorithm is started before running any steps. By default, does nothing. Can be overridden.
 Definition Classes
 HeuristicCollapseStrategy → Algorithm

def
isActive: Boolean
 Definition Classes
 Algorithm

final
def
isInstanceOf[T0]: Boolean
 Definition Classes
 Any

def
kill(): Unit
Kill the algorithm so that it is inactive.
Kill the algorithm so that it is inactive. It will no longer be able to provide answers.Throws AlgorithmInactiveException if the algorithm is not active.
 Definition Classes
 Algorithm

def
makeResultFactor(factorsAfterElimination: MultiSet[Factor[Double]]): Factor[Double]
Combine all the remaining factors into one 'result factor', as in VE.
Combine all the remaining factors into one 'result factor', as in VE.
 Definition Classes
 CollapsedProbabilisticGibbs

def
marginalize(resultFactor: Factor[Double]): List[Factor[Double]]
Marginalize all factors to their component variables.
Marginalize all factors to their component variables.
 Definition Classes
 CollapsedProbabilisticGibbs

def
marginalizeToTarget(factor: Factor[Double], target: Variable[_]): Factor[Double]
Marginalize a factor to a particular variable.
Marginalize a factor to a particular variable.
 Definition Classes
 CollapsedProbabilisticGibbs

val
marginals: Map[Int, Map[Int, Double]]
 Definition Classes
 HeuristicCollapseStrategy

final
def
ne(arg0: AnyRef): Boolean
 Definition Classes
 AnyRef

def
newLastUpdate[T](target: Element[T]): LastUpdate[T]
 Attributes
 protected
 Definition Classes
 BaseUnweightedSampler

def
newTimesSeen[T](target: Element[T]): TimesSeen[T]
 Attributes
 protected
 Definition Classes
 BaseUnweightedSampler

final
def
notify(): Unit
 Definition Classes
 AnyRef

final
def
notifyAll(): Unit
 Definition Classes
 AnyRef

val
numSamplesSeenSoFar: Int
 Definition Classes
 HeuristicCollapseStrategy

val
originalBlocks: List[Block]
 Definition Classes
 CollapsedProbabilisticGibbs

val
pairwiseMarignals: Map[(Int, Int), Map[(Int, Int), Double]]
 Definition Classes
 HeuristicCollapseStrategy

lazy val
queryTargets: List[Element[_]]
 Definition Classes
 BaseUnweightedSampler

def
removeFactor[T](factor: Factor[T], map: Map[Variable[_], MultiSet[Factor[T]]]): Unit
remove a factor from the list
remove a factor from the list
 Definition Classes
 CollapsedProbabilisticGibbs

def
resetCounts(): Unit
 Attributes
 protected
 Definition Classes
 BaseUnweightedSampler → Sampler

def
resetMarginals(): Unit
We override resetMarginals() to do nothing so that we don't get rid of our saved marginal data every time we reinitialize.
We override resetMarginals() to do nothing so that we don't get rid of our saved marginal data every time we reinitialize. If we haven't built the marginal maps yes, build them, else do nothing.
 Definition Classes
 RecurringCollapseStrategy → HeuristicCollapseStrategy

def
resume(): Unit
Resume the computation of the algorithm, if it has been stopped.
Resume the computation of the algorithm, if it has been stopped. Throws AlgorithmInactiveException if the algorithm is not active.
 Definition Classes
 Algorithm

def
sample(): (Boolean, Sample)
Produce a single sample.
Produce a single sample.
 Definition Classes
 ProbabilisticGibbs → BaseUnweightedSampler

def
sampleAllBlocks(): Unit
Every sampleRecurrence many samples, we alter the marginals and PairwiseMarginal Maps to record the current sample.
Every sampleRecurrence many samples, we alter the marginals and PairwiseMarginal Maps to record the current sample. Every sampleReset many samples, we reinitialize.
 Definition Classes
 RecurringCollapseStrategy → ProbabilisticGibbs

def
sampleAllBlocksWithTracking(): Unit
Sample all blocks, then store that sample in the marginal and p.m.
Sample all blocks, then store that sample in the marginal and p.m. maps.
 Definition Classes
 HeuristicCollapseStrategy

var
sampleCount: Int
 Attributes
 protected
 Definition Classes
 BaseUnweightedSampler

val
sampleRecurrence: Int
How often we want to save one of our samples for marginal estimation.

val
sampleReset: Int
How often we want to recollapse.

val
semiring: LogSumProductSemiring
Semiring for use in factors.
Semiring for use in factors.
 Definition Classes
 ProbabilisticGibbs → Gibbs → FactoredAlgorithm

def
sortByHeuristic(varList: List[Variable[_]], HeuristicMap: Map[Variable[_], Double]): List[Variable[_]]
Sort variables by the target heuristic, if they have fewer than alpha neighbors and are not targets.
Sort variables by the target heuristic, if they have fewer than alpha neighbors and are not targets.
 Definition Classes
 CollapsedProbabilisticGibbs

def
start(): Unit
Start the algorithm and make it active.
Start the algorithm and make it active. After it returns, the algorithm must be ready to provide answers. Throws AlgorithmActiveException if the algorithm is already active.
 Definition Classes
 Algorithm

def
stop(): Unit
Stop the algorithm from computing.
Stop the algorithm from computing. The algorithm is still ready to provide answers after it returns. Throws AlgorithmInactiveException if the algorithm is not active.
 Definition Classes
 Algorithm

final
def
synchronized[T0](arg0: ⇒ T0): T0
 Definition Classes
 AnyRef

val
targetVariables: List[Variable[_]]
List of variables corresponding to target elements.
List of variables corresponding to target elements. Creating these is memoized, so we don't need to worry about duplicates.
 Definition Classes
 CollapsedProbabilisticGibbs

val
targs: Seq[Element[_]]
Store which elements are our target variables so that subclasses can make use of them.
Store which elements are our target variables so that subclasses can make use of them.
 Definition Classes
 CollapsedProbabilisticGibbs

def
toString(): String
 Definition Classes
 AnyRef → Any

val
totalSamples: Int
 Definition Classes
 HeuristicCollapseStrategy

val
trackingSamples: Int
 Definition Classes
 HeuristicCollapseStrategy

val
universe: Universe
 Definition Classes
 BaseUnweightedSampler

def
update(): Unit
 Attributes
 protected
 Definition Classes
 BaseUnweightedSampler → Sampler

def
updateDistances(): Unit
Use the marginal maps to compute Hellinger maps.
Use the marginal maps to compute Hellinger maps.
 Definition Classes
 HeuristicCollapseStrategy

def
updateTimesSeenForTarget[T](elem: Element[T], newValue: T): Unit
 Attributes
 protected
 Definition Classes
 BaseUnweightedSampler

def
updateTimesSeenWithValue[T](value: T, timesSeen: TimesSeen[T], seen: Int): Unit
 Attributes
 protected
 Definition Classes
 BaseUnweightedSampler

val
upperB: Boolean
Store which elements are our target variables so that subclasses can make use of them.
Store which elements are our target variables so that subclasses can make use of them.
 Definition Classes
 CollapsedProbabilisticGibbs

val
variables: Set[Variable[_]]
Variables to sample at each time step.
Variables to sample at each time step.
 Definition Classes
 Gibbs

val
varsInOrder: List[Variable[_]]
We need a list of variables in order so we can access them by index.
We need a list of variables in order so we can access them by index.
 Definition Classes
 CollapsedProbabilisticGibbs

final
def
wait(): Unit
 Definition Classes
 AnyRef
 Annotations
 @throws( ... )

final
def
wait(arg0: Long, arg1: Int): Unit
 Definition Classes
 AnyRef
 Annotations
 @throws( ... )

final
def
wait(arg0: Long): Unit
 Definition Classes
 AnyRef
 Annotations
 @throws( ... )