/// <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()); }