Infer.NET user guide : The Infer.NET Modelling API

Indexing arrays by observed variables

Besides ranges, VariableArrays can be indexed by integer variables. This allows you to create complex dependencies between array elements. For example, suppose you have an array of boolean variables, and you want to constrain one of them to be true. This can be accomplished as follows:

Range item = new Range(4);
VariableArray<bool> bools = Variable.Array<bool>(item);
bools[item] = Variable.Bernoulli(0.7).ForEach(item);
Variable<int> index = Variable.New<int>();
Variable.ConstrainTrue(bools[index]);

The observed value of index can be set and changed at any time. This immediately changes the effect of the constraint. For example:

InferenceEngine engine = new InferenceEngine();
index.ObservedValue = 2;
Console.WriteLine(engine.Infer(bools));
// Result is:
// [0] Bernoulli(0.7)
// [1] Bernoulli(0.7)
// [2] Bernoulli(1)
// [3] Bernoulli(0.7)
index.ObservedValue = 3;
Console.WriteLine(engine.Infer(bools));
// Result is:
// [0] Bernoulli(0.7)
// [1] Bernoulli(0.7)
// [2] Bernoulli(0.7)
// [3] Bernoulli(1)

Besides applying constraints, you can also use bools[index] in a factor, or basically anywhere you would use an ordinary variable.

Indexing by observed variables is currently supported for one-dimensional arrays (including jagged arrays). To index by an unobserved (i.e. random) integer variable, use a Switch block.

Indexing by observed variable arrays

The index can be an array element, allowing you to compactly access many elements of a VariableArray. For example, suppose you want to constrain several elements of bools to be true. You can do this as follows:

Range item = new Range(4);
VariableArray<bool> bools = Variable.Array<bool>(item);
bools[item] = Variable.Bernoulli(0.7).ForEach(item);

Variable<int> numIndices = Variable.New<int>();
Range indexed_item = new Range(numIndices);
VariableArray<int> indices = Variable.Array<int>(indexed_item);
Variable.ConstrainTrue(bools[indices[indexed_item]]);

Here we have made a variable (numIndices) for the size of the indexed_item range, so that we can vary the number of indices at runtime. For example:

InferenceEngine engine = new InferenceEngine();
indices.ObservedValue = new int[] { 1, 2 };
numIndices.ObservedValue = indices.ObservedValue.Length;
Console.WriteLine(engine.Infer(bools));
// Result is:
// [0] Bernoulli(0.7)
// [1] Bernoulli(1)
// [2] Bernoulli(1)
// [3] Bernoulli(0.7)
indices.ObservedValue = new int[] { 1, 2, 3 };
numIndices.ObservedValue = indices.ObservedValue.Length;
Console.WriteLine(engine.Infer(bools));
// Result is:
// [0] Bernoulli(0.7)
// [1] Bernoulli(1)
// [2] Bernoulli(1)
// [3] Bernoulli(1)

Efficient access to subarrays

A speed-up is possible when you know that the indices are all distinct. In other words, you are extracting a subarray of the original variable array. The function Variable.Subarray handles this case efficiently, taking a VariableArray and an array of indices, and returning a smaller VariableArray. We can apply this transformation to the above example, to get:

Range item = new Range(4);
VariableArray<bool> bools = Variable.Array<bool>(item);
bools[item] = Variable.Bernoulli(0.7).ForEach(item);

Variable<int> numIndices = Variable.New<int>();
Range indexed_item = new Range(numIndices);
VariableArray<int> indices = Variable.Array<int>(indexed_item);

VariableArray<bool> indexedBools = Variable.Subarray(bools, indices);
// indexedBools automatically has range 'indexed_item'
Variable.ConstrainTrue(indexedBools[indexed_item]);

During inference, this model gives the same answers as above, however it runs a bit faster since Infer.NET does not have to check for the case that two indices might be equal.

Last modified at 12/1/2008 5:11 PM  by Tom Minka 
©2009 Microsoft Corporation. All rights reserved.  Terms of Use | Trademarks | Privacy Statement