Infer.NET

Controlling how inference is performed

You can get fine-grained control of how inference is performed by getting hold of a compiled algorithm object. The following code shows, for our simple Gaussian example, how to do this. One thing to note is that you should pass down all the variables you are interested in inferring to this method call; in this case mean and precision. Recall that compilation typically takes place when you asked for a marginal on one of your variables; instead, this call directly requests a compilation, thus obviating the need for a compilation when you ask for the marginals.


// Set the inference algorithm
InferenceEngine engine = new InferenceEngine(new VariationalMessagePassing());
// Get the compiled inference algorithm
CompiledAlgorithm ca = engine.GetCompiledInferenceAlgorithm(mean, precision);

Once you have a reference to the compiled algorithm, you can explicitly control the initialisation and updates of the algorithm. This allows, for example, implementation of a custom convergence criterion by monitoring the level of change in certain marginals of interest. The CompiledAlgorithm object that you get is the same that you would get if you precompiled your inference algorithm.

The following code snippets illustrate all the ways in which you can use the compiled algorithm object:

Reset

This method allocates all resources needed before performing inference. It should always be called if you make changes which might modify the resources needed.

// Allocate resources for inference
ca.Reset();

Initialise and Update

The initialise method must be called before running the updates. It performs any computations which can be done before iterating over the 'schedule'. Each update is an entire single pass through the schedule which updates all variable's backward and forward messages.


// Initialise the operators
ca.Initialise();
// Run through the schedule several times
for (int i = 0; i < 10; i++)
    ca.Update();

Execute

The execute method provides a short-cut for performing an initialisation followed by a series of updates. The execute method allows the number of updates to be passed in as a parameter - if this is omitted the default number of update iterations is used. The following code snippet sets the number of iterations to 10 and is equivalent to the previous code snippet.


// Execute 10 iterations of the algorithm
ca.Execute(10);

Setting observed values

When using a compiled algorithm directly, you must use the SetObservedValue() method to ensure that the compiled algorithm is aware of the latest value of an observed variable. First, set the ObservedValue property on the variable itself, then call SetObservedValue(observation) on the CompiledAlgorithm instance. Finally, if the size of a variable array has changed, call Reset() on the CompiledAlgorithm instance in order to reallocate resources. See below for an example. If the Variable instance is no longer around, for example, if you are using a precompiled inference algorithm, you will need to use the version of SetObservedValue() which takes a string.

Getting marginals

When using a compiled algorithm directly, you use the Marginal() method to retrieve marginal distributions (see below for an example). This can be done at any time, for example, so that the change in the marginal distribution during inference can be monitored to check for convergence. As with setting observed values, if the Variable instances are not available, you will need to use the version of Marginal() which takes a string.

Example

The following example illustrates these mechanisms by extending the simple Gaussian example in several ways. The purpose of this example is to perform inference using the same model for two different data sets, whilst avoiding compilation of the model between the two calls.

Firstly, the observed data changes for each call of the algorithm. We still create data as a variable array which is observed; however we defer setting what those observed values are until we are ready to call the algorithm; Note that we do need to set an initial dummy value to let the algorithm know that data is observed (in the code below it is just given a null value).

Because the length of data is now variable, we introduce a dataCount variable to indicate its length. Again, we will set the observed value of this variable when we are ready to call the inference, but we initialise it with a dummy value of 0.

The call to GetCompiledInferenceAlgorithm compiles the model and returns a CompiledAlgorihm object which can be then used to perform inference any number of times. The ObservedValue properties for data and dataCount are set in the body of the for loop; in addition, the CompiledAlgorithm instance needs to be informed that these have changed by calling its SetObservedValue method. The inference can then be performed by calling the Reset and Execute methods.

You can verify that compilation only occurs once by setting the BrowserMode to Always - you will see that the browser window only pops up once - indicating a single compilation.


// The model
Variable<double> mean = Variable.GaussianFromMeanAndVariance(0, 100);
Variable<double> precision = Variable.GammaFromShapeAndScale(1, 1);
Variable<int> dataCount = Variable.Observed(0);
Range item = new Range(dataCount);
VariableArray<double> data = Variable.Observed<double>(null, item);

data[item] = Variable.GaussianFromMeanAndPrecision(mean, precision).ForEach(item);

// The data
double[][] dataSets = new double[][]
    { new double[] { 11, 5, 8, 9 },
      new double[] { -1, -3, 2, 3, -5 } };

// Set the inference algorithm
InferenceEngine engine = new InferenceEngine(new VariationalMessagePassing());
// Bring up the browser which shows how model code gets compiled
engine.BrowserMode = BrowserMode.Always;

// Get the compiled inference algorithm
CompiledAlgorithm ca = engine.GetCompiledInferenceAlgorithm(mean, precision);

// Run the inference on each data set for (int j = 0; j < dataSets.Length; j++) { // Set the data and the size of the range data.ObservedValue = dataSets[j]; dataCount.ObservedValue = dataSets[j].Length; // update compiled algorithm with the new observations ca.SetObservedValue(data); ca.SetObservedValue(dataCount); // Reallocate the resources for inference ca.Reset(); // Execute the inference, running 10 iterations ca.Execute(10); // Retrieve the posterior distributions Gaussian marginalMean = ca.Marginal<Gaussian>(mean); Gamma marginalPrecision = ca.Marginal<Gamma>(precision); Console.WriteLine("mean=" + marginalMean); Console.WriteLine("prec=" + marginalPrecision); }

The output from the inference should be:

mean=Gaussian(8.165, 1.026)
prec=Gamma(3, 0.08038)
mean=Gaussian(-0.7877, 1.532)
prec=Gamma(3.5, 0.03672)

Last modified at 7/30/2009 2:12 PM by John Winn