public new static DistArray <T> FromMatlabStruct(MatlabStruct s)
{
// s = struct();
// s.className=class(this);
// distCell = cell(1, length(this.distArray));
// for i=1:length(this.distArray)
// dist = this.distArray(i);
// distCell{i} = dist.toStruct();
// end
// s.distArray = distCell;
// s.mean = this.mean;
// s.variance = this.variance;
//
string className = s.GetString("className");
if (!className.Equals("DistArray"))
{
throw new ArgumentException("The input does not represent a " + "DistArray");
}
object[,] distCell = s.GetCells("distArray");
List <T> dists = new List <T>();
for (int i = 0; i < distCell.Length; i++)
{
var distDict = (Dictionary <string, object>)distCell[0, i];
MatlabStruct distStruct = new MatlabStruct(distDict);
IKEPDist disti = KEPDist.FromMatlabStruct(distStruct);
dists.Add((T)disti);
}
return(new DistArray <T>(dists));
}
// public override int NumInputMessages(){
// Debug.Assert(mwidth2s.Count == vwidth2s.Count);
// return mwidth2s.Count;
// }
private Vector ToMVStack(IKEPDist[] msgs)
{
// stack all means and variances. Divide each by its corresponding
// sqrt(gauss_width2).
// *** Implementation must match RandFourierGaussMVMap.toMVStack()
// in Matlab ***
// empty vector
Vector meanStack = Vector.Zero(0);
Vector varStack = Vector.Zero(0);
for (int i = 0; i < msgs.Length; i++)
{
IKEPDist di = msgs[i];
Vector smean = di.GetMeanVector() * (1 / Math.Sqrt(mwidth2s[i]));
Matrix svar = di.GetCovarianceMatrix() * (1 / Math.Sqrt(vwidth2s[i]));
// reshape column-wise as in Matlab.
// Matrix in Infer.NET is stored row-wise
Vector svarVec = Vector.FromArray(svar.Transpose().SourceArray);
meanStack = Vector.Concat(meanStack, smean);
varStack = Vector.Concat(varStack, svarVec);
}
Vector mv = Vector.Concat(meanStack, varStack);
return(mv);
}
public override Vector MapToVector(params IKEPDist[] msgs)
{
if (msgs.Length != 1)
{
string err = string.Format("{0} only works on one distribution", MATLAB_CLASS);
throw new ArgumentException(err);
}
IKEPDist dist = msgs[0];
InitMap(dist);
Vector mean = dist.GetMeanVector();
Matrix cov = dist.GetCovarianceMatrix();
Vector wtm = mean * W;
Matrix VW = cov * W;
Matrix WVW = new Matrix(W.Rows, W.Cols);
WVW.SetToElementwiseProduct(VW, W);
int dim = W.Rows;
Vector wvwVec = (Vector.Zero(dim) + 1) * WVW;
double[] cosExp = Enumerable.Range(0, numFeatures).Select(
i => Math.Cos(wtm[i] + B[i]) * Math.Exp(-0.5 * wvwVec[i])
).ToArray();
Vector feature = Math.Sqrt(2.0 / numFeatures) * Vector.FromArray(cosExp);
return(feature);
}
public void InitMap(IKEPDist dist)
{
// dynamically initialize the random feature map
if (W == null)
{
Debug.Assert(B == null);
int dim = dist.GetMeanVector().Count;
double[] reci = MatrixUtils.Reciprocal(gwidth2);
double[] zero = Vector.Zero(dim).ToArray();
W = MatrixUtils.SampleDiagonalVectorGaussian(zero, reci, numFeatures);
double[] Bvec = MatrixUtils.UniformVector(0, 2.0 * Math.PI, numFeatures);
B = Vector.FromArray(Bvec);
// VectorGaussian.SampleFromMeanAndVariance();
}
}
public Gamma PrecisionAverageConditional(Gamma precision)
{
Console.WriteLine("{0}.PrecisionAverageConditional. precision: {1}",
typeof(KEP_CGFacOpIns), precision);
var incom = new IKEPDist[] { new DGamma(precision) };
Gamma predictOut;
// The array should have length 1 as we have one incoming message.
Vector[] randomFeatures = null;
watch.Start();
bool isUn = true;
bool onlineReady = toPrecisionMap.IsOnlineReady();
double[] uncertainty = null;
if (onlineReady)
{
randomFeatures = toPrecisionMap.GenAllRandomFeatures(incom);
Debug.Assert(randomFeatures.Length == 2,
"Should have 2 feature vectors: one for shape, one for rate.");
double[] thresh = toPrecisionMap.GetUncertaintyThreshold();
uncertainty = toPrecisionMap.EstimateUncertainty(randomFeatures);
isUn = MatrixUtils.SomeGeq(uncertainty, thresh);
}
watch.Stop();
if (isUn)
{
watch.Start();
// Operator is not certain. Query the oracle.
Gamma oracleOut = CGFacOp.PrecisionAverageConditional(precision);
DGamma target = new DGamma(oracleOut);
// TODO: This line can be improved by passing the random features
toPrecisionMap.UpdateOperator(target, incom);
watch.Stop();
if (IsRecordMessages)
{
if (onlineReady)
{
// What to do if this is improper ?
DGamma rawOut = toPrecisionMap.MapToDistFromRandomFeatures(randomFeatures);
predictOut = (Gamma)rawOut.GetWrappedDistribution();
double[] logPredVar = uncertainty;
record.Record(precision, predictOut, true, logPredVar, oracleOut);
}
else
{
// Not record the predicted messages
double[] logPredVar = new double[] { double.NaN, double.NaN };
record.Record(precision, null, true, logPredVar, oracleOut);
}
}
return(oracleOut);
}
else
{
// Operator is sure
watch.Start();
DGamma rawOut = toPrecisionMap.MapToDistFromRandomFeatures(randomFeatures);
predictOut = (Gamma)rawOut.GetWrappedDistribution();
watch.Stop();
double[] logPredVar = uncertainty;
Console.WriteLine(" ** Certain with log predictive variance: {0}",
StringUtils.ArrayToString(logPredVar));
Console.WriteLine("Predicted outgoing: {0}", predictOut);
Gamma?oracleOut = null;
if (IsPrintTrueWhenCertain)
{
oracleOut = CGFacOp.PrecisionAverageConditional(precision);
Console.WriteLine("oracle outgoing: {0}", oracleOut);
}
Console.WriteLine();
if (IsRecordMessages)
{
// compute oracle's outgoing
if (oracleOut == null)
{
oracleOut = CGFacOp.PrecisionAverageConditional(precision);
}
record.Record(precision, predictOut, false, logPredVar, oracleOut.Value);
}
return(predictOut);
}
}
