/// <summary> /// VMP message to 'sample' /// </summary> /// <param name="probsTrue">Incoming message from 'probsTrue'. Must be a proper distribution. If any element is uniform, the result will be uniform.</param> /// <returns>The outgoing VMP message to the 'sample' argument</returns> /// <remarks><para> /// The outgoing message is the exponential of the average log-factor value, where the average is over all arguments except 'sample'. /// The formula is <c>exp(sum_(probsTrue) p(probsTrue) log(factor(sample,probsTrue)))</c>. /// </para></remarks> /// <exception cref="ImproperMessageException"><paramref name="probsTrue"/> is not a proper distribution</exception> public static BernoulliIntegerSubset SampleAverageLogarithm([SkipIfUniform] SparseBetaList probsTrue) { var logOdds = SparseVector.Zero(probsTrue.Count); logOdds.SetToFunction(probsTrue.TrueCounts, probsTrue.FalseCounts, SparseBernoulliFromBetaOp.ComputeLogOdds); return(new BernoulliIntegerSubset(logOdds)); }
/// <summary>VMP message to <c>sample</c>.</summary> /// <param name="probTrue">Incoming message from <c>probTrue</c>. Must be a proper distribution. If any element is uniform, the result will be uniform.</param> /// <param name="result">Modified to contain the outgoing message.</param> /// <returns> /// <paramref name="result" /> /// </returns> /// <remarks> /// <para>The outgoing message is the exponential of the average log-factor value, where the average is over all arguments except <c>sample</c>. The formula is <c>exp(sum_(probTrue) p(probTrue) log(factor(sample,probTrue)))</c>.</para> /// </remarks> /// <exception cref="ImproperMessageException"> /// <paramref name="probTrue" /> is not a proper distribution.</exception> public static BernoulliIntegerSubset SampleAverageLogarithm([SkipIfUniform] SparseBetaList probTrue, BernoulliIntegerSubset result) { Func <Beta, Bernoulli> f = BernoulliFromBetaOp.SampleAverageLogarithm; result.SetTo(f.Map(probTrue)); return(result); }
//-- VMP ------------------------------------------------------------------------------------------- /// <summary> /// Evidence message for VMP /// </summary> /// <param name="sample">Incoming message from 'sample'. Must be a proper distribution. If any element is uniform, the result will be uniform.</param> /// <param name="probsTrue">Incoming message from 'probsTrue'. Must be a proper distribution. If any element is uniform, the result will be uniform.</param> /// <param name="MeanLog">Buffer 'MeanLog'.</param> /// <param name="MeanLogOneMinus">Buffer 'MeanLogOneMinus'.</param> /// <returns>Average of the factor's log-value across the given argument distributions</returns> /// <remarks><para> /// The formula for the result is <c>sum_(sample,probsTrue) p(sample,probsTrue) log(factor(sample,probsTrue))</c>. /// Adding up these values across all factors and variables gives the log-evidence estimate for VMP. /// </para></remarks> /// <exception cref="ImproperMessageException"><paramref name="sample"/> is not a proper distribution</exception> /// <exception cref="ImproperMessageException"><paramref name="probsTrue"/> is not a proper distribution</exception> public static double AverageLogFactor([Proper] SparseBernoulliListBase sample, [Proper] SparseBetaList probsTrue, SparseVector MeanLog, SparseVector MeanLogOneMinus) { //var MeanLogOneMinus = probsTrue.GetMeanLogOneMinus(); var p = sample.GetProbTrueVector(); var res = p * MeanLog + (1 - p) * MeanLogOneMinus; return(res.Sum()); }
public void SparseDistributionListTolerances() { var bern = SparseBernoulliList.FromSize(1); var beta = SparseBetaList.FromSize(1); var gamma = SparseGammaList.FromSize(1); var gauss = SparseGaussianList.FromSize(1); double origBernDefaultTolerance = SparseBernoulliList.DefaultTolerance; double origBetaDefaultTolerance = SparseBetaList.DefaultTolerance; double origGammaDefaultTolerance = SparseGammaList.DefaultTolerance; double origGaussDefaultTolerance = SparseGaussianList.DefaultTolerance; Assert.Equal(origBernDefaultTolerance, bern.Tolerance); Assert.Equal(origBetaDefaultTolerance, beta.Tolerance); Assert.Equal(origGammaDefaultTolerance, gamma.Tolerance); Assert.Equal(origGaussDefaultTolerance, gauss.Tolerance); double newBernDefaultTolerance = 0.1; double newBetaDefaultTolerance = 0.2; double newGammaDefaultTolerance = 0.3; double newGaussDefaultTolerance = 0.4; try { // Checks that we can maintain different default tolerances // on different specializations of the generic base class SparseBernoulliList.DefaultTolerance = newBernDefaultTolerance; SparseBetaList.DefaultTolerance = newBetaDefaultTolerance; SparseGammaList.DefaultTolerance = newGammaDefaultTolerance; SparseGaussianList.DefaultTolerance = newGaussDefaultTolerance; Assert.Equal(newBernDefaultTolerance, SparseBernoulliList.DefaultTolerance); Assert.Equal(newBetaDefaultTolerance, SparseBetaList.DefaultTolerance); Assert.Equal(newGammaDefaultTolerance, SparseGammaList.DefaultTolerance); Assert.Equal(newGaussDefaultTolerance, SparseGaussianList.DefaultTolerance); // Now check that the default tolerance gets picked up by the factory methods. bern = SparseBernoulliList.FromSize(1); beta = SparseBetaList.FromSize(1); gamma = SparseGammaList.FromSize(1); gauss = SparseGaussianList.FromSize(1); Assert.Equal(newBernDefaultTolerance, bern.Tolerance); Assert.Equal(newBetaDefaultTolerance, beta.Tolerance); Assert.Equal(newGammaDefaultTolerance, gamma.Tolerance); Assert.Equal(newGaussDefaultTolerance, gauss.Tolerance); } finally { // Now revert back so that we don't spoil the other tests SparseBernoulliList.DefaultTolerance = origBernDefaultTolerance; SparseBetaList.DefaultTolerance = origBetaDefaultTolerance; SparseGammaList.DefaultTolerance = origGammaDefaultTolerance; SparseGaussianList.DefaultTolerance = origGaussDefaultTolerance; } }
/// <summary> /// Evidence message for VMP /// </summary> /// <param name="sample">Constant value for 'sample'.</param> /// <param name="probsTrue">Incoming message from 'probsTrue'. Must be a proper distribution. If any element is uniform, the result will be uniform.</param> /// <param name="SumMeanLogOneMinus"></param> /// <param name="MeanLogMinusMeanLogOneMinus">Buffer 'MeanLogMinusMeanLogOneMinus'.</param> /// <returns>Average of the factor's log-value across the given argument distributions</returns> /// <remarks><para> /// The formula for the result is <c>sum_(probsTrue) p(probsTrue) log(factor(sample,probsTrue))</c>. /// Adding up these values across all factors and variables gives the log-evidence estimate for VMP. /// </para></remarks> /// <exception cref="ImproperMessageException"><paramref name="probsTrue"/> is not a proper distribution</exception> public static double AverageLogFactor(IList <int> sample, [Proper] SparseBetaList probsTrue, double SumMeanLogOneMinus, SparseVector MeanLogMinusMeanLogOneMinus) { //var MeanLogOneMinus = probsTrue.GetMeanLogOneMinus(); double ev = SumMeanLogOneMinus; // assume 'sample' is very sparse foreach (int i in sample) { ev += MeanLogMinusMeanLogOneMinus[i]; } return(ev); }
/// <summary> /// VMP message to 'probsTrue' /// </summary> /// <param name="sample">Constant value for 'sample'.</param> /// <param name="result">Modified to contain the outgoing message</param> /// <returns><paramref name="result"/></returns> /// <remarks><para> /// The outgoing message is the factor viewed as a function of 'probsTrue' conditioned on the given values. /// </para></remarks> public static SparseBetaList ProbsTrueAverageLogarithm(IList <int> sample, SparseBetaList result) { var trueCounts = result.TrueCounts; var falseCounts = result.FalseCounts; trueCounts.SetAllElementsTo(1.0); falseCounts.SetAllElementsTo(2.0); foreach (int i in sample) { trueCounts[i] = 2; falseCounts[i] = 1; } return(result); }
/// <summary> /// Evidence message for VMP /// </summary> /// <param name="sample">Constant value for 'sample'.</param> /// <param name="probsTrue">Incoming message from 'probsTrue'. Must be a proper distribution. If any element is uniform, the result will be uniform.</param> /// <param name="MeanLogOneMinus">Buffer 'MeanLogOneMinus'.</param> /// <returns>Average of the factor's log-value across the given argument distributions</returns> /// <remarks><para> /// The formula for the result is <c>sum_(probsTrue) p(probsTrue) log(factor(sample,probsTrue))</c>. /// Adding up these values across all factors and variables gives the log-evidence estimate for VMP. /// </para></remarks> /// <exception cref="ImproperMessageException"><paramref name="probsTrue"/> is not a proper distribution</exception> public static double AverageLogFactor(IList <bool> sample, [Proper] SparseBetaList probsTrue, SparseVector MeanLogOneMinus) { //var MeanLogOneMinus = probsTrue.GetMeanLogOneMinus(); double ev = MeanLogOneMinus.Sum(); int count = sample.Count; // assume 'sample' is very sparse bool[] sampleAsArray = (bool[])sample; for (int i = 0; i < count; i++) { if (!sampleAsArray[i]) { continue; } ev -= MeanLogOneMinus[i]; ev += SparseBetaList.ComputeMeanLog(probsTrue.TrueCounts[i], probsTrue.FalseCounts[i]); } return(ev); }
/// <summary>Evidence message for VMP.</summary> /// <param name="sample">Incoming message from <c>sample</c>.</param> /// <param name="probTrue">Incoming message from <c>probTrue</c>. Must be a proper distribution. If any element is uniform, the result will be uniform.</param> /// <returns>Average of the factor's log-value across the given argument distributions.</returns> /// <remarks> /// <para>The formula for the result is <c>sum_(sample,probTrue) p(sample,probTrue) log(factor(sample,probTrue))</c>. Adding up these values across all factors and variables gives the log-evidence estimate for VMP.</para> /// </remarks> /// <exception cref="ImproperMessageException"> /// <paramref name="probTrue" /> is not a proper distribution.</exception> public static double AverageLogFactor(BernoulliIntegerSubset sample, [Proper] SparseBetaList probTrue) { Func <Bernoulli, Beta, double> f = BernoulliFromBetaOp.AverageLogFactor; return(f.Map(sample.SparseBernoulliList, probTrue).EnumerableSum(x => x)); }
/// <summary>EP message to <c>probTrue</c>.</summary> /// <param name="sample">Incoming message from <c>sample</c>. Must be a proper distribution. If any element is uniform, the result will be uniform.</param> /// <param name="probTrue">Incoming message from <c>probTrue</c>.</param> /// <param name="result">Modified to contain the outgoing message.</param> /// <returns> /// <paramref name="result" /> /// </returns> /// <remarks> /// <para>The outgoing message is a distribution matching the moments of <c>probTrue</c> as the random arguments are varied. The formula is <c>proj[p(probTrue) sum_(sample) p(sample) factor(sample,probTrue)]/p(probTrue)</c>.</para> /// </remarks> /// <exception cref="ImproperMessageException"> /// <paramref name="sample" /> is not a proper distribution.</exception> public static SparseBetaList ProbTrueAverageConditional([SkipIfUniform] BernoulliIntegerSubset sample, SparseBetaList probTrue, SparseBetaList result) { Func <Bernoulli, Beta, Beta> f = BernoulliFromBetaOp.ProbTrueAverageConditional; result.SetTo(f.Map(sample.SparseBernoulliList, probTrue)); return(result); }
public static double LogEvidenceRatio(SparseBernoulliList sample, SparseBetaList probTrue) { return(0.0); }
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="SparseBernoulliFromBetaOp"]/message_doc[@name="ProbTrueAverageLogarithm(SparseBernoulliList, SparseBetaList)"]/*'/> public static SparseBetaList ProbTrueAverageLogarithm(SparseBernoulliList sample, SparseBetaList result) { result.SetToFunction(sample, s => BernoulliFromBetaOp.ProbTrueAverageLogarithm(s)); return(result); }
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="SparseBernoulliFromBetaOp"]/message_doc[@name="AverageLogFactor(ISparseList{bool}, SparseBetaList)"]/*'/> public static double AverageLogFactor(ISparseList <bool> sample, [Proper] SparseBetaList probTrue) { Func <bool, Beta, double> f = BernoulliFromBetaOp.AverageLogFactor; return(f.Map(sample, probTrue).EnumerableSum(x => x)); }
/// <summary>VMP message to <c>probTrue</c>.</summary> /// <param name="sample">Constant value for <c>sample</c>.</param> /// <param name="result">Modified to contain the outgoing message.</param> /// <returns> /// <paramref name="result" /> /// </returns> /// <remarks> /// <para>The outgoing message is the factor viewed as a function of <c>probTrue</c> conditioned on the given values.</para> /// </remarks> public static SparseBetaList ProbTrueAverageLogarithm(IList <int> sample, SparseBetaList result) { result.SetToFunction(BernoulliIntegerSubset.SubsetToList(sample, result.Count), s => BernoulliFromBetaOp.ProbTrueAverageLogarithm(s)); return(result); }
/// <summary> /// Update the buffer 'MeanLogMinusMeanLogOneMinus' /// </summary> /// <param name="probsTrue">Incoming message from 'probsTrue'. Must be a proper distribution. If any element is uniform, the result will be uniform.</param> /// <returns>New value of buffer 'MeanLogMinusMeanLogOneMinus'</returns> /// <remarks><para> /// /// </para></remarks> /// <exception cref="ImproperMessageException"><paramref name="probsTrue"/> is not a proper distribution</exception> public static SparseVector MeanLogMinusMeanLogOneMinus([Proper] SparseBetaList probsTrue) { return((SparseVector)(probsTrue.GetMeanLog() - probsTrue.GetMeanLogOneMinus())); }
/// <summary> /// Update the buffer 'SumMeanLogOneMinus' /// </summary> /// <param name="probsTrue">Incoming message from 'probsTrue'. Must be a proper distribution. If any element is uniform, the result will be uniform.</param> /// <returns>New value of buffer 'SumMeanLogOneMinus'</returns> /// <remarks><para> /// /// </para></remarks> /// <exception cref="ImproperMessageException"><paramref name="probsTrue"/> is not a proper distribution</exception> public static double SumMeanLogOneMinus([Proper] SparseBetaList probsTrue) { return(probsTrue.GetMeanLogOneMinus().Sum()); }
//-- VMP ------------------------------------------------------------------------------------------- /// <summary> /// Evidence message for VMP /// </summary> /// <param name="sample">Incoming message from 'sample'. Must be a proper distribution. If any element is uniform, the result will be uniform.</param> /// <param name="probsTrue">Incoming message from 'probsTrue'. Must be a proper distribution. If any element is uniform, the result will be uniform.</param> /// <param name="MeanLog"></param> /// <param name="MeanLogOneMinus"></param> /// <returns>Average of the factor's log-value across the given argument distributions</returns> /// <remarks><para> /// The formula for the result is <c>sum_(probsTrue) p(probsTrue) log(factor(sample,probsTrue))</c>. /// Adding up these values across all factors and variables gives the log-evidence estimate for VMP. /// </para></remarks> /// <exception cref="ImproperMessageException"><paramref name="probsTrue"/> is not a proper distribution</exception> public static double AverageLogFactor([Proper] BernoulliIntegerSubset sample, [Proper] SparseBetaList probsTrue, SparseVector MeanLog, SparseVector MeanLogOneMinus) { return(SparseBernoulliFromBetaOp.AverageLogFactor(sample, probsTrue, MeanLog, MeanLogOneMinus)); }
/// <summary>Evidence message for VMP.</summary> /// <param name="sample">Constant value for <c>sample</c>.</param> /// <param name="probTrue">Incoming message from <c>probTrue</c>. Must be a proper distribution. If any element is uniform, the result will be uniform.</param> /// <returns>Average of the factor's log-value across the given argument distributions.</returns> /// <remarks> /// <para>The formula for the result is <c>sum_(probTrue) p(probTrue) log(factor(sample,probTrue))</c>. Adding up these values across all factors and variables gives the log-evidence estimate for VMP.</para> /// </remarks> /// <exception cref="ImproperMessageException"> /// <paramref name="probTrue" /> is not a proper distribution.</exception> public static double AverageLogFactor(IList <int> sample, [Proper] SparseBetaList probTrue) { Func <bool, Beta, double> f = BernoulliFromBetaOp.AverageLogFactor; return(f.Map(BernoulliIntegerSubset.SubsetToList(sample, probTrue.Count), probTrue).EnumerableSum(x => x)); }
public void SparseBernoulliFromBetaFactor() { var calcSuffix = ": calculation differs between sparse and dense"; var sparsitySuffix = ": result is not sparse as expected"; var calcErrMsg = ""; var sparsityErrMsg = ""; var tolerance = 1e-10; Rand.Restart(12347); int listSize = 50; var sparseProbTrueDist = SparseBetaList.Constant(listSize, new Beta(1, 2)); sparseProbTrueDist[3] = new Beta(4, 5); sparseProbTrueDist[6] = new Beta(7, 8); var probTrueDist = sparseProbTrueDist.ToArray(); var sparseProbTruePoint = SparseList <double> .Constant(listSize, 0.1); sparseProbTruePoint[3] = 0.7; sparseProbTruePoint[6] = 0.8; var probTruePoint = sparseProbTruePoint.ToArray(); var sparseSampleDist = SparseBernoulliList.Constant(listSize, new Bernoulli(0.1)); sparseSampleDist[3] = new Bernoulli(0.8); sparseSampleDist[9] = new Bernoulli(0.9); var sampleDist = sparseSampleDist.ToArray(); var sparseSamplePoint = SparseList <bool> .Constant(listSize, false); sparseSamplePoint[3] = true; sparseSamplePoint[9] = true; var samplePoint = sparseSamplePoint.ToArray(); var toSparseSampleDist = SparseBernoulliList.Constant(listSize, new Bernoulli(0.1)); toSparseSampleDist[3] = new Bernoulli(0.4); toSparseSampleDist[4] = new Bernoulli(0.8); var toSampleDist = toSparseSampleDist.ToArray(); // --------------------------- // Check average log factor // --------------------------- calcErrMsg = "Average log factor" + calcSuffix; // Dist, dist var sparseAvgLog = SparseBernoulliFromBetaOp.AverageLogFactor(sparseSampleDist, sparseProbTrueDist); var avgLog = Util.ArrayInit(listSize, i => BernoulliFromBetaOp.AverageLogFactor(sampleDist[i], probTrueDist[i])).Sum(); TAssert.True(System.Math.Abs(avgLog - sparseAvgLog) < tolerance, calcErrMsg); // Dist, point sparseAvgLog = SparseBernoulliFromBetaOp.AverageLogFactor(sparseSampleDist, sparseProbTruePoint); avgLog = Util.ArrayInit(listSize, i => BernoulliFromBetaOp.AverageLogFactor(sampleDist[i], probTruePoint[i])).Sum(); TAssert.True(System.Math.Abs(avgLog - sparseAvgLog) < tolerance, calcErrMsg); // Point, dist sparseAvgLog = SparseBernoulliFromBetaOp.AverageLogFactor(sparseSamplePoint, sparseProbTrueDist); avgLog = Util.ArrayInit(listSize, i => BernoulliFromBetaOp.AverageLogFactor(samplePoint[i], probTrueDist[i])).Sum(); TAssert.True(System.Math.Abs(avgLog - sparseAvgLog) < tolerance, calcErrMsg); // Point, point sparseAvgLog = SparseBernoulliFromBetaOp.AverageLogFactor(sparseSamplePoint, sparseProbTruePoint); avgLog = Util.ArrayInit(listSize, i => BernoulliFromBetaOp.AverageLogFactor(samplePoint[i], probTruePoint[i])).Sum(); TAssert.True(System.Math.Abs(avgLog - sparseAvgLog) < tolerance, calcErrMsg); // --------------------------- // Check log average factor // --------------------------- calcErrMsg = "Log average factor" + calcSuffix; var sparseLogAvg = SparseBernoulliFromBetaOp.LogAverageFactor(sparseSampleDist, toSparseSampleDist); var logAvg = Util.ArrayInit(listSize, i => BernoulliFromBetaOp.LogAverageFactor(sampleDist[i], toSampleDist[i])).Sum(); TAssert.True(System.Math.Abs(logAvg - sparseLogAvg) < tolerance, calcErrMsg); sparseLogAvg = SparseBernoulliFromBetaOp.LogAverageFactor(sparseSamplePoint, sparseProbTrueDist); logAvg = Util.ArrayInit(listSize, i => BernoulliFromBetaOp.LogAverageFactor(samplePoint[i], probTrueDist[i])).Sum(); TAssert.True(System.Math.Abs(logAvg - sparseLogAvg) < tolerance, calcErrMsg); sparseLogAvg = SparseBernoulliFromBetaOp.LogAverageFactor(sparseSamplePoint, sparseProbTruePoint); logAvg = Util.ArrayInit(listSize, i => BernoulliFromBetaOp.LogAverageFactor(samplePoint[i], probTruePoint[i])).Sum(); TAssert.True(System.Math.Abs(logAvg - sparseLogAvg) < tolerance, calcErrMsg); // --------------------------- // Check log evidence ratio // --------------------------- calcErrMsg = "Log evidence ratio" + calcSuffix; // Dist, dist var sparseEvidRat = SparseBernoulliFromBetaOp.LogEvidenceRatio(sparseSampleDist, sparseProbTrueDist); var evidRat = Util.ArrayInit(listSize, i => BernoulliFromBetaOp.LogEvidenceRatio(sampleDist[i], probTrueDist[i])).Sum(); TAssert.True(System.Math.Abs(evidRat - sparseEvidRat) < tolerance, calcErrMsg); // Dist, point sparseEvidRat = SparseBernoulliFromBetaOp.LogEvidenceRatio(sparseSampleDist, sparseProbTruePoint); evidRat = Util.ArrayInit(listSize, i => BernoulliFromBetaOp.LogEvidenceRatio(sampleDist[i], probTruePoint[i])).Sum(); TAssert.True(System.Math.Abs(evidRat - sparseEvidRat) < tolerance, calcErrMsg); // Point, dist sparseEvidRat = SparseBernoulliFromBetaOp.LogEvidenceRatio(sparseSamplePoint, sparseProbTrueDist); evidRat = Util.ArrayInit(listSize, i => BernoulliFromBetaOp.LogEvidenceRatio(samplePoint[i], probTrueDist[i])).Sum(); TAssert.True(System.Math.Abs(evidRat - sparseEvidRat) < tolerance, calcErrMsg); // Point, point sparseEvidRat = SparseBernoulliFromBetaOp.LogEvidenceRatio(sparseSamplePoint, sparseProbTruePoint); evidRat = Util.ArrayInit(listSize, i => BernoulliFromBetaOp.LogEvidenceRatio(samplePoint[i], probTruePoint[i])).Sum(); TAssert.True(System.Math.Abs(evidRat - sparseEvidRat) < tolerance, calcErrMsg); // --------------------------- // Check SampleConditional // --------------------------- calcErrMsg = "SampleConditional" + calcSuffix; sparsityErrMsg = "SampleConditional" + sparsitySuffix; // Use different common value to ensure this gets properly set var sparseSampleConditional = SparseBernoulliList.Constant(listSize, new Bernoulli(0.5)); sparseSampleConditional = SparseBernoulliFromBetaOp.SampleConditional(sparseProbTruePoint, sparseSampleConditional); var sampleConditional = Util.ArrayInit(listSize, i => BernoulliFromBetaOp.SampleConditional(probTruePoint[i])); TAssert.True(2 == sparseSampleConditional.SparseCount, sparsityErrMsg); TAssert.True(sparseSampleConditional.MaxDiff(sampleConditional) < tolerance, calcErrMsg); // --------------------------- // Check SampleAverageConditional // --------------------------- calcErrMsg = "SampleAverageConditional" + calcSuffix; sparsityErrMsg = "SampleAverageConditional" + sparsitySuffix; // Use different common value to ensure this gets properly set var sparseSampleAvgConditional = SparseBernoulliList.Constant(listSize, new Bernoulli(0.5)); sparseSampleAvgConditional = SparseBernoulliFromBetaOp.SampleAverageConditional(sparseProbTrueDist, sparseSampleAvgConditional); var sampleAvgConditional = Util.ArrayInit(listSize, i => BernoulliFromBetaOp.SampleAverageConditional(probTrueDist[i])); TAssert.True(2 == sparseSampleAvgConditional.SparseCount, sparsityErrMsg); TAssert.True(sparseSampleAvgConditional.MaxDiff(sampleAvgConditional) < tolerance, calcErrMsg); sparseSampleAvgConditional = SparseBernoulliList.Constant(listSize, new Bernoulli(0.5)); sparseSampleAvgConditional = SparseBernoulliFromBetaOp.SampleAverageConditional(sparseProbTruePoint, sparseSampleAvgConditional); sampleAvgConditional = Util.ArrayInit(listSize, i => BernoulliFromBetaOp.SampleAverageConditional(probTruePoint[i])); TAssert.True(2 == sparseSampleAvgConditional.SparseCount, sparsityErrMsg); TAssert.True(sparseSampleAvgConditional.MaxDiff(sampleAvgConditional) < tolerance, calcErrMsg); // --------------------------- // Check ProbTrueConditional // --------------------------- calcErrMsg = "ProbTrueConditional" + calcSuffix; sparsityErrMsg = "ProbTrueConditional" + sparsitySuffix; // Use different common value to ensure this gets properly set var sparseProbTrueConditional = SparseBetaList.Constant(listSize, new Beta(1.1, 2.2)); sparseProbTrueConditional = SparseBernoulliFromBetaOp.ProbTrueConditional(sparseSamplePoint, sparseProbTrueConditional); var probTrueConditional = Util.ArrayInit(listSize, i => BernoulliFromBetaOp.ProbTrueConditional(samplePoint[i])); TAssert.True(2 == sparseProbTrueConditional.SparseCount, sparsityErrMsg); TAssert.True(sparseProbTrueConditional.MaxDiff(probTrueConditional) < tolerance, calcErrMsg); // --------------------------- // Check ProbTrueAverageConditional // --------------------------- calcErrMsg = "ProbTrueAverageConditional" + calcSuffix; sparsityErrMsg = "ProbTrueAverageConditional" + sparsitySuffix; // Use different common value to ensure this gets properly set var sparseProbTrueAvgConditional = SparseBetaList.Constant(listSize, new Beta(1.1, 2.2)); sparseProbTrueAvgConditional = SparseBernoulliFromBetaOp.ProbTrueAverageConditional(sparseSampleDist, sparseProbTrueDist, sparseProbTrueAvgConditional); var probTrueAvgConditional = Util.ArrayInit(listSize, i => BernoulliFromBetaOp.ProbTrueAverageConditional(sampleDist[i], probTrueDist[i])); TAssert.True(2 == sparseProbTrueAvgConditional.SparseCount, sparsityErrMsg); TAssert.True(sparseProbTrueAvgConditional.MaxDiff(probTrueAvgConditional) < tolerance, calcErrMsg); sparseProbTrueAvgConditional = SparseBetaList.Constant(listSize, new Beta(1.1, 2.2)); sparseProbTrueAvgConditional = SparseBernoulliFromBetaOp.ProbTrueAverageConditional(sparseSamplePoint, sparseProbTrueAvgConditional); probTrueAvgConditional = Util.ArrayInit(listSize, i => BernoulliFromBetaOp.ProbTrueAverageConditional(samplePoint[i])); TAssert.True(2 == sparseProbTrueAvgConditional.SparseCount, sparsityErrMsg); TAssert.True(sparseProbTrueAvgConditional.MaxDiff(probTrueAvgConditional) < tolerance, calcErrMsg); // --------------------------- // Check SampleAverageLogarithm // --------------------------- calcErrMsg = "SampleAverageLogarithm" + calcSuffix; sparsityErrMsg = "SampleAverageLogarithm" + sparsitySuffix; // Use different common value to ensure this gets properly set var sparseSampleAvgLogarithm = SparseBernoulliList.Constant(listSize, new Bernoulli(0.5)); sparseSampleAvgLogarithm = SparseBernoulliFromBetaOp.SampleAverageLogarithm(sparseProbTrueDist, sparseSampleAvgLogarithm); var sampleAvgLogarithm = Util.ArrayInit(listSize, i => BernoulliFromBetaOp.SampleAverageLogarithm(probTrueDist[i])); TAssert.True(2 == sparseSampleAvgLogarithm.SparseCount, sparsityErrMsg); TAssert.True(sparseSampleAvgLogarithm.MaxDiff(sampleAvgLogarithm) < tolerance, calcErrMsg); sparseSampleAvgLogarithm = SparseBernoulliList.Constant(listSize, new Bernoulli(0.5)); sparseSampleAvgLogarithm = SparseBernoulliFromBetaOp.SampleAverageLogarithm(sparseProbTruePoint, sparseSampleAvgLogarithm); sampleAvgLogarithm = Util.ArrayInit(listSize, i => BernoulliFromBetaOp.SampleAverageLogarithm(probTruePoint[i])); TAssert.True(2 == sparseSampleAvgLogarithm.SparseCount, sparsityErrMsg); TAssert.True(sparseSampleAvgLogarithm.MaxDiff(sampleAvgLogarithm) < tolerance, calcErrMsg); // --------------------------- // Check ProbTrueAverageLogarithm // --------------------------- calcErrMsg = "ProbTrueAverageLogarithm" + calcSuffix; sparsityErrMsg = "ProbTrueAverageLogarithm" + sparsitySuffix; // Use different common value to ensure this gets properly set var sparseProbTrueAvgLogarithm = SparseBetaList.Constant(listSize, new Beta(1.1, 2.2)); sparseProbTrueAvgLogarithm = SparseBernoulliFromBetaOp.ProbTrueAverageLogarithm(sparseSampleDist, sparseProbTrueAvgLogarithm); var probTrueAvgLogarithm = Util.ArrayInit(listSize, i => BernoulliFromBetaOp.ProbTrueAverageLogarithm(sampleDist[i])); TAssert.True(2 == sparseProbTrueAvgLogarithm.SparseCount, sparsityErrMsg); TAssert.True(sparseProbTrueAvgLogarithm.MaxDiff(probTrueAvgLogarithm) < tolerance, calcErrMsg); sparseProbTrueAvgLogarithm = SparseBetaList.Constant(listSize, new Beta(1.1, 2.2)); sparseProbTrueAvgLogarithm = SparseBernoulliFromBetaOp.ProbTrueAverageLogarithm(sparseSamplePoint, sparseProbTrueAvgLogarithm); probTrueAvgLogarithm = Util.ArrayInit(listSize, i => BernoulliFromBetaOp.ProbTrueAverageLogarithm(samplePoint[i])); TAssert.True(2 == sparseProbTrueAvgLogarithm.SparseCount, sparsityErrMsg); TAssert.True(sparseProbTrueAvgLogarithm.MaxDiff(probTrueAvgLogarithm) < tolerance, calcErrMsg); }
/// <summary> /// VMP message to 'probsTrue' /// </summary> /// <param name="sample">Constant value for 'sample'.</param> /// <param name="result">Modified to contain the outgoing message</param> /// <returns><paramref name="result"/></returns> /// <remarks><para> /// The outgoing message is the factor viewed as a function of 'probsTrue' conditioned on the given values. /// </para></remarks> public static SparseBetaList ProbsTrueAverageLogarithm(IList<int> sample, SparseBetaList result) { var trueCounts =result.TrueCounts; var falseCounts =result.FalseCounts; trueCounts.SetAllElementsTo(1.0); falseCounts.SetAllElementsTo(2.0); foreach(int i in sample) { trueCounts[i] = 2; falseCounts[i] = 1; } return result; }
/// <summary>Evidence message for EP.</summary> /// <param name="sample">Constant value for <c>sample</c>.</param> /// <param name="probTrue">Incoming message from <c>probTrue</c>.</param> /// <returns>Logarithm of the factor's contribution the EP model evidence.</returns> /// <remarks> /// <para>The formula for the result is <c>log(sum_(probTrue) p(probTrue) factor(sample,probTrue))</c>. Adding up these values across all factors and variables gives the log-evidence estimate for EP.</para> /// </remarks> public static double LogEvidenceRatio(IList <int> sample, SparseBetaList probTrue) { Func <bool, Beta, double> f = BernoulliFromBetaOp.LogEvidenceRatio; return(f.Map(BernoulliIntegerSubset.SubsetToList(sample, probTrue.Count), probTrue).EnumerableSum(x => x)); }
/// <summary> /// Update the buffer 'MeanLog' /// </summary> /// <param name="probsTrue">Incoming message from 'probsTrue'. Must be a proper distribution. If any element is uniform, the result will be uniform.</param> /// <returns>New value of buffer 'MeanLog'</returns> /// <remarks><para> /// /// </para></remarks> /// <exception cref="ImproperMessageException"><paramref name="probsTrue"/> is not a proper distribution</exception> public static SparseVector MeanLog([Proper] SparseBetaList probsTrue) { return(probsTrue.GetMeanLog()); }
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="SparseBernoulliFromBetaOp"]/message_doc[@name="ProbTrueAverageConditional(SparseBernoulliList, SparseBetaList, SparseBetaList)"]/*'/> public static SparseBetaList ProbTrueAverageConditional([SkipIfUniform] SparseBernoulliList sample, SparseBetaList probTrue, SparseBetaList result) { result.SetToFunction(sample, probTrue, (s, pt) => BernoulliFromBetaOp.ProbTrueAverageConditional(s, pt)); return(result); }
/// <summary> /// Evidence message for VMP /// </summary> /// <param name="sample">Incoming message from 'sample'. Must be a proper distribution. If any element is uniform, the result will be uniform.</param> /// <param name="probsTrue">Constant value for 'probsTrue'.</param> /// <param name="MeanLog">Buffer 'MeanLog'.</param> /// <param name="MeanLogOneMinus">Buffer 'MeanLogOneMinus'.</param> /// <returns>Average of the factor's log-value across the given argument distributions</returns> /// <remarks><para> /// The formula for the result is <c>sum_(sample) p(sample) log(factor(sample,probsTrue))</c>. /// Adding up these values across all factors and variables gives the log-evidence estimate for VMP. /// </para></remarks> /// <exception cref="ImproperMessageException"><paramref name="sample"/> is not a proper distribution</exception> public static double AverageLogFactor([Proper] SparseBernoulliListBase sample, SparseVector probsTrue, SparseVector MeanLog, SparseVector MeanLogOneMinus) { return(AverageLogFactor(sample, SparseBetaList.PointMass(probsTrue), MeanLog, MeanLogOneMinus)); }
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="SparseBernoulliFromBetaOp"]/message_doc[@name="SampleAverageLogarithm(SparseBetaList, SparseBernoulliList)"]/*'/> public static SparseBernoulliList SampleAverageLogarithm([SkipIfUniform] SparseBetaList probTrue, SparseBernoulliList result) { result.SetToFunction(probTrue, pt => BernoulliFromBetaOp.SampleAverageLogarithm(pt)); return(result); }
public void Initialize(bool skipStringDistributions = false) { // DO NOT make this a constructor, because it makes the test not notice complete lack of serialization as an empty object is set up exactly as the thing // you are trying to deserialize. this.pareto = new Pareto(1.2, 3.5); this.poisson = new Poisson(2.3); this.wishart = new Wishart(20, new PositiveDefiniteMatrix(new double[, ] { { 22, 21 }, { 21, 23 } })); this.vectorGaussian = new VectorGaussian(Vector.FromArray(13, 14), new PositiveDefiniteMatrix(new double[, ] { { 16, 15 }, { 15, 17 } })); this.unnormalizedDiscrete = UnnormalizedDiscrete.FromLogProbs(DenseVector.FromArray(5.1, 5.2, 5.3)); this.pointMass = PointMass <double> .Create(1.1); this.gaussian = new Gaussian(11.0, 12.0); this.nonconjugateGaussian = new NonconjugateGaussian(1.2, 2.3, 3.4, 4.5); this.gamma = new Gamma(9.0, 10.0); this.gammaPower = new GammaPower(5.6, 2.8, 3.4); this.discrete = new Discrete(6.0, 7.0, 8.0); this.conjugateDirichlet = new ConjugateDirichlet(1.2, 2.3, 3.4, 4.5); this.dirichlet = new Dirichlet(3.0, 4.0, 5.0); this.beta = new Beta(2.0, 1.0); this.binomial = new Binomial(5, 0.8); this.bernoulli = new Bernoulli(0.6); this.sparseBernoulliList = SparseBernoulliList.Constant(4, new Bernoulli(0.1)); this.sparseBernoulliList[1] = new Bernoulli(0.9); this.sparseBernoulliList[3] = new Bernoulli(0.7); this.sparseBetaList = SparseBetaList.Constant(5, new Beta(2.0, 2.0)); this.sparseBetaList[0] = new Beta(3.0, 4.0); this.sparseBetaList[1] = new Beta(5.0, 6.0); this.sparseGaussianList = SparseGaussianList.Constant(6, Gaussian.FromMeanAndPrecision(0.1, 0.2)); this.sparseGaussianList[4] = Gaussian.FromMeanAndPrecision(0.3, 0.4); this.sparseGaussianList[5] = Gaussian.FromMeanAndPrecision(0.5, 0.6); this.sparseGammaList = SparseGammaList.Constant(1, Gamma.FromShapeAndRate(1.0, 2.0)); this.truncatedGamma = new TruncatedGamma(1.2, 2.3, 3.4, 4.5); this.truncatedGaussian = new TruncatedGaussian(1.2, 3.4, 5.6, 7.8); this.wrappedGaussian = new WrappedGaussian(1.2, 2.3, 3.4); ga = Distribution <double> .Array(new[] { this.gaussian, this.gaussian }); vga = Distribution <Vector> .Array(new[] { this.vectorGaussian, this.vectorGaussian }); ga2D = Distribution <double> .Array(new[, ] { { this.gaussian, this.gaussian }, { this.gaussian, this.gaussian } }); vga2D = Distribution <Vector> .Array(new[, ] { { this.vectorGaussian, this.vectorGaussian }, { this.vectorGaussian, this.vectorGaussian } }); gaJ = Distribution <double> .Array(new[] { new[] { this.gaussian, this.gaussian }, new[] { this.gaussian, this.gaussian } }); vgaJ = Distribution <Vector> .Array(new[] { new[] { this.vectorGaussian, this.vectorGaussian }, new[] { this.vectorGaussian, this.vectorGaussian } }); var gp = new GaussianProcess(new ConstantFunction(0), new SquaredExponential(0)); var basis = Util.ArrayInit(2, i => Vector.FromArray(1.0 * i)); this.sparseGp = new SparseGP(new SparseGPFixed(gp, basis)); this.quantileEstimator = new QuantileEstimator(0.01); this.quantileEstimator.Add(5); this.outerQuantiles = OuterQuantiles.FromDistribution(3, this.quantileEstimator); this.innerQuantiles = InnerQuantiles.FromDistribution(3, this.outerQuantiles); if (!skipStringDistributions) { // String distributions can not be serialized by some formatters (namely BinaryFormatter) // That is fine because this combination is never used in practice this.stringDistribution1 = StringDistribution.String("aa") .Append(StringDistribution.OneOf("b", "ccc")).Append("dddd"); this.stringDistribution2 = new StringDistribution(); this.stringDistribution2.SetToProduct(StringDistribution.OneOf("a", "b"), StringDistribution.OneOf("b", "c")); } }
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="SparseBernoulliFromBetaOp"]/message_doc[@name="LogEvidenceRatio(ISparseList{bool}, SparseBetaList)"]/*'/> public static double LogEvidenceRatio(ISparseList <bool> sample, SparseBetaList probTrue) { Func <bool, Beta, double> f = BernoulliFromBetaOp.LogEvidenceRatio; return(f.Map(sample, probTrue).EnumerableSum(x => x)); }
public static double LogEvidenceRatio(BernoulliIntegerSubset sample, SparseBetaList probTrue) { return(0.0); }
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="SparseBernoulliFromBetaOp"]/message_doc[@name="ProbTrueAverageConditional(ISparseList{bool}, SparseBetaList)"]/*'/> public static SparseBetaList ProbTrueAverageConditional(ISparseList <bool> sample, SparseBetaList result) { result.SetToFunction(sample, s => BernoulliFromBetaOp.ProbTrueAverageConditional(s)); return(result); }
public void Initialize() { // DO NOT make this a constructor, because it makes the test not notice complete lack of serialization as an empty object is set up exactly as the thing // you are trying to deserialize. this.pareto = new Pareto(1.2, 3.5); this.poisson = new Poisson(2.3); this.wishart = new Wishart(20, new PositiveDefiniteMatrix(new double[, ] { { 22, 21 }, { 21, 23 } })); this.vectorGaussian = new VectorGaussian(Vector.FromArray(13, 14), new PositiveDefiniteMatrix(new double[, ] { { 16, 15 }, { 15, 17 } })); this.unnormalizedDiscrete = UnnormalizedDiscrete.FromLogProbs(DenseVector.FromArray(5.1, 5.2, 5.3)); this.pointMass = PointMass <double> .Create(1.1); this.gaussian = new Gaussian(11.0, 12.0); this.nonconjugateGaussian = new NonconjugateGaussian(1.2, 2.3, 3.4, 4.5); this.gamma = new Gamma(9.0, 10.0); this.gammaPower = new GammaPower(5.6, 2.8, 3.4); this.discrete = new Discrete(6.0, 7.0, 8.0); this.conjugateDirichlet = new ConjugateDirichlet(1.2, 2.3, 3.4, 4.5); this.dirichlet = new Dirichlet(3.0, 4.0, 5.0); this.beta = new Beta(2.0, 1.0); this.binomial = new Binomial(5, 0.8); this.bernoulli = new Bernoulli(0.6); this.sparseBernoulliList = SparseBernoulliList.Constant(4, new Bernoulli(0.1)); this.sparseBernoulliList[1] = new Bernoulli(0.9); this.sparseBernoulliList[3] = new Bernoulli(0.7); this.sparseBetaList = SparseBetaList.Constant(5, new Beta(2.0, 2.0)); this.sparseBetaList[0] = new Beta(3.0, 4.0); this.sparseBetaList[1] = new Beta(5.0, 6.0); this.sparseGaussianList = SparseGaussianList.Constant(6, Gaussian.FromMeanAndPrecision(0.1, 0.2)); this.sparseGaussianList[4] = Gaussian.FromMeanAndPrecision(0.3, 0.4); this.sparseGaussianList[5] = Gaussian.FromMeanAndPrecision(0.5, 0.6); this.sparseGammaList = SparseGammaList.Constant(1, Gamma.FromShapeAndRate(1.0, 2.0)); this.truncatedGamma = new TruncatedGamma(1.2, 2.3, 3.4, 4.5); this.truncatedGaussian = new TruncatedGaussian(1.2, 3.4, 5.6, 7.8); this.wrappedGaussian = new WrappedGaussian(1.2, 2.3, 3.4); ga = Distribution <double> .Array(new[] { this.gaussian, this.gaussian }); vga = Distribution <Vector> .Array(new[] { this.vectorGaussian, this.vectorGaussian }); ga2D = Distribution <double> .Array(new[, ] { { this.gaussian, this.gaussian }, { this.gaussian, this.gaussian } }); vga2D = Distribution <Vector> .Array(new[, ] { { this.vectorGaussian, this.vectorGaussian }, { this.vectorGaussian, this.vectorGaussian } }); gaJ = Distribution <double> .Array(new[] { new[] { this.gaussian, this.gaussian }, new[] { this.gaussian, this.gaussian } }); vgaJ = Distribution <Vector> .Array(new[] { new[] { this.vectorGaussian, this.vectorGaussian }, new[] { this.vectorGaussian, this.vectorGaussian } }); var gp = new GaussianProcess(new ConstantFunction(0), new SquaredExponential(0)); var basis = Util.ArrayInit(2, i => Vector.FromArray(1.0 * i)); this.sparseGp = new SparseGP(new SparseGPFixed(gp, basis)); this.quantileEstimator = new QuantileEstimator(0.01); this.quantileEstimator.Add(5); }