/// <summary>
/// Creates an instantiated factor in this graph, with neighborIndices representing the neighbor variables by integer
/// index.
/// </summary>
/// <param name="featureTable">the feature table to use to drive the value of the factor</param>
/// <param name="neighborIndices">the indices of the neighboring variables, in order</param>
/// <returns>a reference to the created factor. This can be safely ignored, as the factor is already saved in the model</returns>
public virtual GraphicalModel.Factor AddFactor(ConcatVectorTable featureTable, int[] neighborIndices)
{
System.Diagnostics.Debug.Assert((featureTable.GetDimensions().Length == neighborIndices.Length));
GraphicalModel.Factor factor = new GraphicalModel.Factor(featureTable, neighborIndices);
factors.Add(factor);
return(factor);
}
public override GraphicalModel Generate(SourceOfRandomness sourceOfRandomness, IGenerationStatus generationStatus)
{
GraphicalModel model = new GraphicalModel();
// Create the variables and factors
int[] variableSizes = new int[20];
for (int i = 0; i < 20; i++)
{
variableSizes[i] = sourceOfRandomness.NextInt(1, 5);
}
int numFactors = sourceOfRandomness.NextInt(12);
for (int i_1 = 0; i_1 < numFactors; i_1++)
{
int[] neighbors = new int[sourceOfRandomness.NextInt(1, 3)];
int[] neighborSizes = new int[neighbors.Length];
for (int j = 0; j < neighbors.Length; j++)
{
neighbors[j] = sourceOfRandomness.NextInt(20);
neighborSizes[j] = variableSizes[neighbors[j]];
}
ConcatVectorTable table = new ConcatVectorTable(neighborSizes);
foreach (int[] assignment in table)
{
int numComponents = sourceOfRandomness.NextInt(7);
// Generate a vector
ConcatVector v = new ConcatVector(numComponents);
for (int x = 0; x < numComponents; x++)
{
if (sourceOfRandomness.NextBoolean())
{
v.SetSparseComponent(x, sourceOfRandomness.NextInt(32), sourceOfRandomness.NextDouble());
}
else
{
double[] val = new double[sourceOfRandomness.NextInt(12)];
for (int y = 0; y < val.Length; y++)
{
val[y] = sourceOfRandomness.NextDouble();
}
v.SetDenseComponent(x, val);
}
}
// set vec in table
table.SetAssignmentValue(assignment, null);
}
model.AddFactor(table, neighbors);
}
// Add metadata to the variables, factors, and model
GenerateMetaData(sourceOfRandomness, model.GetModelMetaDataByReference());
for (int i_2 = 0; i_2 < 20; i_2++)
{
GenerateMetaData(sourceOfRandomness, model.GetVariableMetaDataByReference(i_2));
}
foreach (GraphicalModel.Factor factor in model.factors)
{
GenerateMetaData(sourceOfRandomness, factor.GetMetaDataByReference());
}
return(model);
}
/// <summary>This is the preferred way to add factors to a graphical model.</summary>
/// <remarks>
/// This is the preferred way to add factors to a graphical model. Specify the neighbors, their dimensions, and a
/// function that maps from variable assignments to ConcatVector's of features, and this function will handle the
/// data flow of constructing and populating a factor matching those specifications.
/// <p>
/// IMPORTANT: assignmentFeaturizer must be REPEATABLE and NOT HAVE SIDE EFFECTS
/// This is because it is actually stored as a lazy closure until the full featurized vector is needed, and then it
/// is created, used, and discarded. It CAN BE CALLED MULTIPLE TIMES, and must always return the same value in order
/// for behavior of downstream systems to be defined.
/// </remarks>
/// <param name="neighborIndices">the names of the variables, as indices</param>
/// <param name="neighborDimensions">the sizes of the neighbor variables, corresponding to the order in neighborIndices</param>
/// <param name="assignmentFeaturizer">
/// a function that maps from an assignment to the variables, represented as an array of
/// assignments in the same order as presented in neighborIndices, to a ConcatVector of
/// features for that assignment.
/// </param>
/// <returns>a reference to the created factor. This can be safely ignored, as the factor is already saved in the model</returns>
public virtual GraphicalModel.Factor AddFactor(int[] neighborIndices, int[] neighborDimensions, IFunction <int[], ConcatVector> assignmentFeaturizer)
{
ConcatVectorTable features = new ConcatVectorTable(neighborDimensions);
foreach (int[] assignment in features)
{
features.SetAssignmentValue(assignment, null);
}
return(AddFactor(features, neighborIndices));
}
public static GraphicalModel.Factor ReadFromProto(GraphicalModelProto.Factor proto)
{
GraphicalModel.Factor factor = new GraphicalModel.Factor();
factor.featuresTable = ConcatVectorTable.ReadFromProto(proto.GetFeaturesTable());
factor.metaData = GraphicalModel.ReadMetaDataFromProto(proto.GetMetaData());
factor.neigborIndices = new int[proto.GetNeighborCount()];
for (int i = 0; i < factor.neigborIndices.Length; i++)
{
factor.neigborIndices[i] = proto.GetNeighbor(i);
}
return(factor);
}
public virtual void TestCloneTable(ConcatVector[][][] factor3)
{
ConcatVectorTable concatVectorTable = ConvertArrayToVectorTable((ConcatVector[][][])factor3);
ConcatVectorTable cloned = concatVectorTable.CloneTable();
for (int i = 0; i < factor3.Length; i++)
{
for (int j = 0; j < factor3[0].Length; j++)
{
for (int k = 0; k < factor3[0][0].Length; k++)
{
NUnit.Framework.Assert.IsTrue(factor3[i][j][k].ValueEquals(cloned.GetAssignmentValue(new int[] { i, j, k }).Get(), 1.0e-5));
}
}
}
NUnit.Framework.Assert.IsTrue(concatVectorTable.ValueEquals(cloned, 1.0e-5));
}
public static ConcatVectorTable ConvertArrayToVectorTable(ConcatVector[][][] factor3)
{
int[] neighborSizes = new int[] { factor3.Length, factor3[0].Length, factor3[0][0].Length };
ConcatVectorTable concatVectorTable = new ConcatVectorTable(neighborSizes);
for (int i = 0; i < factor3.Length; i++)
{
for (int j = 0; j < factor3[0].Length; j++)
{
for (int k = 0; k < factor3[0][0].Length; k++)
{
int iF = i;
int jF = j;
int kF = k;
concatVectorTable.SetAssignmentValue(new int[] { i, j, k }, null);
}
}
}
return(concatVectorTable);
}
public virtual void TestProtoTable(ConcatVector[][][] factor3)
{
ConcatVectorTable concatVectorTable = ConvertArrayToVectorTable((ConcatVector[][][])factor3);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
concatVectorTable.WriteToStream(byteArrayOutputStream);
byteArrayOutputStream.Close();
byte[] bytes = byteArrayOutputStream.ToByteArray();
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
ConcatVectorTable recovered = ConcatVectorTable.ReadFromStream(byteArrayInputStream);
for (int i = 0; i < factor3.Length; i++)
{
for (int j = 0; j < factor3[0].Length; j++)
{
for (int k = 0; k < factor3[0][0].Length; k++)
{
NUnit.Framework.Assert.IsTrue(factor3[i][j][k].ValueEquals(recovered.GetAssignmentValue(new int[] { i, j, k }).Get(), 1.0e-5));
}
}
}
NUnit.Framework.Assert.IsTrue(concatVectorTable.ValueEquals(recovered, 1.0e-5));
}
public virtual void TestCache(ConcatVector[][][] factor3, int numUses)
{
int[] dimensions = new int[] { factor3.Length, factor3[0].Length, factor3[0][0].Length };
int[][][] thunkHits = new int[][][] { };
ConcatVectorTable table = new ConcatVectorTable(dimensions);
for (int i = 0; i < factor3.Length; i++)
{
for (int j = 0; j < factor3[0].Length; j++)
{
for (int k = 0; k < factor3[0][0].Length; k++)
{
int[] assignment = new int[] { i, j, k };
table.SetAssignmentValue(assignment, null);
}
}
}
// Pre-cacheing
for (int n = 0; n < numUses; n++)
{
for (int i_1 = 0; i_1 < factor3.Length; i_1++)
{
for (int j = 0; j < factor3[0].Length; j++)
{
for (int k = 0; k < factor3[0][0].Length; k++)
{
int[] assignment = new int[] { i_1, j, k };
table.GetAssignmentValue(assignment).Get();
}
}
}
}
for (int i_2 = 0; i_2 < factor3.Length; i_2++)
{
for (int j = 0; j < factor3[0].Length; j++)
{
for (int k = 0; k < factor3[0][0].Length; k++)
{
NUnit.Framework.Assert.AreEqual(numUses, thunkHits[i_2][j][k]);
}
}
}
table.CacheVectors();
// Cached
for (int n_1 = 0; n_1 < numUses; n_1++)
{
for (int i_1 = 0; i_1 < factor3.Length; i_1++)
{
for (int j = 0; j < factor3[0].Length; j++)
{
for (int k = 0; k < factor3[0][0].Length; k++)
{
int[] assignment = new int[] { i_1, j, k };
table.GetAssignmentValue(assignment).Get();
}
}
}
}
for (int i_3 = 0; i_3 < factor3.Length; i_3++)
{
for (int j = 0; j < factor3[0].Length; j++)
{
for (int k = 0; k < factor3[0][0].Length; k++)
{
NUnit.Framework.Assert.AreEqual(numUses + 1, thunkHits[i_3][j][k]);
}
}
}
table.ReleaseCache();
// Post-cacheing
for (int n_2 = 0; n_2 < numUses; n_2++)
{
for (int i_1 = 0; i_1 < factor3.Length; i_1++)
{
for (int j = 0; j < factor3[0].Length; j++)
{
for (int k = 0; k < factor3[0][0].Length; k++)
{
int[] assignment = new int[] { i_1, j, k };
table.GetAssignmentValue(assignment).Get();
}
}
}
}
for (int i_4 = 0; i_4 < factor3.Length; i_4++)
{
for (int j = 0; j < factor3[0].Length; j++)
{
for (int k = 0; k < factor3[0][0].Length; k++)
{
NUnit.Framework.Assert.AreEqual((2 * numUses) + 1, thunkHits[i_4][j][k]);
}
}
}
}
public Factor(ConcatVectorTable featuresTable, int[] neighborIndices)
{
this.featuresTable = featuresTable;
this.neigborIndices = neighborIndices;
}
