/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="InnerProductOpBase"]/message_doc[@name="AAverageConditional(Gaussian, Vector, DenseVector, PositiveDefiniteMatrix, VectorGaussian)"]/*'/>
public static VectorGaussian AAverageConditional([SkipIfUniform] Gaussian innerProduct, Vector A, DenseVector BMean, PositiveDefiniteMatrix BVariance, VectorGaussian result)
{
if (innerProduct.IsUniform())
{
return(VectorGaussian.Uniform(A.Count));
}
// logZ = log N(mProduct; A'*BMean, vProduct + A'*BVariance*A)
// = -0.5 (mProduct - A'*BMean)^2 / (vProduct + A'*BVariance*A) -0.5 log(vProduct + A'*BVariance*A)
// v*innerProduct.Precision
double v = 1 + BVariance.QuadraticForm(A, A) * innerProduct.Precision;
double diff = innerProduct.MeanTimesPrecision - A.Inner(BMean) * innerProduct.Precision;
// dlogZ/dA = BMean * (mProduct - A'*BMean)/v + (BVariance*A) (diff)^2 / v^2 - (BVariance*A)/v
double diff2 = diff * diff;
double v2 = v * v;
var avb = BVariance * A;
var avbPrec = avb * innerProduct.Precision;
var dlogZ = (BMean * diff - avbPrec) / v + avb * diff2 / v2;
// -ddlogZ/dA^2 = (BMean.Outer(BMean) + BVariance) / v + avb.Outer(avb) * (4 * diff2 / (v2 * v))
// -(avb.Outer(avb - BMean * (2 * diff)) * 2 + BVariance * diff2) / v2;
PositiveDefiniteMatrix negativeHessian = BVariance * (innerProduct.Precision / v - diff2 / v2);
negativeHessian.SetToSumWithOuter(negativeHessian, innerProduct.Precision / v, BMean, BMean);
negativeHessian.SetToSumWithOuter(negativeHessian, 4 * diff2 / (v2 * v) - 2 * innerProduct.Precision / v2, avb, avbPrec);
negativeHessian.SetToSumWithOuter(negativeHessian, 2 * diff / v2, avbPrec, BMean);
negativeHessian.SetToSumWithOuter(negativeHessian, 2 * diff / v2, BMean, avbPrec);
negativeHessian.Symmetrize();
return(VectorGaussian.FromDerivatives(A, dlogZ, negativeHessian, GaussianProductOp.ForceProper));
}
private void GaussianProductOp_APointMass(double aMean, Gaussian Product, Gaussian B)
{
bool isProper = Product.IsProper();
Gaussian A = Gaussian.PointMass(aMean);
Gaussian result = GaussianProductOp.AAverageConditional(Product, A, B);
Console.WriteLine("{0}: {1}", A, result);
Gaussian result2 = isProper ? GaussianProductOp_Slow.AAverageConditional(Product, A, B) : result;
Console.WriteLine("{0}: {1}", A, result2);
Assert.True(result.MaxDiff(result2) < 1e-6);
var Amsg = InnerProductOp_PointB.BAverageConditional(Product, DenseVector.FromArray(B.GetMean()), new PositiveDefiniteMatrix(new double[, ] {
{ B.GetVariance() }
}), VectorGaussian.PointMass(aMean), VectorGaussian.Uniform(1));
//Console.WriteLine("{0}: {1}", A, Amsg);
Assert.True(result.MaxDiff(Amsg.GetMarginal(0)) < 1e-6);
double prevDiff = double.PositiveInfinity;
for (int i = 3; i < 40; i++)
{
double v = System.Math.Pow(0.1, i);
A = Gaussian.FromMeanAndVariance(aMean, v);
result2 = isProper ? GaussianProductOp.AAverageConditional(Product, A, B) : result;
double diff = result.MaxDiff(result2);
Console.WriteLine("{0}: {1} diff={2}", A, result2, diff.ToString("g4"));
//Assert.True(diff <= prevDiff || diff < 1e-6);
result2 = isProper ? GaussianProductOp_Slow.AAverageConditional(Product, A, B) : result;
diff = result.MaxDiff(result2);
Console.WriteLine("{0}: {1} diff={2}", A, result2, diff.ToString("g4"));
Assert.True(diff <= prevDiff || diff < 1e-6);
prevDiff = diff;
}
}
/// <summary>
/// Predictive distribution at a given list of points
/// </summary>
/// <param name="XList">List of inputs</param>
/// <returns>Predictive distribution</returns>
public VectorGaussian Joint(IList <Vector> XList)
{
if (IsUniform())
{
return(VectorGaussian.Uniform(XList.Count));
}
else
{
PositiveDefiniteMatrix kXX = FixedParameters.Prior.Covariance(XList);
Matrix kXB = FixedParameters.KernelOf_X_B(XList);
kXX.SetToDifference(kXX, kXB * Beta * kXB.Transpose());
VectorGaussian result = new VectorGaussian(kXB * Alpha + FixedParameters.Prior.Mean(XList), kXX);
return(result);
}
}
/// <summary>
/// Loads the priors of BCC and CBCC.
/// </summary>
/// <returns>A BCC posterior instance with the loaded priors.</returns>
BCC.Posteriors ToPriors()
{
int numClasses = Mapping.LabelCount;
int numTasks = Mapping.TaskCount;
int numWorkers = Mapping.WorkerCount;
CommunityModel.Posteriors cbccPriors = new CommunityModel.Posteriors();
BCC.Posteriors priors = IsCommunityModel ? cbccPriors : new BCC.Posteriors();
/// Loads the prior of the background probabilities of the tasks
priors.BackgroundLabelProb = BackgroundLabelProb;
/// Loads the prior of the confusion matrix of each worker
priors.WorkerConfusionMatrix = Util.ArrayInit(numWorkers,
w =>
{
string wid = Mapping.WorkerIndexToId[w];
if (WorkerConfusionMatrix.ContainsKey(wid))
{
return(Util.ArrayInit(numClasses, lab => WorkerConfusionMatrix[wid][lab]));
}
else
{
return(Util.ArrayInit(numClasses, lab => Dirichlet.Uniform(numClasses)));
}
});
/// Loads the true label constraint of each task
priors.TrueLabelConstraint = Util.ArrayInit(numTasks,
t =>
{
string tid = Mapping.TaskIndexToId[t];
if (TrueLabelConstraint.ContainsKey(tid))
{
return(TrueLabelConstraint[Mapping.TaskIndexToId[t]]);
}
else
{
return(Discrete.Uniform(numClasses));
}
});
/// Loads the priors of the parameters of CBCC
if (IsCommunityModel)
{
cbccPriors.CommunityConfusionMatrix = CommunityConfusionMatrix;
cbccPriors.WorkerScoreMatrixConstraint = Util.ArrayInit(numWorkers,
w =>
{
string wid = Mapping.WorkerIndexToId[w];
if (WorkerScoreMatrixConstraint.ContainsKey(wid))
{
return(Util.ArrayInit(numClasses, lab => WorkerScoreMatrixConstraint[wid][lab]));
}
else
{
return(Util.ArrayInit(numClasses, lab => VectorGaussian.Uniform(numClasses)));
}
});
cbccPriors.CommunityProb = CommunityProb;
cbccPriors.CommunityScoreMatrix = CommunityScoreMatrix;
cbccPriors.WorkerCommunityConstraint = Util.ArrayInit(numWorkers,
w =>
{
string wid = Mapping.WorkerIndexToId[w];
if (CommunityConstraint.ContainsKey(wid))
{
return(CommunityConstraint[wid]);
}
else
{
return(Discrete.Uniform(CommunityCount));
}
});
}
priors.Evidence = ModelEvidence;
return(priors);
}
/// <summary>
/// Attachs the data to the workers labels and sets the constraints on the community score matrices and
/// the community memberships (used for online training).
/// </summary>
/// <param name="taskIndices">The matrix of the task indices (columns) of each worker (rows).</param>
/// <param name="workerLabels">The matrix of the labels (columns) of each worker (rows).</param>
/// <param name="scoreConstraint">The constraint of the community score matrices.</param>
/// <param name="communityConstraint">The constraint of the workers community membership.</param>
protected void AttachData(int[][] taskIndices, int[][] workerLabels, VectorGaussian[][] scoreConstraint, Discrete[] communityConstraint)
{
int communityCount = m.SizeAsInt;
int workerCount = workerLabels.Length;
int labelCount = c.SizeAsInt;
base.AttachData(taskIndices, workerLabels);
CommunityInit.ObservedValue = Util.ArrayInit(workerCount, worker => Discrete.PointMass(Rand.Int(communityCount), communityCount));
if (scoreConstraint != null)
{
ScoreMatrixConstraint.ObservedValue = scoreConstraint;
}
else
{
ScoreMatrixConstraint.ObservedValue = Util.ArrayInit(workerCount, w => Util.ArrayInit(labelCount, lab => VectorGaussian.Uniform(labelCount)));
}
if (communityConstraint != null)
{
CommunityConstraint.ObservedValue = communityConstraint;
}
else
{
CommunityConstraint.ObservedValue = Util.ArrayInit(workerCount, w => Discrete.Uniform(communityCount));
}
}
BCCPosteriors ToPriors()
{
int numClasses = Mapping.LabelCount;
int numTasks = Mapping.TaskCount;
int numWorkers = Mapping.WorkerCount;
CBCCPosteriors cbccPriors = new CBCCPosteriors();
BCCPosteriors priors = IsCommunityModel ? cbccPriors : new BCCPosteriors();
priors.BackgroundLabelProb = BackgroundLabelProb;
priors.WorkerConfusionMatrix = Util.ArrayInit(numWorkers,
w =>
{
string wid = Mapping.WorkerIndexToId[w];
if (WorkerConfusionMatrix.ContainsKey(wid))
{
return(Util.ArrayInit(numClasses, c => WorkerConfusionMatrix[wid][c]));
}
else
{
return(Util.ArrayInit(numClasses, c => Dirichlet.Uniform(numClasses)));
}
});
priors.TrueLabelConstraint = Util.ArrayInit(numTasks,
t =>
{
string tid = Mapping.TaskIndexToId[t];
if (TrueLabelConstraint.ContainsKey(tid))
{
return(TrueLabelConstraint[Mapping.TaskIndexToId[t]]);
}
else
{
return(Discrete.Uniform(numClasses));
}
});
if (IsCommunityModel)
{
cbccPriors.CommunityConfusionMatrix = CommunityConfusionMatrix;
cbccPriors.WorkerScoreMatrixConstraint = Util.ArrayInit(numWorkers,
w =>
{
string wid = Mapping.WorkerIndexToId[w];
if (WorkerScoreMatrixConstraint.ContainsKey(wid))
{
return(Util.ArrayInit(numClasses, c => WorkerScoreMatrixConstraint[wid][c]));
}
else
{
return(Util.ArrayInit(numClasses, c => VectorGaussian.Uniform(numClasses)));
}
});
cbccPriors.CommunityProb = CommunityProb;
cbccPriors.CommunityScoreMatrix = CommunityScoreMatrix;
cbccPriors.WorkerCommunityConstraint = Util.ArrayInit(numWorkers,
w =>
{
string wid = Mapping.WorkerIndexToId[w];
if (CommunityConstraint.ContainsKey(wid))
{
return(CommunityConstraint[wid]);
}
else
{
return(Discrete.Uniform(CommunityCount));
}
});
}
priors.Evidence = ModelEvidence;
return(priors);
}
public static Vector GP(double scaling, Vector[] x, int[] hypersToOptimise, KernelFunction initialKernel)
{
return(VectorGaussian.Uniform(x.Length).Sample());
}