/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="SparseGaussianListOp"]/message_doc[@name="LogAverageFactor(SparseGaussianList, SparseGaussianList, SparseGammaList, SparseGammaList)"]/*'/>
public static double LogAverageFactor(
[SkipIfUniform] SparseGaussianList sample, [SkipIfUniform] SparseGaussianList mean, [SkipIfUniform] SparseGammaList precision, SparseGammaList to_precision)
{
Func <Gaussian, Gaussian, Gamma, Gamma, double> f = GaussianOp.LogAverageFactor;
return(f.Map(sample, mean, precision, to_precision).EnumerableSum(x => x));
}
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="SparseGaussianListOp"]/message_doc[@name="LogEvidenceRatio(SparseGaussianList, ISparseList{double}, SparseGammaList, SparseGaussianList, SparseGammaList)"]/*'/>
public static double LogEvidenceRatio(
[SkipIfUniform] SparseGaussianList sample, ISparseList <double> mean, [SkipIfUniform] SparseGammaList precision, [Fresh] SparseGaussianList to_sample, SparseGammaList to_precision)
{
Func <Gaussian, double, Gamma, Gaussian, Gamma, double> f = GaussianOp.LogEvidenceRatio;
return(f.Map(sample, mean, precision, to_sample, to_precision).EnumerableSum(x => x));
}
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;
}
}
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="SparseGaussianListOp"]/message_doc[@name="MeanAverageConditional(ISparseList{double}, SparseGaussianList, SparseGammaList, SparseGammaList, SparseGaussianList)"]/*'/>
public static SparseGaussianList MeanAverageConditional(
ISparseList <double> sample, [SkipIfUniform] SparseGaussianList mean, [SkipIfUniform] SparseGammaList precision, SparseGammaList to_precision, SparseGaussianList result)
{
result.SetToFunction(sample, mean, precision, to_precision, (s, m, p, tp) => GaussianOp.MeanAverageConditional(s, m, p, tp));
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"));
}
}
/// <summary>
/// VMP message to 'mean'
/// </summary>
/// <param name="sample">Constant value for 'sample'.</param>
/// <param name="precision">Incoming message from 'precision'. Must be a proper distribution. If uniform, the result will be uniform.</param>
/// <returns>The outgoing VMP message to the 'mean' argument</returns>
/// <remarks><para>
/// The outgoing message is the exponential of the average log-factor value, where the average is over all arguments except 'mean'.
/// The formula is <c>exp(sum_(precision) p(precision) log(factor(sample,mean,precision)))</c>.
/// </para></remarks>
/// <exception cref="ImproperMessageException"><paramref name="precision"/> is not a proper distribution</exception>
public static SparseGaussianList MeanAverageLogarithm(IList<double> sample, [Proper]SparseGammaList precision, SparseGaussianList result)
{
result.SetToFunction(sample, precision, (s, p) => GaussianOp.MeanAverageLogarithm(s, p));
return result;
}
/// <summary>
/// EP message to 'mean'
/// </summary>
/// <param name="sample">Constant value for 'sample'.</param>
/// <param name="precision">Constant value for 'precision'.</param>
/// <returns>The outgoing EP message to the 'mean' argument</returns>
/// <remarks><para>
/// The outgoing message is the factor viewed as a function of 'mean' conditioned on the given values.
/// </para></remarks>
public static SparseGaussianList MeanAverageConditional(IList<double> sample, IList<double> precision, SparseGaussianList result)
{
result.SetToFunction(sample, precision, (s, p) => GaussianOp.MeanAverageConditional(s, p));
return result;
}
/// <summary>
/// EP message to 'mean'
/// </summary>
/// <param name="sample">Constant value for 'sample'.</param>
/// <param name="mean">Incoming message from 'mean'. Must be a proper distribution. If uniform, the result will be uniform.</param>
/// <param name="precision">Incoming message from 'precision'. Must be a proper distribution. If uniform, the result will be uniform.</param>
/// <returns>The outgoing EP message to the 'mean' argument</returns>
/// <remarks><para>
/// The outgoing message is a distribution matching the moments of 'mean' as the random arguments are varied.
/// The formula is <c>proj[p(mean) sum_(precision) p(precision) factor(sample,mean,precision)]/p(mean)</c>.
/// </para></remarks>
/// <exception cref="ImproperMessageException"><paramref name="mean"/> is not a proper distribution</exception>
/// <exception cref="ImproperMessageException"><paramref name="precision"/> is not a proper distribution</exception>
public static SparseGaussianList MeanAverageConditional(IList<double> sample, [SkipIfUniform] SparseGaussianList mean, [SkipIfUniform] SparseGammaList precision, SparseGammaList to_precision, SparseGaussianList result)
{
result.SetToFunction(sample, mean, precision, to_precision, (s, m, p, tp) => GaussianOp.MeanAverageConditional(s, m, p, tp));
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);
}
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="SparseGaussianListOp"]/message_doc[@name="MeanAverageLogarithm(ISparseList{double}, ISparseList{double}, SparseGaussianList)"]/*'/>
public static SparseGaussianList MeanAverageLogarithm(ISparseList <double> sample, ISparseList <double> precision, SparseGaussianList result)
{
result.SetToFunction(sample, precision, (s, p) => GaussianOp.MeanAverageLogarithm(s, p));
return(result);
}
public static SparseGaussianList SampleAverageLogarithmInit([IgnoreDependency] SparseGaussianList mean)
{
return((SparseGaussianList)mean.Clone());
}
public static SparseGaussianList SampleAverageLogarithmInit([IgnoreDependency] ISparseList <double> mean)
{
return(SparseGaussianList.FromSize(mean.Count));
}
public static SparseGaussianList SampleAverageConditionalInit([IgnoreDependency] SparseGaussianList mean)
{
return((SparseGaussianList)mean.Clone());
}
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="SparseGaussianListOp"]/message_doc[@name="LogEvidenceRatio(ISparseList{double}, SparseGaussianList, ISparseList{double})"]/*'/>
public static double LogEvidenceRatio(ISparseList <double> sample, SparseGaussianList mean, ISparseList <double> precision)
{
Func <double, Gaussian, double, double> f = GaussianOp.LogEvidenceRatio;
return(f.Map(sample, mean, precision).EnumerableSum(x => x));
}
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="SparseGaussianListOp"]/message_doc[@name="PrecisionAverageConditional(ISparseList{double}, SparseGaussianList, SparseGammaList, SparseGammaList)"]/*'/>
public static SparseGammaList PrecisionAverageConditional(
ISparseList <double> sample, [SkipIfUniform] SparseGaussianList mean, [SkipIfUniform] SparseGammaList precision, SparseGammaList result)
{
result.SetToFunction(sample, mean, precision, (s, m, p) => GaussianOp.PrecisionAverageConditional_slow(Gaussian.PointMass(s), m, p));
return(result);
}
/// <summary>
/// EP message to 'sample'
/// </summary>
/// <param name="sample">Incoming message from 'sample'.</param>
/// <param name="mean">Constant value for 'mean'.</param>
/// <param name="precision">Incoming message from 'precision'. Must be a proper distribution. If uniform, the result will be uniform.</param>
/// <returns>The outgoing EP message to the 'sample' argument</returns>
/// <remarks><para>
/// The outgoing message is a distribution matching the moments of 'sample' as the random arguments are varied.
/// The formula is <c>proj[p(sample) sum_(precision) p(precision) factor(sample,mean,precision)]/p(sample)</c>.
/// </para></remarks>
/// <exception cref="ImproperMessageException"><paramref name="precision"/> is not a proper distribution</exception>
public static SparseGaussianList SampleAverageConditional(SparseGaussianList sample, IList<double> mean, [SkipIfUniform] SparseGammaList precision, SparseGaussianList result)
{
result.SetToFunction<Gaussian, double, Gamma>(sample, mean, precision, (s, m, p) => GaussianOp.SampleAverageConditional(s, m, p));
return result;
}
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="SparseGaussianListOp"]/message_doc[@name="MeanAverageLogarithm(SparseGaussianList, SparseGammaList, SparseGaussianList)"]/*'/>
public static SparseGaussianList MeanAverageLogarithm([Proper] SparseGaussianList sample, [Proper] SparseGammaList precision, SparseGaussianList result)
{
result.SetToFunction(sample, precision, (s, p) => GaussianOp.MeanAverageLogarithm(s, p));
return(result);
}
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="SparseGaussianListOp"]/message_doc[@name="SampleAverageLogarithm(ISparseList{double}, SparseGammaList, SparseGaussianList)"]/*'/>
public static SparseGaussianList SampleAverageLogarithm(ISparseList <double> mean, [Proper] SparseGammaList precision, SparseGaussianList result)
{
result.SetToFunction(mean, precision, (m, p) => GaussianOp.SampleAverageLogarithm(m, p));
return(result);
}
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="SparseGaussianListOp"]/message_doc[@name="PrecisionAverageLogarithm(ISparseList{double}, SparseGaussianList, SparseGammaList)"]/*'/>
public static SparseGammaList PrecisionAverageLogarithm(ISparseList <double> sample, [Proper] SparseGaussianList mean, SparseGammaList result)
{
result.SetToFunction(sample, mean, (s, m) => GaussianOp.PrecisionAverageLogarithm(s, m));
return(result);
}
/// <summary>
/// Evidence message for EP
/// </summary>
/// <param name="sample">Constant value for 'sample'.</param>
/// <param name="mean">Incoming message from 'mean'.</param>
/// <param name="precision">Constant value for 'precision'.</param>
/// <returns>Logarithm of the factor's contribution the EP model evidence</returns>
/// <remarks><para>
/// The formula for the result is <c>log(sum_(mean) p(mean) factor(sample,mean,precision))</c>.
/// Adding up these values across all factors and variables gives the log-evidence estimate for EP.
/// </para></remarks>
public static double LogEvidenceRatio(IList<double> sample, SparseGaussianList mean, IList<double> precision)
{
Func<double, Gaussian, double, double> f = GaussianOp.LogEvidenceRatio;
return f.Map(sample, mean, precision).EnumerableReduce(0.0, (res, elem) => res + elem, (res, elem, cnt) => res + elem * cnt);
}
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="SparseGaussianListOp"]/message_doc[@name="AverageLogFactor(SparseGaussianList, SparseGaussianList, ISparseList{double})"]/*'/>
public static double AverageLogFactor([Proper] SparseGaussianList sample, [Proper] SparseGaussianList mean, ISparseList <double> precision)
{
Func <Gaussian, Gaussian, double, double> f = GaussianOp.AverageLogFactor;
return(f.Map(sample, mean, precision).EnumerableSum(x => x));
}
/// <summary>
/// VMP message to 'sample'
/// </summary>
/// <param name="mean">Constant value for 'mean'.</param>
/// <param name="precision">Incoming message from 'precision'. Must be a proper distribution. If 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_(precision) p(precision) log(factor(sample,mean,precision)))</c>.
/// </para></remarks>
/// <exception cref="ImproperMessageException"><paramref name="precision"/> is not a proper distribution</exception>
public static SparseGaussianList SampleAverageLogarithm(IList<double> mean, [Proper] SparseGammaList precision, SparseGaussianList result)
{
result.SetToFunction(mean, precision, (m, p) => GaussianOp.SampleAverageLogarithm(m, p));
return result;
}
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="SparseGaussianListOp"]/message_doc[@name="SampleAverageConditional(SparseGaussianList, ISparseList{double}, SparseGaussianList)"]/*'/>
public static SparseGaussianList SampleAverageConditional([SkipIfUniform] SparseGaussianList mean, ISparseList <double> precision, SparseGaussianList result)
{
result.SetToFunction(mean, precision, (m, p) => GaussianOp.SampleAverageConditional(m, p));
return(result);
}
/// <summary>
/// EP message to 'sample'
/// </summary>
/// <param name="mean">Incoming message from 'mean'. Must be a proper distribution. If uniform, the result will be uniform.</param>
/// <param name="precision">Constant value for 'precision'.</param>
/// <returns>The outgoing EP message to the 'sample' argument</returns>
/// <remarks><para>
/// The outgoing message is a distribution matching the moments of 'sample' as the random arguments are varied.
/// The formula is <c>proj[p(sample) sum_(mean) p(mean) factor(sample,mean,precision)]/p(sample)</c>.
/// </para></remarks>
/// <exception cref="ImproperMessageException"><paramref name="mean"/> is not a proper distribution</exception>
public static SparseGaussianList SampleAverageConditional([SkipIfUniform] SparseGaussianList mean, IList<double> precision, SparseGaussianList result)
{
result.SetToFunction(mean, precision, (m, p) => GaussianOp.SampleAverageConditional(m, p));
return result;
}
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="SparseGaussianListOp"]/message_doc[@name="MeanAverageConditional(SparseGaussianList, ISparseList{double}, SparseGaussianList)"]/*'/>
public static SparseGaussianList MeanAverageConditional([SkipIfUniform] SparseGaussianList sample, ISparseList <double> precision, SparseGaussianList result)
{
result.SetToFunction(sample, precision, (s, p) => GaussianOp.MeanAverageConditional(s, p));
return(result);
}
public void SparseGaussianListFactor()
{
SparseGaussianList.DefaultTolerance = 1e-10;
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;
// True distribution for the means
var sparseMeanDist = SparseGaussianList.Constant(listSize, Gaussian.FromMeanAndPrecision(1, 2), tolerance);
sparseMeanDist[3] = Gaussian.FromMeanAndPrecision(4, 5);
sparseMeanDist[6] = Gaussian.FromMeanAndPrecision(7, 8);
var meanDist = sparseMeanDist.ToArray();
var sparseMeanPoint = SparseList <double> .Constant(listSize, 0.1);
sparseMeanPoint[3] = 0.7;
sparseMeanPoint[6] = 0.8;
var meanPoint = sparseMeanPoint.ToArray();
// True distribution for the precisions
var sparsePrecDist = SparseGammaList.Constant(listSize, Gamma.FromShapeAndRate(1.1, 1.2), tolerance);
sparsePrecDist[3] = Gamma.FromShapeAndRate(2.3, 2.4);
sparsePrecDist[6] = Gamma.FromShapeAndRate(3.4, 4.5);
var precDist = sparsePrecDist.ToArray();
var sparsePrecPoint = SparseList <double> .Constant(listSize, 0.1);
sparsePrecPoint[3] = 5.6;
sparsePrecPoint[6] = 0.5;
var precPoint = sparsePrecPoint.ToArray();
var sparseSampleDist = SparseGaussianList.Constant(listSize, Gaussian.FromMeanAndPrecision(0.5, 1.5), tolerance);
sparseSampleDist[3] = Gaussian.FromMeanAndPrecision(-0.5, 2.0);
sparseSampleDist[9] = Gaussian.FromMeanAndPrecision(1.6, 0.4);
var sampleDist = sparseSampleDist.ToArray();
var sparseSamplePoint = SparseList <double> .Constant(listSize, 0.5);
sparseSamplePoint[3] = 0.1;
sparseSamplePoint[9] = 2.3;
var samplePoint = sparseSamplePoint.ToArray();
var toSparseSampleDist = SparseGaussianList.Constant(listSize, Gaussian.FromMeanAndPrecision(-0.2, 0.3), tolerance);
toSparseSampleDist[3] = Gaussian.FromMeanAndPrecision(2.1, 3.2);
toSparseSampleDist[4] = Gaussian.FromMeanAndPrecision(1.3, 0.7);
var toSampleDist = toSparseSampleDist.ToArray();
var toSparsePrecDist = SparseGammaList.Constant(listSize, Gamma.FromShapeAndRate(2.3, 3.4), tolerance);
toSparsePrecDist[3] = Gamma.FromShapeAndRate(3.4, 4.5);
toSparsePrecDist[4] = Gamma.FromShapeAndRate(5.6, 6.7);
var toPrecDist = toSparsePrecDist.ToArray();
// ---------------------------
// Check average log factor
// ---------------------------
calcErrMsg = "Average log factor" + calcSuffix;
// Dist, dist, dist
var sparseAvgLog = SparseGaussianListOp.AverageLogFactor(sparseSampleDist, sparseMeanDist, sparsePrecDist);
var avgLog = Util.ArrayInit(listSize, i => GaussianOp.AverageLogFactor(sampleDist[i], meanDist[i], precDist[i])).Sum();
TAssert.True(System.Math.Abs(avgLog - sparseAvgLog) < tolerance, calcErrMsg);
// Dist, dist, point
sparseAvgLog = SparseGaussianListOp.AverageLogFactor(sparseSampleDist, sparseMeanDist, sparsePrecPoint);
avgLog = Util.ArrayInit(listSize, i => GaussianOp.AverageLogFactor(sampleDist[i], meanDist[i], precPoint[i])).Sum();
TAssert.True(System.Math.Abs(avgLog - sparseAvgLog) < tolerance, calcErrMsg);
// Dist, point, dist
sparseAvgLog = SparseGaussianListOp.AverageLogFactor(sparseSampleDist, sparseMeanPoint, sparsePrecDist);
avgLog = Util.ArrayInit(listSize, i => GaussianOp.AverageLogFactor(sampleDist[i], meanPoint[i], precDist[i])).Sum();
TAssert.True(System.Math.Abs(avgLog - sparseAvgLog) < tolerance, calcErrMsg);
// Dist, point, point
sparseAvgLog = SparseGaussianListOp.AverageLogFactor(sparseSampleDist, sparseMeanPoint, sparsePrecPoint);
avgLog = Util.ArrayInit(listSize, i => GaussianOp.AverageLogFactor(sampleDist[i], meanPoint[i], precPoint[i])).Sum();
TAssert.True(System.Math.Abs(avgLog - sparseAvgLog) < tolerance, calcErrMsg);
// Point, dist, dist
sparseAvgLog = SparseGaussianListOp.AverageLogFactor(sparseSamplePoint, sparseMeanDist, sparsePrecDist);
avgLog = Util.ArrayInit(listSize, i => GaussianOp.AverageLogFactor(samplePoint[i], meanDist[i], precDist[i])).Sum();
TAssert.True(System.Math.Abs(avgLog - sparseAvgLog) < tolerance, calcErrMsg);
// Point, dist, point
sparseAvgLog = SparseGaussianListOp.AverageLogFactor(sparseSamplePoint, sparseMeanDist, sparsePrecPoint);
avgLog = Util.ArrayInit(listSize, i => GaussianOp.AverageLogFactor(samplePoint[i], meanDist[i], precPoint[i])).Sum();
TAssert.True(System.Math.Abs(avgLog - sparseAvgLog) < tolerance, calcErrMsg);
// Point, point, dist
sparseAvgLog = SparseGaussianListOp.AverageLogFactor(sparseSamplePoint, sparseMeanPoint, sparsePrecDist);
avgLog = Util.ArrayInit(listSize, i => GaussianOp.AverageLogFactor(samplePoint[i], meanPoint[i], precDist[i])).Sum();
TAssert.True(System.Math.Abs(avgLog - sparseAvgLog) < tolerance, calcErrMsg);
// Point, point, point
sparseAvgLog = SparseGaussianListOp.AverageLogFactor(sparseSamplePoint, sparseMeanPoint, sparsePrecPoint);
avgLog = Util.ArrayInit(listSize, i => GaussianOp.AverageLogFactor(samplePoint[i], meanPoint[i], precPoint[i])).Sum();
TAssert.True(System.Math.Abs(avgLog - sparseAvgLog) < tolerance, calcErrMsg);
// ---------------------------
// Check log average factor
// ---------------------------
calcErrMsg = "Log average factor" + calcSuffix;
var sparseLogAvg = SparseGaussianListOp.LogAverageFactor(sparseSampleDist, sparseMeanDist, sparsePrecDist, toSparsePrecDist);
var logAvg = Util.ArrayInit(listSize, i => GaussianOp.LogAverageFactor(sampleDist[i], meanDist[i], precDist[i], toPrecDist[i])).Sum();
TAssert.True(System.Math.Abs(logAvg - sparseLogAvg) < tolerance, calcErrMsg);
// Dist, dist, point
sparseLogAvg = SparseGaussianListOp.LogAverageFactor(sparseSampleDist, sparseMeanDist, sparsePrecPoint);
logAvg = Util.ArrayInit(listSize, i => GaussianOp.LogAverageFactor(sampleDist[i], meanDist[i], precPoint[i])).Sum();
TAssert.True(System.Math.Abs(logAvg - sparseLogAvg) < tolerance, calcErrMsg);
// Dist, point, dist
sparseLogAvg = SparseGaussianListOp.LogAverageFactor(sparseSampleDist, sparseMeanPoint, sparsePrecDist, toSparsePrecDist);
logAvg = Util.ArrayInit(listSize, i => GaussianOp.LogAverageFactor(sampleDist[i], meanPoint[i], precDist[i], toPrecDist[i])).Sum();
TAssert.True(System.Math.Abs(logAvg - sparseLogAvg) < tolerance, calcErrMsg);
// Dist, point, point
sparseLogAvg = SparseGaussianListOp.LogAverageFactor(sparseSampleDist, sparseMeanPoint, sparsePrecPoint);
logAvg = Util.ArrayInit(listSize, i => GaussianOp.LogAverageFactor(sampleDist[i], meanPoint[i], precPoint[i])).Sum();
TAssert.True(System.Math.Abs(logAvg - sparseLogAvg) < tolerance, calcErrMsg);
// Point, dist, dist
sparseLogAvg = SparseGaussianListOp.LogAverageFactor(sparseSamplePoint, sparseMeanDist, sparsePrecDist, toSparsePrecDist);
logAvg = Util.ArrayInit(listSize, i => GaussianOp.LogAverageFactor(samplePoint[i], meanDist[i], precDist[i], toPrecDist[i])).Sum();
TAssert.True(System.Math.Abs(logAvg - sparseLogAvg) < tolerance, calcErrMsg);
// Point, dist, point
sparseLogAvg = SparseGaussianListOp.LogAverageFactor(sparseSamplePoint, sparseMeanDist, sparsePrecPoint);
logAvg = Util.ArrayInit(listSize, i => GaussianOp.LogAverageFactor(samplePoint[i], meanDist[i], precPoint[i])).Sum();
TAssert.True(System.Math.Abs(logAvg - sparseLogAvg) < tolerance, calcErrMsg);
// Point, point, dist
sparseLogAvg = SparseGaussianListOp.LogAverageFactor(sparseSamplePoint, sparseMeanPoint, sparsePrecDist);
logAvg = Util.ArrayInit(listSize, i => GaussianOp.LogAverageFactor(samplePoint[i], meanPoint[i], precDist[i])).Sum();
TAssert.True(System.Math.Abs(logAvg - sparseLogAvg) < tolerance, calcErrMsg);
// Point, point, point
sparseLogAvg = SparseGaussianListOp.LogAverageFactor(sparseSamplePoint, sparseMeanPoint, sparsePrecPoint);
logAvg = Util.ArrayInit(listSize, i => GaussianOp.LogAverageFactor(samplePoint[i], meanPoint[i], precPoint[i])).Sum();
TAssert.True(System.Math.Abs(logAvg - sparseLogAvg) < tolerance, calcErrMsg);
// ---------------------------
// Check log evidence ratio
// ---------------------------
calcErrMsg = "Log evidence ratio" + calcSuffix;
var sparseEvidRat = SparseGaussianListOp.LogEvidenceRatio(sparseSampleDist, sparseMeanDist, sparsePrecDist, toSparseSampleDist, toSparsePrecDist);
var evidRat = Util.ArrayInit(listSize, i => GaussianOp.LogEvidenceRatio(sampleDist[i], meanDist[i], precDist[i], toSampleDist[i], toPrecDist[i])).Sum();
TAssert.True(System.Math.Abs(evidRat - sparseEvidRat) < tolerance, calcErrMsg);
// Dist, dist, point
sparseEvidRat = SparseGaussianListOp.LogEvidenceRatio(sparseSampleDist, sparseMeanDist, sparsePrecPoint);
evidRat = Util.ArrayInit(listSize, i => GaussianOp.LogEvidenceRatio(sampleDist[i], meanDist[i], precPoint[i])).Sum();
TAssert.True(System.Math.Abs(evidRat - sparseEvidRat) < tolerance, calcErrMsg);
// Dist, point, dist
sparseEvidRat = SparseGaussianListOp.LogEvidenceRatio(sparseSampleDist, sparseMeanPoint, sparsePrecDist, toSparseSampleDist, toSparsePrecDist);
evidRat = Util.ArrayInit(listSize, i => GaussianOp.LogEvidenceRatio(sampleDist[i], meanPoint[i], precDist[i], toSampleDist[i], toPrecDist[i])).Sum();
TAssert.True(System.Math.Abs(evidRat - sparseEvidRat) < tolerance, calcErrMsg);
// Dist, point, point
sparseEvidRat = SparseGaussianListOp.LogEvidenceRatio(sparseSampleDist, sparseMeanPoint, sparsePrecPoint);
evidRat = Util.ArrayInit(listSize, i => GaussianOp.LogEvidenceRatio(sampleDist[i], meanPoint[i], precPoint[i])).Sum();
TAssert.True(System.Math.Abs(evidRat - sparseEvidRat) < tolerance, calcErrMsg);
// Point, dist, dist
sparseEvidRat = SparseGaussianListOp.LogEvidenceRatio(sparseSamplePoint, sparseMeanDist, sparsePrecDist, toSparsePrecDist);
evidRat = Util.ArrayInit(listSize, i => GaussianOp.LogEvidenceRatio(samplePoint[i], meanDist[i], precDist[i], toPrecDist[i])).Sum();
TAssert.True(System.Math.Abs(evidRat - sparseEvidRat) < tolerance, calcErrMsg);
// Point, dist, point
sparseEvidRat = SparseGaussianListOp.LogEvidenceRatio(sparseSamplePoint, sparseMeanDist, sparsePrecPoint);
evidRat = Util.ArrayInit(listSize, i => GaussianOp.LogEvidenceRatio(samplePoint[i], meanDist[i], precPoint[i])).Sum();
TAssert.True(System.Math.Abs(evidRat - sparseEvidRat) < tolerance, calcErrMsg);
// Point, point, dist
sparseEvidRat = SparseGaussianListOp.LogEvidenceRatio(sparseSamplePoint, sparseMeanPoint, sparsePrecDist);
evidRat = Util.ArrayInit(listSize, i => GaussianOp.LogEvidenceRatio(samplePoint[i], meanPoint[i], precDist[i])).Sum();
TAssert.True(System.Math.Abs(evidRat - sparseEvidRat) < tolerance, calcErrMsg);
// Point, point, point
sparseEvidRat = SparseGaussianListOp.LogEvidenceRatio(sparseSamplePoint, sparseMeanPoint, sparsePrecPoint);
evidRat = Util.ArrayInit(listSize, i => GaussianOp.LogEvidenceRatio(samplePoint[i], meanPoint[i], precPoint[i])).Sum();
TAssert.True(System.Math.Abs(evidRat - sparseEvidRat) < tolerance, calcErrMsg);
// ---------------------------
// Check SampleAverageConditional
// ---------------------------
calcErrMsg = "SampleAverageConditional" + calcSuffix;
sparsityErrMsg = "SampleAverageConditional" + sparsitySuffix;
// Use different common value to ensure this gets properly set
var sparseSampleAvgConditional = SparseGaussianList.Constant(listSize, Gaussian.FromMeanAndPrecision(0.5, 0.6), tolerance);
sparseSampleAvgConditional = SparseGaussianListOp.SampleAverageConditional(sparseSampleDist, sparseMeanDist, sparsePrecDist, toSparsePrecDist, sparseSampleAvgConditional);
var sampleAvgConditional = Util.ArrayInit(listSize, i => GaussianOp.SampleAverageConditional(sampleDist[i], meanDist[i], precDist[i], toPrecDist[i]));
TAssert.True(3 == sparseSampleAvgConditional.SparseCount, sparsityErrMsg);
TAssert.True(sparseSampleAvgConditional.MaxDiff(sampleAvgConditional) < tolerance, calcErrMsg);
sparseSampleAvgConditional = SparseGaussianList.Constant(listSize, Gaussian.FromMeanAndPrecision(0.5, 0.6), tolerance);
sparseSampleAvgConditional = SparseGaussianListOp.SampleAverageConditional(sparseSampleDist, sparseMeanPoint, sparsePrecDist, toSparsePrecDist, sparseSampleAvgConditional);
sampleAvgConditional = Util.ArrayInit(listSize, i => GaussianOp.SampleAverageConditional(sampleDist[i], meanPoint[i], precDist[i], toPrecDist[i]));
TAssert.True(3 == sparseSampleAvgConditional.SparseCount, sparsityErrMsg);
TAssert.True(sparseSampleAvgConditional.MaxDiff(sampleAvgConditional) < tolerance, calcErrMsg);
sparseSampleAvgConditional = SparseGaussianList.Constant(listSize, Gaussian.FromMeanAndPrecision(0.5, 0.6), tolerance);
sparseSampleAvgConditional = SparseGaussianListOp.SampleAverageConditional(sparseMeanDist, sparsePrecPoint, sparseSampleAvgConditional);
sampleAvgConditional = Util.ArrayInit(listSize, i => GaussianOp.SampleAverageConditional(meanDist[i], precPoint[i]));
TAssert.True(2 == sparseSampleAvgConditional.SparseCount, sparsityErrMsg);
TAssert.True(sparseSampleAvgConditional.MaxDiff(sampleAvgConditional) < tolerance, calcErrMsg);
sparseSampleAvgConditional = SparseGaussianList.Constant(listSize, Gaussian.FromMeanAndPrecision(0.5, 0.6), tolerance);
sparseSampleAvgConditional = SparseGaussianListOp.SampleAverageConditional(sparseMeanPoint, sparsePrecPoint, sparseSampleAvgConditional);
sampleAvgConditional = Util.ArrayInit(listSize, i => GaussianOp.SampleAverageConditional(meanPoint[i], precPoint[i]));
TAssert.True(2 == sparseSampleAvgConditional.SparseCount, sparsityErrMsg);
TAssert.True(sparseSampleAvgConditional.MaxDiff(sampleAvgConditional) < tolerance, calcErrMsg);
// ---------------------------
// Check MeanAverageConditional
// ---------------------------
calcErrMsg = "MeanAverageConditional" + calcSuffix;
sparsityErrMsg = "MeanAverageConditional" + sparsitySuffix;
// Use different common value to ensure this gets properly set
var sparseMeanAvgConditional = SparseGaussianList.Constant(listSize, Gaussian.FromMeanAndPrecision(0.5, 0.6), tolerance);
sparseMeanAvgConditional = SparseGaussianListOp.MeanAverageConditional(sparseSampleDist, sparseMeanDist, sparsePrecDist, toSparsePrecDist, sparseMeanAvgConditional);
var meanAvgConditional = Util.ArrayInit(listSize, i => GaussianOp.MeanAverageConditional(sampleDist[i], meanDist[i], precDist[i], toPrecDist[i]));
TAssert.True(3 == sparseMeanAvgConditional.SparseCount, sparsityErrMsg);
TAssert.True(sparseMeanAvgConditional.MaxDiff(meanAvgConditional) < tolerance, calcErrMsg);
sparseMeanAvgConditional = SparseGaussianList.Constant(listSize, Gaussian.FromMeanAndPrecision(0.5, 0.6), tolerance);
sparseMeanAvgConditional = SparseGaussianListOp.MeanAverageConditional(sparseSamplePoint, sparseMeanDist, sparsePrecDist, toSparsePrecDist, sparseMeanAvgConditional);
meanAvgConditional = Util.ArrayInit(listSize, i => GaussianOp.MeanAverageConditional(samplePoint[i], meanDist[i], precDist[i], toPrecDist[i]));
TAssert.True(3 == sparseMeanAvgConditional.SparseCount, sparsityErrMsg);
TAssert.True(sparseMeanAvgConditional.MaxDiff(meanAvgConditional) < tolerance, calcErrMsg);
sparseMeanAvgConditional = SparseGaussianList.Constant(listSize, Gaussian.FromMeanAndPrecision(0.5, 0.6), tolerance);
sparseMeanAvgConditional = SparseGaussianListOp.MeanAverageConditional(sparseSampleDist, sparsePrecPoint, sparseMeanAvgConditional);
meanAvgConditional = Util.ArrayInit(listSize, i => GaussianOp.MeanAverageConditional(sampleDist[i], precPoint[i]));
TAssert.True(3 == sparseMeanAvgConditional.SparseCount, sparsityErrMsg);
TAssert.True(sparseMeanAvgConditional.MaxDiff(meanAvgConditional) < tolerance, calcErrMsg);
sparseMeanAvgConditional = SparseGaussianList.Constant(listSize, Gaussian.FromMeanAndPrecision(0.5, 0.6), tolerance);
sparseMeanAvgConditional = SparseGaussianListOp.MeanAverageConditional(sparseSamplePoint, sparsePrecPoint, sparseMeanAvgConditional);
meanAvgConditional = Util.ArrayInit(listSize, i => GaussianOp.MeanAverageConditional(samplePoint[i], precPoint[i]));
TAssert.True(3 == sparseMeanAvgConditional.SparseCount, sparsityErrMsg);
TAssert.True(sparseMeanAvgConditional.MaxDiff(meanAvgConditional) < tolerance, calcErrMsg);
// ---------------------------
// Check PrecisionAverageConditional
// ---------------------------
calcErrMsg = "PrecisionAverageConditional" + calcSuffix;
sparsityErrMsg = "PrecisionAverageConditional" + sparsitySuffix;
// Use different common value to ensure this gets properly set
var sparsePrecAvgConditional = SparseGammaList.Constant(listSize, Gamma.FromShapeAndRate(2.1, 3.2), tolerance);
sparsePrecAvgConditional = SparseGaussianListOp.PrecisionAverageConditional(sparseSampleDist, sparseMeanDist, sparsePrecDist, sparsePrecAvgConditional);
var precAvgConditional = Util.ArrayInit(listSize, i => GaussianOp.PrecisionAverageConditional(sampleDist[i], meanDist[i], precDist[i]));
TAssert.True(3 == sparsePrecAvgConditional.SparseCount, sparsityErrMsg);
TAssert.True(sparsePrecAvgConditional.MaxDiff(precAvgConditional) < tolerance, calcErrMsg);
sparsePrecAvgConditional = SparseGammaList.Constant(listSize, Gamma.FromShapeAndRate(2.1, 3.2), tolerance);
sparsePrecAvgConditional = SparseGaussianListOp.PrecisionAverageConditional(sparseSamplePoint, sparseMeanDist, sparsePrecDist, sparsePrecAvgConditional);
precAvgConditional = Util.ArrayInit(listSize, i => GaussianOp.PrecisionAverageConditional(Gaussian.PointMass(samplePoint[i]), meanDist[i], precDist[i]));
TAssert.True(3 == sparsePrecAvgConditional.SparseCount, sparsityErrMsg);
TAssert.True(sparsePrecAvgConditional.MaxDiff(precAvgConditional) < tolerance, calcErrMsg);
sparsePrecAvgConditional = SparseGammaList.Constant(listSize, Gamma.FromShapeAndRate(2.1, 3.2), tolerance);
sparsePrecAvgConditional = SparseGaussianListOp.PrecisionAverageConditional(sparseSampleDist, sparseMeanPoint, sparsePrecDist, sparsePrecAvgConditional);
precAvgConditional = Util.ArrayInit(listSize, i => GaussianOp.PrecisionAverageConditional(sampleDist[i], Gaussian.PointMass(meanPoint[i]), precDist[i]));
TAssert.True(3 == sparsePrecAvgConditional.SparseCount, sparsityErrMsg);
TAssert.True(sparsePrecAvgConditional.MaxDiff(precAvgConditional) < tolerance, calcErrMsg);
sparsePrecAvgConditional = SparseGammaList.Constant(listSize, Gamma.FromShapeAndRate(2.1, 3.2), tolerance);
sparsePrecAvgConditional = SparseGaussianListOp.PrecisionAverageConditional(sparseSamplePoint, sparseMeanPoint, sparsePrecAvgConditional);
precAvgConditional = Util.ArrayInit(listSize, i => GaussianOp.PrecisionAverageConditional(samplePoint[i], meanPoint[i]));
TAssert.True(3 == sparsePrecAvgConditional.SparseCount, sparsityErrMsg);
TAssert.True(sparsePrecAvgConditional.MaxDiff(precAvgConditional) < tolerance, calcErrMsg);
}
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="SparseGaussianListOp"]/message_doc[@name="LogAverageFactor(ISparseList{double}, SparseGaussianList, ISparseList{double})"]/*'/>
public static double LogAverageFactor(ISparseList <double> sample, [SkipIfUniform] SparseGaussianList mean, ISparseList <double> precision)
{
Func <double, Gaussian, double, double> f = GaussianOp.LogAverageFactor;
return(f.Map(sample, mean, precision).EnumerableSum(x => x));
}
