Infer.NET development : Compiler transforms

Replication transform

Ensures that random variable expressions in loops are fully-indexed i.e. they are indexed by the loop variables of all containing loops. This is achieved by replicating any expression which is not fully-indexed across all unindexed loops. For example:

The transformation ensures that no two iterations of the loop refer to the same variable. Thus they can all be processed in parallel by subsequent transforms.

If the variable being referenced was declared inside loop i, then it is implicitly indexed by i already and does not need to be replicated over i.

The variable ‘means’ in the expression means[indices[i]] is not considered to be indexed by i. This is because different values of i might lead to the same element of means being selected. Thus to be safe, we need to replicate means over i. In this particular case, we can use Factor.GetItems(means, indices).

When the transform encounters a variable reference or array indexer expression, it proceeds as follows:

1. Collect the set of loops that the expression appears in, excluding loops that the variable was declared in. This reduced set of loops is called the “reference loop context”.
2. If a loop variable appears as the left hand side in a parent condition, exclude the loop from replication.
3. If a loop variable appears as an index in the expression, exclude the loop from replication.
4. Replicate the expression over the remaining reference loops, starting from the outermost. Let the current reference loop have loop variable i. Replicating the expression over i involves 3 steps:
   1. We know that i does not appear as an index in the expression, but it may appear in some other form. For example, the expression may be means[indices[i]]. Split the expression into the largest target that does not involve i, and then the remaining indices. For example, means[indices[i]] splits into “means” and “[indices[i]]”. If loop j is outside of i, then means[j][indices[i]][k] would split into “means[j]” and “[indices[i]][k]” (regardless of whether k is outside of i). If loop j was inside of i, then means[j][indices[i]][k] would split into “means” and “[j][indices[i]][k]”.
   2. Replicate the target of the split expression, by inserting a statement such as: means_j_rep_i = Replicate(means[j], size_i);
   3. Replace the target of the split expression with the replicated array, indexed by i. Thus means[j][indices[i]][k] becomes means_j_rep_i[i][indices[i]][k]. This becomes the new expression to replicate in the remaining reference loops.

Longer Example (all rows are part of the same program)

double precision = 1.0;
int arrayLength = 2;
double scalar = Gaussian.Sample(0.0, precision);
double[] array = new double[arrayLength];
double[] items = new double[scalarGiven];
items = Factor.GetItems(array, arrayGiven);
double[,] array2D = new double[arrayLength,scalarGiven];