Working with arrays and rangesWhen defining a large model, it is a good idea to avoid creating too many Variable objects. One way to do this is to use Infer.NET's built-in concept of a VariableArray. VariableArrays are processed as a unit during model compilation and inference, allowing dramatic speedups. This section covers single dimensional and multi-dimension arrays. Jagged arrays (arrays of arrays) are described in a later section. RangesA Range object represents a stream of integers from 0 to N-1. This code creates a range from 0 to 9,
It is also possible to create named ranges, such as
The size of a range does not have to be fixed when defining your model, for example:
Variable arraysHaving defined ranges, you can then declare a variable array using the syntax:
The provided ranges must be distinct. The dimensionality of the array is determined from the number of ranges. Currently, arrays of one or two dimensions are supported. This code creates a 1D and then a 2D array:
At this point, the arrays are declared but not initialized. You can fill an array in two ways: the SetTo method or using an indexer []. The SetTo method is used in conjunction with a factor that returns an array, e.g. Factor.MatrixMultiply. The SetTo method takes a factor along with factor arguments, and defines the array contents to be the output of the factor:
The indexer approach is used in conjunction with a factor that returns a single item, e.g. Variable.Bernoulli. The right hand side of the indexer call must be a stream of variables, tagged with the same ranges used to create the VariableArray. The simplest way to create a stream of variables is with the
The result of this call is a stream of independent variables of type T, each having the same definition as the provided expression. For example, this code fills in the contents of the bools array declared above:
Each element of bools is now an independent Bernoulli variable with mean 0.7. When you pass a stream of variables to a factor, the result is also a stream, so the following is also valid:
In this case, we take N independent Bernoulli variables with mean 0.7 and OR them with a single Bernoulli variable with mean 0.9, giving a new set of N variables. The resulting variables are not independent since they all depend on the outcome of the 0.9 variable. If that variable is true, then all of the results are true. In general, the arguments to the factor on the right-hand side may be streams over different ranges, as long as the overall set of ranges on the right-hand side matches the indices on the left-hand side. Besides
Because there is no loop, this notation allows large numbers of regularly-structured variables to be defined very compactly.
At the moment, arrays can only be indexed by ranges or integer variables. That is, bools can only be indexed by pixel or a Variable<int>. To index by a constant, e.g. bools[0], use bools[Variable.Constant(0)]. (This will be simplified in a future release.) If your model has a lot of statements requiring the ForEach method to be appended for a given range, it may be more convenient to use the ForEach block. Streams of variablesThis section describes in more detail the stream concept introduced above. The basic idea is that, besides arrays, Infer.NET has the concept of a stream of variables. To illustrate why this is needed, consider a factor like Factor.Bernoulli. This factor takes one scalar double. Passing it an array of doubles should be a type error. However, we also want to allow compact code such as:
Infer.NET thus provides a stream syntax to allow code that is both compact and type-safe. Infer.NET VariableArrays are special in that they are indexed by ranges rather than integers. When a VariableArray is indexed by a range object, i.e. varray[range], the result is a stream of variables tagged with that range. This stream can then be given to a factor which expects the variable type, returning a stream of result variables. The stream of result variables is then converted back into an array by assignment, again using the range as index. Notice the code is very similar to what you would write as the body of a loop, except no looping construct is needed. Conceptually, the syntax allProbTrues[pixel] is creating a stream of double variables, Variable.Bernoulli is then creating a stream of boolean variables, and bools[pixel] = ... is filling the bools array with that stream. In implementation, a stream is represented by a single object, with no looping involved. Thus the code is more efficient than an explicit loop. The result of Variable.Bernoulli above is a stream that can be passed through any number of factors before it is assigned to an array. Because streams are tagged with range objects, you can also combine multiple streams into one expression yielding a multidimensional VariableArray, like so:
Constant arraysA constant array is created using Variable.Constant, passing a .NET array and a set of ranges:
The resulting array can only be indexed by the ranges that it was created with. Constant arrays can be used just like random variable arrays. In particular, they can appear on the left-hand side of an indexed assignment. But the effect is to impose a constraint, rather than change the contents of the array. For example:
is equivalent to:
Arrays of observed variablesSimilarly, arrays of observed values can be created using Variable.Observed,
Alternatively, you can define the observed variable arrays without specifying ranges, and define the ranges from the arrays:
If you use Variable.Observed, you must supply initial values. If you want to omit the initial observed values, you should use Variable.Array instead. Here is an example for a 2D array where the array sizes and the array itself are not specified when definiting the model:
Later, when you want to run inference, you can supply the observed value as follows. Infer.NET will expect the array to be the same size as the ranges:
|
|
|
 |
|||
 |
 |
||||
 |
©2009 Microsoft Corporation. All rights reserved. Terms of Use | Trademarks | Privacy Statement |  |