/// <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); }
/// <summary> /// The expected logarithm of that distribution under this distribution. /// </summary> /// <param name="that">The distribution to take the logarithm of.</param> /// <returns><c>sum_x this.Evaluate(x)*Math.Log(that.Evaluate(x))</c></returns> /// <remarks>This is also known as the cross entropy.</remarks> public double GetAverageLog(BernoulliIntegerSubset that) { var res = SparseVector.Zero(LogOddsVector.Count); var res2 = SparseVector.Zero(LogOddsVector.Count); res.SetToFunction(LogOddsVector, that.GetLogProbTrueVector(), (logpr, logProbTrue) => double.IsNegativeInfinity(logpr) ?0 :MMath.Logistic(logpr) * logProbTrue); res2.SetToFunction(LogOddsVector, that.GetLogProbFalseVector(), (logpr, logProbFalse) => double.IsPositiveInfinity(logpr) ?0 :MMath.Logistic(-logpr) * logProbFalse); return(res.Sum() + res2.Sum()); }
/// <summary> /// Sets this BernoulliIntegerSubset distribution to the weighted sum of two other such distributions /// </summary> /// <param name="weight1"></param> /// <param name="value1"></param> /// <param name="weight2"></param> /// <param name="value2"></param> /// <remarks>Not yet implemented</remarks> public void SetToSum(double weight1, BernoulliIntegerSubset value1, double weight2, BernoulliIntegerSubset value2) { if (weight1 + weight2 == 0) { SetToUniform(); } else { LogOddsVector.SetToFunction(value1.GetProbTrueVector(), value2.GetProbTrueVector(), (x, y) => MMath.Logit((weight1 * x + weight2 * y) / (weight1 + weight2))); } }
public void BernoulliIntegerSubsetArithmetic() { double tolerance = 1e-10; var commonValue1 = new Bernoulli(0.1); var commonValue2 = new Bernoulli(0.2); var specialValue1 = new Bernoulli(0.7); var specialValue2 = new Bernoulli(0.8); var specialValue3 = new Bernoulli(0.9); var listSize = 100; var sparseBernoulliList1 = SparseBernoulliList.Constant(listSize, commonValue1); var sparseBernoulliList2 = SparseBernoulliList.Constant(listSize, commonValue2); sparseBernoulliList1[20] = specialValue1; sparseBernoulliList1[55] = specialValue2; sparseBernoulliList2[25] = specialValue2; sparseBernoulliList2[55] = specialValue3; var bernoulliIntegerSubset1 = BernoulliIntegerSubset.FromSparseList(sparseBernoulliList1); var bernoulliIntegerSubset2 = BernoulliIntegerSubset.FromSparseList(sparseBernoulliList2); // Product var product = bernoulliIntegerSubset1 * bernoulliIntegerSubset2; Assert.Equal(3, product.SparseBernoulliList.SparseValues.Count); Assert.Equal(commonValue1 * commonValue2, product.SparseBernoulliList.CommonValue); Assert.Equal(specialValue1 * commonValue2, product.SparseBernoulliList[20]); Assert.Equal(commonValue1 * specialValue2, product.SparseBernoulliList[25]); Assert.Equal(specialValue2 * specialValue3, product.SparseBernoulliList[55]); // Ratio var ratio = bernoulliIntegerSubset1 / bernoulliIntegerSubset2; Assert.Equal(2, ratio.SparseBernoulliList.SparseValues.Count); Assert.Equal((commonValue1 / commonValue2).GetProbTrue(), ratio.SparseBernoulliList.CommonValue.GetProbTrue(), tolerance); Assert.Equal((specialValue1 / commonValue2).GetProbTrue(), ratio.SparseBernoulliList[20].GetProbTrue(), tolerance); Assert.Equal((commonValue1 / specialValue2).GetProbTrue(), ratio.SparseBernoulliList[25].GetProbTrue(), tolerance); Assert.Equal((specialValue2 / specialValue3).GetProbTrue(), ratio.SparseBernoulliList[55].GetProbTrue(), tolerance); // Power var exponent = 1.2; var power = bernoulliIntegerSubset1 ^ exponent; Assert.Equal(2, power.SparseBernoulliList.SparseValues.Count); Assert.Equal(commonValue1 ^ exponent, power.SparseBernoulliList.CommonValue); Assert.Equal(specialValue1 ^ exponent, power.SparseBernoulliList[20]); Assert.Equal(specialValue2 ^ exponent, power.SparseBernoulliList[55]); }
/// <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); }
/// <summary>VMP message to <c>sample</c>.</summary> /// <param name="probTrue">Constant value for <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 the factor viewed as a function of <c>sample</c> conditioned on the given values.</para> /// </remarks> public static BernoulliIntegerSubset SampleAverageLogarithm(ISparseList <double> probTrue, BernoulliIntegerSubset result) { Func <double, Bernoulli> f = BernoulliFromBetaOp.SampleAverageLogarithm; result.SetTo(f.Map(probTrue)); return(result); }
/// <summary>Evidence message for VMP.</summary> /// <param name="sample">Incoming message from <c>sample</c>.</param> /// <param name="probTrue">Constant value for <c>probTrue</c>.</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,probTrue))</c>. Adding up these values across all factors and variables gives the log-evidence estimate for VMP.</para> /// </remarks> public static double AverageLogFactor(BernoulliIntegerSubset sample, ISparseList <double> probTrue) { Func <Bernoulli, double, double> f = BernoulliFromBetaOp.AverageLogFactor; return(f.Map(sample.SparseBernoulliList, probTrue).EnumerableSum(x => x)); }
/// <summary>VMP message to <c>set</c>.</summary> /// <param name="i">Constant value for <c>i</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>set</c> conditioned on the given values.</para> /// </remarks> public static BernoulliIntegerSubset SetAverageLogarithm(int i, BernoulliIntegerSubset result) { result.SetToUniform(); result.SparseBernoulliList[i] = Bernoulli.PointMass(true); return(result); }
/// <summary>Gibbs message to <c>sample</c>.</summary> /// <param name="probTrue">Constant value for <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 the factor viewed as a function of <c>sample</c> conditioned on the given values.</para> /// </remarks> public static BernoulliIntegerSubset SampleConditional(ISparseList <double> probTrue, BernoulliIntegerSubset result) { Func <double, Bernoulli> f = BernoulliFromBetaOp.SampleConditional; result.SetTo(f.Map(probTrue)); return(result); }
/// <summary>Evidence message for EP.</summary> /// <param name="sample">Incoming message from <c>sample</c>.</param> /// <param name="to_sample">Outgoing message to <c>sample</c>.</param> /// <returns>Logarithm of the factor's average value across the given argument distributions.</returns> /// <remarks> /// <para>The formula for the result is <c>log(sum_(sample) p(sample) factor(sample,probTrue))</c>.</para> /// </remarks> public static double LogAverageFactor(BernoulliIntegerSubset sample, [Fresh] BernoulliIntegerSubset to_sample) { Func <Bernoulli, Bernoulli, double> f = BernoulliFromBetaOp.LogAverageFactor; return(f.Map(sample.SparseBernoulliList, to_sample.SparseBernoulliList).EnumerableSum(x => x)); }
/// <summary> /// VMP message to 'probsTrue' /// </summary> /// <param name="sample">Incoming message from 'sample'. Must be a proper distribution. If any element is uniform, the result will be uniform.</param> /// <returns>The outgoing VMP message to the 'probsTrue' argument</returns> /// <remarks><para> /// The outgoing message is the exponential of the average log-factor value, where the average is over all arguments except 'probsTrue'. /// The formula is <c>exp(sum_(sample) p(sample) log(factor(sample,probsTrue)))</c>. /// </para></remarks> /// <exception cref="ImproperMessageException"><paramref name="sample"/> is not a proper distribution</exception> public static SparseBetaList ProbsTrueAverageLogarithm([Proper] BernoulliIntegerSubset sample) { return(SparseBernoulliFromBetaOp.ProbsTrueAverageLogarithm(sample)); }
/// <summary> /// Sets this BernoulliIntegerSubset distribution to the power another such distribution /// </summary> /// <param name="value"></param> /// <param name="exponent"></param> public void SetToPower(BernoulliIntegerSubset value, double exponent) { throw new NotImplementedException(); }
/// <summary> /// Sets this BernoulliIntegerSubset distribution to the ratio of two other such distributions /// </summary> /// <param name="numerator"></param> /// <param name="denominator"></param> public void SetToRatio(BernoulliIntegerSubset numerator, BernoulliIntegerSubset denominator) { LogOddsVector.SetToDifference(numerator.LogOddsVector, denominator.LogOddsVector); }
/// <summary> /// Sets this BernoulliIntegerSubset distribution to another such distribution /// </summary> /// <param name="value"></param> public void SetTo(BernoulliIntegerSubset value) { LogOddsVector.SetTo(value.LogOddsVector); }
/// <summary> /// Sets this BernoulliIntegerSubset distribution to a product of two other such distributions /// </summary> /// <param name="a"></param> /// <param name="b"></param> public void SetToProduct(BernoulliIntegerSubset a, BernoulliIntegerSubset b) { LogOddsVector.SetToSum(a.LogOddsVector, b.LogOddsVector); }
/// <summary> /// Clones this object. /// </summary> /// <returns></returns> public object Clone() { BernoulliIntegerSubset clone = new BernoulliIntegerSubset((SparseVector)LogOddsVector.Clone()); return(clone); }
/// <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); }
public static double LogEvidenceRatio(BernoulliIntegerSubset sample, ISparseList <double> probTrue) { return(0.0); }
/// <summary>VMP message to <c>probTrue</c>.</summary> /// <param name="sample">Incoming message from <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 exponential of the average log-factor value, where the average is over all arguments except <c>probTrue</c>. The formula is <c>exp(sum_(sample) p(sample) log(factor(sample,probTrue)))</c>.</para> /// </remarks> public static SparseBetaList ProbTrueAverageLogarithm(BernoulliIntegerSubset sample, SparseBetaList result) { result.SetToFunction(sample.SparseBernoulliList, s => BernoulliFromBetaOp.ProbTrueAverageLogarithm(s)); 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 'probsTrue'.</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, SparseVector probsTrue, SparseVector MeanLog, SparseVector MeanLogOneMinus) { return(SparseBernoulliFromBetaOp.AverageLogFactor(sample, probsTrue, MeanLog, MeanLogOneMinus)); }
/// <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 average value across the given argument distributions.</returns> /// <remarks> /// <para>The formula for the result is <c>log(sum_(probTrue) p(probTrue) factor(sample,probTrue))</c>.</para> /// </remarks> public static double LogAverageFactor(IList <int> sample, SparseBetaList probTrue) { Func <bool, Beta, double> f = BernoulliFromBetaOp.LogAverageFactor; return(f.Map(BernoulliIntegerSubset.SubsetToList(sample, probTrue.Count), probTrue).EnumerableSum(x => x)); }
/// <summary> /// Gets the log of the integral of the product of this BernoulliIntegerSubset distribution and another such distribution /// </summary> /// <param name="that"></param> /// <returns></returns> /// <remarks>Not yet implemented</remarks> public double GetLogAverageOf(BernoulliIntegerSubset that) { throw new NotImplementedException(); }
/// <summary>Evidence message for EP.</summary> /// <param name="sample">Constant value for <c>sample</c>.</param> /// <param name="probTrue">Constant value for <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(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, ISparseList <double> probTrue) { Func <bool, double, double> f = BernoulliFromBetaOp.LogEvidenceRatio; return(f.Map(BernoulliIntegerSubset.SubsetToList(sample, probTrue.Count), probTrue).EnumerableSum(x => x)); }
/// <summary> /// VMP message to 'set' /// </summary> /// <param name="i">Constant value for 'i'.</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 'set' conditioned on the given values. /// </para></remarks> public static BernoulliIntegerSubset SetAverageLogarithm(int i, BernoulliIntegerSubset result) { result.SetToUniform(); result.LogOddsVector[i] = double.PositiveInfinity; return(result); }