/// <summary>
/// Sets the uninformed priors.
/// </summary>
public void SetUninformedPriors()
{
ProbInitPrior.ObservedValue = Dirichlet.Uniform(K.SizeAsInt);
CPTTransPrior.ObservedValue = Util.ArrayInit(K.SizeAsInt, k => Dirichlet.Uniform(K.SizeAsInt)).ToArray();
EmitMeanPrior.ObservedValue = Util.ArrayInit(K.SizeAsInt, k => Gaussian.FromMeanAndVariance(1000, 1000000000)).ToArray();
EmitPrecPrior.ObservedValue = Util.ArrayInit(K.SizeAsInt, k => Gamma.FromMeanAndVariance(0.1, 100)).ToArray();
}
public void GaussianOpMean()
{
Gaussian result = new Gaussian();
Gaussian X0 = Gaussian.FromMeanAndVariance(7, 1.0 / 3);
Gaussian Mean0 = Gaussian.FromMeanAndVariance(3, 0.5);
Gamma Precision0 = Gamma.FromShapeAndScale(3, 3);
// Unknown precision
Gamma Precision = Gamma.FromShapeAndScale(3, 3);
Gaussian X = X0;
Gaussian Mean = Mean0;
// in matlab: test_t_msg
result = GaussianOp.MeanAverageConditional_slow(X, Mean, Precision);
Console.WriteLine(result);
Assert.True(GaussianOp.MeanAverageConditional_slow(X, Mean, Precision).MaxDiff(new Gaussian(-9.9121, -4.5998)) < 1e-0);
X = Gaussian.FromMeanAndVariance(1, 2);
Mean = Gaussian.PointMass(0);
Precision = Gamma.FromShapeAndRate(3, 1);
Gaussian xPostExpected = Gaussian.FromMeanAndVariance(0.178378819440295, 0.365796599498963);
Console.WriteLine(GaussianOp.SampleAverageConditional_slow(X, Mean, Precision) * X);
Assert.True(GaussianOp.SampleAverageConditional_slow(X, Mean, Precision).MaxDiff(xPostExpected / X) < 5e-7);
Console.WriteLine(GaussianOp_Slow.SampleAverageConditional(X, Mean, Precision) * X);
Assert.True(GaussianOp_Slow.SampleAverageConditional(X, Mean, Precision).MaxDiff(xPostExpected / X) < 5e-7);
}
private void GaussianProductOp_APointMass(double aMean, Gaussian Product, Gaussian B)
{
bool isProper = Product.IsProper();
Gaussian A = Gaussian.PointMass(aMean);
Gaussian result = GaussianProductOp.AAverageConditional(Product, A, B);
Console.WriteLine("{0}: {1}", A, result);
Gaussian result2 = isProper ? GaussianProductOp_Slow.AAverageConditional(Product, A, B) : result;
Console.WriteLine("{0}: {1}", A, result2);
Assert.True(result.MaxDiff(result2) < 1e-6);
var Amsg = InnerProductOp_PointB.BAverageConditional(Product, DenseVector.FromArray(B.GetMean()), new PositiveDefiniteMatrix(new double[, ] {
{ B.GetVariance() }
}), VectorGaussian.PointMass(aMean), VectorGaussian.Uniform(1));
//Console.WriteLine("{0}: {1}", A, Amsg);
Assert.True(result.MaxDiff(Amsg.GetMarginal(0)) < 1e-6);
double prevDiff = double.PositiveInfinity;
for (int i = 3; i < 40; i++)
{
double v = System.Math.Pow(0.1, i);
A = Gaussian.FromMeanAndVariance(aMean, v);
result2 = isProper ? GaussianProductOp.AAverageConditional(Product, A, B) : result;
double diff = result.MaxDiff(result2);
Console.WriteLine("{0}: {1} diff={2}", A, result2, diff.ToString("g4"));
//Assert.True(diff <= prevDiff || diff < 1e-6);
result2 = isProper ? GaussianProductOp_Slow.AAverageConditional(Product, A, B) : result;
diff = result.MaxDiff(result2);
Console.WriteLine("{0}: {1} diff={2}", A, result2, diff.ToString("g4"));
Assert.True(diff <= prevDiff || diff < 1e-6);
prevDiff = diff;
}
}
/// <summary>
/// Priors from posteriors with possible missing features (e.g. for community training).
/// </summary>
/// <param name="posteriors">The posteriors.</param>
/// <param name="featureSet">The feature set.</param>
/// <param name="point">The point.</param>
/// <param name="thresholdAndNoiseVariance">The threshold and noise variance.</param>
/// <param name="userNames">The user names.</param>
/// <returns>The <see cref="CommunityPriors" />.</returns>
internal static CommunityPriors FromPosteriors(
CommunityPosteriors posteriors,
FeatureSet featureSet,
double point,
double thresholdAndNoiseVariance,
IList <string> userNames)
{
return(new CommunityPriors
{
WeightMeans =
featureSet.FeatureBuckets.ToDictionary(
ia => ia,
ia =>
posteriors.WeightMeans.ContainsKey(ia)
? posteriors.WeightMeans[ia]
: Gaussian.FromMeanAndVariance(0.0, 1.0)),
WeightPrecisions =
featureSet.FeatureBuckets.ToDictionary(
ia => ia,
ia =>
posteriors.WeightPrecisions.ContainsKey(ia)
? posteriors.WeightPrecisions[ia]
: Gamma.PointMass(point)),
Thresholds =
userNames.ToDictionary(
ia => ia,
ia =>
posteriors.Thresholds != null && posteriors.Thresholds.ContainsKey(ia)
? posteriors.Thresholds[ia]
: Gaussian.FromMeanAndVariance(0.0, thresholdAndNoiseVariance)),
NoiseVariance = thresholdAndNoiseVariance,
});
}
public static Gaussian SumExceptAverageConditional([SkipIfAllUniform] IReadOnlyList <Gaussian> array, int index)
{
if (array.Count == 2)
{
return(array[1 - index]);
}
double mean = 0;
double variance = 0;
for (int i = 0; i < array.Count; i++)
{
if (i == index)
{
continue;
}
if (array[i].Precision == 0)
{
return(array[i]);
}
double mean1;
double variance1;
array[i].GetMeanAndVariance(out mean1, out variance1);
mean += mean1;
variance += variance1;
}
return(Gaussian.FromMeanAndVariance(mean, variance));
}
private void ExpModel()
{
double a = Factor.Random(Gaussian.FromMeanAndVariance(1.0, 2.0));
double c = System.Math.Exp(a);
InferNet.Infer(c, nameof(c));
}
private void GaussianOpX2(Gaussian mean, Gamma precision)
{
Gaussian sample, result, result2;
sample = Gaussian.PointMass(2);
result = GaussianOp.SampleAverageConditional_slow(sample, mean, precision);
result2 = GaussianOp_Slow.SampleAverageConditional(sample, mean, precision);
Console.WriteLine("{0}: {1} {2}", sample, result, result2);
Assert.True(result.MaxDiff(result2) < 1e-8);
double prevDiff = double.PositiveInfinity;
for (int i = 8; i < 30; i++)
{
double v = System.Math.Pow(0.1, i);
sample = Gaussian.FromMeanAndVariance(2, v);
result2 = GaussianOp_Slow.SampleAverageConditional(sample, mean, precision);
double diff = result.MaxDiff(result2);
Console.WriteLine("{0}: {1} diff={2}", sample, result2, diff.ToString("g4"));
Assert.True(diff <= prevDiff || diff < 1e-6);
result2 = GaussianOp.SampleAverageConditional_slow(sample, mean, precision);
diff = result.MaxDiff(result2);
Console.WriteLine("{0}: {1} diff={2}", sample, result2, diff.ToString("g4"));
Assert.True(diff <= prevDiff || diff < 1e-6);
prevDiff = diff;
}
}
public void MissingDataGaussianTest()
{
Variable <double> mean = Variable.GaussianFromMeanAndVariance(0, 100).Named("mean");
Variable <double> precision = Variable.GammaFromShapeAndScale(1, 1).Named("precision");
Variable <int> n = Variable.New <int>().Named("n");
Range i = new Range(n).Named("i");
VariableArray <double> x = Variable.Array <double>(i).Named("x");
using (Variable.ForEach(i))
{
using (Variable.If(x[i] > 0))
{
x[i] = Variable.GaussianFromMeanAndPrecision(mean, precision);
}
}
x.ObservedValue = new double[] { -1, 5.0, -1, 7.0, -1 };
n.ObservedValue = x.ObservedValue.Length;
InferenceEngine engine = new InferenceEngine(new VariationalMessagePassing());
//Console.WriteLine(engine.Infer(isMissing));
Gaussian meanExpected = Gaussian.FromMeanAndVariance(5.9603207170807826, 0.66132138200164436);
Gamma precisionExpected = Gamma.FromShapeAndRate(2, 2.6628958274937107);
Gaussian meanActual = engine.Infer <Gaussian>(mean);
Gamma precisionActual = engine.Infer <Gamma>(precision);
Console.WriteLine("mean = {0} should be {1}", meanActual, meanExpected);
Console.WriteLine("precision = {0} should be {1}", precisionActual, precisionExpected);
Assert.True(meanExpected.MaxDiff(meanActual) < 1e-10);
Assert.True(precisionExpected.MaxDiff(precisionActual) < 1e-10);
}
private void GaussianModel()
{
double m = Factor.Random(Gaussian.FromMeanAndVariance(1.0, 2.0));
double p = Factor.Random(Gamma.FromMeanAndVariance(2.0, 1.0));
double c = Factor.Gaussian(m, p);
InferNet.Infer(c, nameof(c));
}
public static Gaussian GPPrediction(Vector x, Vector[] xData, Gaussian[] y, KernelFunction kf, PositiveDefiniteMatrix spec)
{
var KxD = Vector.FromArray(xData.Select(o => kf.EvaluateX1X2(x, o)).ToArray());
double mean = spec.QuadraticForm(KxD, Vector.FromArray(y.Select(o => o.GetMean()).ToArray()));
double variance = kf.EvaluateX1X2(x, x) - spec.QuadraticForm(KxD);
return(Gaussian.FromMeanAndVariance(mean, variance));
}
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="ProductGaussianBetaVmpOp"]/message_doc[@name="ProductAverageLogarithm(Gaussian, Beta)"]/*'/>
public static Gaussian ProductAverageLogarithm([SkipIfUniform] Gaussian A, [SkipIfUniform] Beta B)
{
double ma = A.GetMean(), mb = B.GetMean();
double va = A.GetVariance(), vb = B.GetVariance();
Gaussian result = Gaussian.FromMeanAndVariance(ma * mb, va * vb + va * mb * mb + vb * ma * ma);
return(result);
}
public static ArrayType ArrayAverageConditional <ArrayType>([SkipIfUniform] Gaussian sumExcept, IReadOnlyList <Gaussian> array, int index, ArrayType result)
where ArrayType : IList <Gaussian>
{
if (sumExcept.Precision == 0 || array.Count <= 2)
{
for (int i = 0; i < result.Count; i++)
{
if (i == index)
{
result[i] = Gaussian.Uniform();
}
else
{
result[i] = sumExcept;
}
}
return(result);
}
sumExcept.GetMeanAndVarianceImproper(out double sumMean, out double sumVariance);
double[] means = new double[array.Count];
double[] variances = new double[array.Count];
for (int i = 0; i < array.Count; i++)
{
// could generalize this to be predicate(i)
if (i == index)
{
continue;
}
array[i].GetMeanAndVarianceImproper(out double mean1, out double variance1);
means[i] = mean1;
variances[i] = variance1;
}
double[] meanPrevious = new double[array.Count];
double[] variancePrevious = new double[array.Count];
for (int i = 1; i < array.Count; i++)
{
// i == index doesn't matter since it will have mean=0, variance=0
meanPrevious[i] = meanPrevious[i - 1] + means[i - 1];
variancePrevious[i] = variancePrevious[i - 1] + variances[i - 1];
}
double meanNext = 0;
double varianceNext = 0;
for (int i = array.Count - 1; i >= 0; i--)
{
if (i == index)
{
result[i] = Gaussian.Uniform();
continue;
}
double sumOtherMeans = meanPrevious[i] + meanNext;
double sumOtherVariances = variancePrevious[i] + varianceNext;
result[i] = Gaussian.FromMeanAndVariance(sumMean - sumOtherMeans, sumVariance + sumOtherVariances);
meanNext += means[i];
varianceNext += variances[i];
}
return(result);
}
/// <summary>
/// Generate priors from the weight and threshold variance.
/// </summary>
/// <param name="featureBuckets">The feature buckets.</param>
/// <param name="weightVariance">The weight variance.</param>
/// <param name="thresholdVariance">The threshold variance.</param>
/// <returns>
/// The <see cref="Priors" />
/// </returns>
internal static Priors Generate(ICollection <FeatureBucket> featureBuckets, double weightVariance, double thresholdVariance)
{
return(new Priors
{
Weights = featureBuckets.ToDictionary(ia => ia, ia => Gaussian.FromMeanAndVariance(0.0, weightVariance)),
Threshold = Gaussian.FromMeanAndVariance(0.0, thresholdVariance),
NoiseVariance = thresholdVariance
});
}
/// <summary>
/// Find the Laplace approximation for Beta(Logistic(x)) * Gaussian(x))
/// </summary>
/// <param name="beta">Beta distribution</param>
/// <param name="gauss">Gaussian distribution</param>
/// <returns>A proposal distribution</returns>
public static Gaussian LogisticProposalDistribution(Beta beta, Gaussian gauss)
{
if (beta.IsUniform())
{
return(new Gaussian(gauss));
}
// if gauss is uniform, m,p = 0 below, and the following code will just ignore the Gaussian
// and do a Laplace approximation for Beta(Logistic(x))
double c = beta.TrueCount - 1;
double d = beta.FalseCount - 1;
double m = gauss.GetMean();
double p = gauss.Precision;
// We want to find the mode of
// ln(g(x)) = c.ln(f(x)) + d.ln(1 - f(x)) - 0.5p((x - m)^2) + constant
// First deriv:
// h(x) = (ln(g(x))' = c.(1 - f(x)) - d.f(x) - p(x-m)
// Second deriv:
// h'(x) = (ln(g(x))' = -(c+d).f'(x) - p
// Use Newton-Raphson to find unique root of h(x).
// g(x) is log-concave so Newton-Raphson should converge quickly.
// Set the initial point by projecting beta
// to a Gaussian and taking the mean of the product:
double bMean, bVar;
beta.GetMeanAndVariance(out bMean, out bVar);
Gaussian prod = new Gaussian();
double invLogisticMean = Math.Log(bMean) - Math.Log(1.0 - bMean);
prod.SetToProduct(Gaussian.FromMeanAndVariance(invLogisticMean, bVar), gauss);
double xnew = prod.GetMean();
double x = 0, fx, dfx, hx, dhx = 0;
int maxIters = 100; // Should only need a handful of iters
int cnt = 0;
do
{
x = xnew;
fx = MMath.Logistic(x);
dfx = fx * (1.0 - fx);
// Find the root of h(x)
hx = c * (1.0 - fx) - d * fx - p * (x - m);
dhx = -(c + d) * dfx - p;
xnew = x - (hx / dhx); // The Newton step
if (Math.Abs(x - xnew) < 0.00001)
{
break;
}
} while (++cnt < maxIters);
if (cnt >= maxIters)
{
throw new InferRuntimeException("Unable to find proposal distribution mode");
}
return(Gaussian.FromMeanAndPrecision(x, -dhx));
}
/// <summary>
/// VMP message to 'product'
/// </summary>
/// <param name="A">Incoming message from 'a'. Must be a proper distribution. If uniform, the result will be uniform.</param>
/// <param name="B">Incoming message from 'b'. Must be a proper distribution. If uniform, the result will be uniform.</param>
/// <returns>The outgoing VMP message to the 'product' argument</returns>
/// <remarks><para>
/// The outgoing message is a distribution matching the moments of 'product' as the random arguments are varied.
/// The formula is <c>proj[sum_(a,b) p(a,b) factor(product,a,b)]</c>.
/// </para></remarks>
/// <exception cref="ImproperMessageException"><paramref name="A"/> is not a proper distribution</exception>
/// <exception cref="ImproperMessageException"><paramref name="B"/> is not a proper distribution</exception>
public static Gaussian ProductAverageLogarithm([SkipIfUniform] Gaussian A, [SkipIfUniform] Gamma B)
{
double ma = A.GetMean(), mb = B.GetMean();
double va = A.GetVariance(), vb = B.GetVariance();
if (Double.IsPositiveInfinity(va) || Double.IsPositiveInfinity(vb))
{
return(Gaussian.Uniform());
}
return(Gaussian.FromMeanAndVariance(ma * mb, va * vb + va * mb * mb + vb * ma * ma));
}
/// <summary>
/// VMP message to 'product'
/// </summary>
/// <param name="A">Constant value for 'a'.</param>
/// <param name="B">Incoming message from 'b'. Must be a proper distribution. If uniform, the result will be uniform.</param>
/// <returns>The outgoing VMP message to the 'product' argument</returns>
/// <remarks><para>
/// The outgoing message is a distribution matching the moments of 'product' as the random arguments are varied.
/// The formula is <c>proj[sum_(b) p(b) factor(product,a,b)]</c>.
/// </para></remarks>
/// <exception cref="ImproperMessageException"><paramref name="B"/> is not a proper distribution</exception>
public static Gaussian ProductAverageLogarithm(double A, [SkipIfUniform] Gamma B)
{
double mb, vb;
B.GetMeanAndVariance(out mb, out vb);
if (Double.IsPositiveInfinity(vb))
{
return(Gaussian.Uniform());
}
return(Gaussian.FromMeanAndVariance(A * mb, A * A * vb));
}
public static DistributionArray2D <Gaussian, double> RandomGaussianArray(int C, int d)
{
Gaussian[,] array = new Gaussian[C, d];
for (int i = 0; i < C; i++)
{
for (int j = 0; j < d; j++)
{
array[i, j] = Gaussian.FromMeanAndVariance(Rand.Normal(), 1);
}
}
return((DistributionArray2D <Gaussian, double>) Distribution <double> .Array(array));
}
/// <summary>
/// Create an array of Gaussian distributions with random mean and unit variance
/// </summary>
/// <param name="row">Number of rows</param>
/// <param name="col">Number of columns</param>
/// <returns>The array as a distribution over a 2-D double array domain</returns>
private static IDistribution <double[, ]> randomGaussianArray(int row, int col)
{
Gaussian[,] array = new Gaussian[row, col];
for (int i = 0; i < row; i++)
{
for (int j = 0; j < col; j++)
{
array[i, j] = Gaussian.FromMeanAndVariance(Rand.Normal(), 1);
}
}
return(Distribution <double> .Array(array));
}
public void GaussianOpX2Test()
{
using (TestUtils.TemporarilyAllowGaussianImproperMessages)
{
Gamma precision = Gamma.FromShapeAndScale(3, 3);
Gaussian mean;
mean = Gaussian.PointMass(7);
GaussianOpX2(mean, precision);
mean = Gaussian.FromMeanAndVariance(7, 1.0 / 3);
GaussianOpX2(mean, precision);
}
}
/// <summary>
/// EP message to 'product'.
/// </summary>
/// <param name="Product">Incoming message from 'product'.</param>
/// <param name="A">Incoming message from 'a'.</param>
/// <param name="B">Incoming message from 'b'.</param>
/// <returns>The outgoing EP message to the 'product' argument.</returns>
/// <remarks><para>
/// The outgoing message is the integral of the factor times incoming messages, over all arguments except 'product'.
/// The formula is <c>int f(product,x) q(x) dx</c> where <c>x = (a,b)</c>.
/// </para></remarks>
public static Gaussian ProductAverageConditional(Gaussian Product, Gaussian A, Beta B)
{
A.GetMeanAndVariance(out mA, out vA);
double mB, vB;
B.GetMeanAndVariance(out mB, out vB);
double mProduct, vProduct;
Product.GetMeanAndVariance(out mProduct, out vProduct);
// algorithm: quadrature on A from -1 to 1, plus quadrature on 1/A from -1 to 1.
double z = 0, sumX = 0, sumX2 = 0;
for (int i = 0; i <= QuadratureNodeCount; i++)
{
double a = (2.0 * i) / QuadratureNodeCount - 1;
double logfA = Gaussian.GetLogProb(mProduct, a * mB, vProduct + a * a * vB) + Gaussian.GetLogProb(a, mA, vA);
double fA = Math.Exp(logfA);
z += fA;
double b = (mB * vProduct + a * mProduct * vB) / (vProduct + a * a * vB);
double b2 = b * b + (vProduct * vB) / (vProduct + a * a * vB);
double x = a * b;
double x2 = a * a * b2;
sumX += x * fA;
sumX2 += x2 * fA;
double invA = a;
a = 1.0 / invA;
double logfInvA = Gaussian.GetLogProb(mProduct * invA, mB, vProduct * invA * invA + vB) + Gaussian.GetLogProb(a, mA, vA) - Math.Log(Math.Abs(invA + Double.Epsilon));
double fInvA = Math.Exp(logfInvA);
z += fInvA;
b = (mB * vProduct + a * mProduct * vB) / (vProduct + a * a * vB);
b2 = b * b + (vProduct * vB) / (vProduct + a * a * vB);
x = a * b;
x2 = a * a * b2;
sumX += x * fInvA;
sumX2 += x2 * fInvA;
}
double mean = sumX / z;
double var = sumX2 / z - mean * mean;
Gaussian result = Gaussian.FromMeanAndVariance(mean, var);
if (ForceProper)
{
result.SetToRatioProper(result, Product);
}
else
{
result.SetToRatio(result, Product);
}
return(result);
}
/// <summary>VMP message to <c>productExp</c>.</summary>
/// <param name="A">Constant value for <c>a</c>.</param>
/// <param name="B">Incoming message from <c>b</c>. Must be a proper distribution. If uniform, the result will be uniform.</param>
/// <returns>The outgoing VMP message to the <c>productExp</c> argument.</returns>
/// <remarks>
/// <para>The outgoing message is a distribution matching the moments of <c>productExp</c> as the random arguments are varied. The formula is <c>proj[sum_(b) p(b) factor(productExp,a,b)]</c>.</para>
/// </remarks>
/// <exception cref="ImproperMessageException">
/// <paramref name="B" /> is not a proper distribution.</exception>
public static Gaussian ProductExpAverageLogarithm(double A, [SkipIfUniform] Gaussian B)
{
double mb, vb;
B.GetMeanAndVariance(out mb, out vb);
if (Double.IsPositiveInfinity(vb))
{
return(Gaussian.Uniform());
}
double mp = A * Math.Exp(mb + vb / 2.0);
return(Gaussian.FromMeanAndVariance(mp, A * A * Math.Exp(2.0 * (mb + vb)) - mp * mp));
}
public void IndexOfMaximumFastTest()
{
int n = 5;
Range item = new Range(n).Named("item");
var priors = Variable <Gaussian> .Array(item);
priors.ObservedValue = Util.ArrayInit(n, i => Gaussian.FromMeanAndVariance(i * 0.5, i));
var x = Variable.Array <double>(item).Named("x");
x[item] = Variable <double> .Random(priors[item]);
var y = Variable <int> .Factor(MMath.IndexOfMaximumDouble, x);
InferenceEngine engine = new InferenceEngine();
engine.ShowProgress = false;
string format = "f4";
var yActual = engine.Infer <Discrete>(y);
Console.WriteLine("Quadratic: {0}", yActual.ToString(format));
// Monte Carlo estimate
Rand.Restart(0);
DiscreteEstimator est = new DiscreteEstimator(n);
for (int iter = 0; iter < 100000; iter++)
{
double[] samples = Util.ArrayInit(n, i => priors.ObservedValue[i].Sample());
int argmax = MMath.IndexOfMaximumDouble(samples);
est.Add(argmax);
}
var yExpected = est.GetDistribution(Discrete.Uniform(n));
Console.WriteLine("Sampling: {0}", yExpected.ToString(format));
Assert.True(yExpected.MaxDiff(yActual) < 1e-2);
engine.Compiler.GivePriorityTo(typeof(IndexOfMaximumOp_Fast));
yActual = engine.Infer <Discrete>(y);
Console.WriteLine("Linear: {0}", yActual.ToString(format));
Assert.True(yExpected.MaxDiff(yActual) < 1e-2);
bool compareApproximation = false;
if (compareApproximation)
{
var yPost2 = IndexOfMaximumOp_Fast.IndexOfMaximumDoubleAverageConditional(priors.ObservedValue, Discrete.Uniform(n));
Console.WriteLine(yPost2);
var yPost3 = IndexOfMaximumOp_Fast.IndexOfMaximumDoubleAverageConditional2(priors.ObservedValue, Discrete.Uniform(n));
Console.WriteLine(yPost3);
}
}
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="InnerProductArrayOp"]/message_doc[@name="InnerProductAverageConditional(double[], IList{Gaussian})"]/*'/>
public static Gaussian InnerProductAverageConditional(double[] A, [SkipIfUniform] IList <Gaussian> B)
{
double xMean = 0, xVariance = 0,
bMean, bVariance;
for (int k = 0; k < A.Length; k++)
{
B[k].GetMeanAndVariance(out bMean, out bVariance);
xMean += A[k] * bMean;
xVariance += A[k] * A[k] * bVariance;
}
return(Gaussian.FromMeanAndVariance(xMean, xVariance));
}
static void Main(string[] args)
{
double[][] trainingData = new double[2][];
trainingData[0] = new double[] { 0.5, 0.6, 0.7, 0.24 };
trainingData[1] = new double[] { 0.4, 0.3, 0.55, 0.95 };
Gaussian alphaPrior = Gaussian.FromMeanAndVariance(1, 0.002);
Gaussian betaPrior = Gaussian.FromMeanAndVariance(1, 0.002);
Gaussian genesT1Prior = Gaussian.FromMeanAndVariance(1, 0.002);
Gaussian wPrior = Gaussian.FromMeanAndVariance(0, 1);
int nGenes = trainingData[0].Length;
NetModelData initPriors = new NetModelData(
Util.ArrayInit(nGenes, u => genesT1Prior),
Util.ArrayInit(nGenes, u => alphaPrior),
Util.ArrayInit(nGenes, u => betaPrior),
Util.ArrayInit(nGenes, u => Util.ArrayInit(nGenes - 1, t => wPrior))
); // w -> variance : Variable.GammaFromShapeAndRate(1, 1)
//Train the model
PertNetModel pertNetModel = new PertNetModel();
Console.WriteLine("number of genes: " + trainingData[0].Length);
pertNetModel.CreateModel(trainingData[0].Length);
pertNetModel.SetModelData(initPriors);
NetModelData posteriors1 = pertNetModel.InferModelData(trainingData);
Gaussian[][] x = posteriors1.wDist;
for (int i = 0; i < posteriors1.wDist.Length; i++)
{
for (int j = 0; j < posteriors1.wDist[i].Length; j++)
{
Console.WriteLine(posteriors1.wDist[i][j]);
}
}
//Console.WriteLine("Inferred w = " + posteriors1.wDist);
// Console.WriteLine("===================");
// Console.WriteLine(pertNetModel.w);
//////////////////////////
double[][] trainingData2 = new double[2][];
trainingData2[0] = new double[] { 0.25, 0.16, 0.73, 0.4 };
trainingData2[1] = new double[] { 0.94, 0.43, 0.25, 0.65 };
pertNetModel.SetModelData(posteriors1);
NetModelData posteriors2 = pertNetModel.InferModelData(trainingData2);
Console.ReadLine();
}
/// <summary>VMP message to <c>productExp</c>.</summary>
/// <param name="A">Incoming message from <c>a</c>. Must be a proper distribution. If uniform, the result will be uniform.</param>
/// <param name="B">Incoming message from <c>b</c>. Must be a proper distribution. If uniform, the result will be uniform.</param>
/// <returns>The outgoing VMP message to the <c>productExp</c> argument.</returns>
/// <remarks>
/// <para>The outgoing message is a distribution matching the moments of <c>productExp</c> as the random arguments are varied. The formula is <c>proj[sum_(a,b) p(a,b) factor(productExp,a,b)]</c>.</para>
/// </remarks>
/// <exception cref="ImproperMessageException">
/// <paramref name="A" /> is not a proper distribution.</exception>
/// <exception cref="ImproperMessageException">
/// <paramref name="B" /> is not a proper distribution.</exception>
public static Gaussian ProductExpAverageLogarithm([SkipIfUniform] Gaussian A, [SkipIfUniform] Gaussian B)
{
double ma, mb, va, vb;
A.GetMeanAndVariance(out ma, out va);
B.GetMeanAndVariance(out mb, out vb);
if (Double.IsPositiveInfinity(va) || Double.IsPositiveInfinity(vb))
{
return(Gaussian.Uniform());
}
double mp = ma * Math.Exp(mb + vb / 2.0);
return(Gaussian.FromMeanAndVariance(mp, (va + ma * ma) * Math.Exp(2.0 * (mb + vb)) - mp * mp));
}
/// <summary>
/// EP message to 'logOdds'.
/// </summary>
/// <param name="sample">Constant value for sample.</param>
/// <param name="logOdds">Incoming message from 'logOdds'. Must be a proper distribution. If uniform, the result will be uniform.</param>
/// <returns>The outgoing EP message to the 'logOdds' argument.</returns>
/// <remarks><para>
/// The outgoing message is the moment matched Gaussian approximation to the factor.
/// </para></remarks>
public static Gaussian LogOddsAverageConditional(bool sample, [SkipIfUniform] Gaussian logOdds)
{
double m, v;
logOdds.GetMeanAndVariance(out m, out v);
double s = sample ? 1 : -1;
m *= s;
if (m + 1.5 * v < -38)
{
double beta2 = Math.Exp(m + 1.5 * v);
return(Gaussian.FromMeanAndVariance(s * (m + v), v * (1 - v * beta2)) / logOdds);
}
double sigma0 = MMath.LogisticGaussian(m, v);
double sigma1 = MMath.LogisticGaussianDerivative(m, v);
double sigma2 = MMath.LogisticGaussianDerivative2(m, v);
double alpha, beta;
alpha = sigma1 / sigma0;
if (Double.IsNaN(alpha))
{
throw new Exception("alpha is NaN");
}
if (m + 2 * v < -19)
{
beta = Math.Exp(3 * m + 2.5 * v) / (sigma0 * sigma0);
}
else
{
//beta = (sigma1*sigma1 - sigma2*sigma0)/(sigma0*sigma0);
beta = alpha * alpha - sigma2 / sigma0;
}
if (Double.IsNaN(beta))
{
throw new Exception("beta is NaN");
}
double m2 = s * (m + v * alpha);
double v2 = v * (1 - v * beta);
if (v2 > v)
{
throw new Exception("v2 > v");
}
if (v2 < 0)
{
throw new Exception("v2 < 0");
}
return(Gaussian.FromMeanAndVariance(m2, v2) / logOdds);
}
public void LogisticProposalDistribution()
{
double[] TrueCounts = { 2, 20, 200, 2000, 20000, 2, 20, 200, 2000, 20000 };
double[] FalseCounts = { 2, 200, 20000, 200, 20, 200, 2000, 2, 2000, 20 };
double[] Means = { .5, 1, 2, 4, 8, 16, 32, 0, -2, -20 };
double[] Variances = { 1, 2, 4, 8, .1, .0001, .01, .000001, 0.000001, 0.001 };
for (int i = 0; i < 10; i++)
{
Beta b = new Beta();
b.TrueCount = TrueCounts[i];
b.FalseCount = FalseCounts[i];
Gaussian g = Gaussian.FromMeanAndVariance(Means[i], Variances[i]);
Gaussian gProposal = GaussianBetaProductOp.LogisticProposalDistribution(b, g);
}
}
/// <summary>
/// Priors from posteriors with possible missing features.
/// </summary>
/// <param name="posteriors">The posteriors.</param>
/// <param name="featureSet">The feature set.</param>
/// <param name="noiseVariance">The noise variance.</param>
/// <returns>The <see cref="Priors" /></returns>
internal static Priors FromPosteriors(Posteriors posteriors, FeatureSet featureSet, double noiseVariance)
{
return(new Priors
{
Weights =
featureSet.FeatureBuckets.ToDictionary(
ia => ia,
ia =>
posteriors.Weights.ContainsKey(ia)
? posteriors.Weights[ia]
: Gaussian.FromMeanAndVariance(0.0, noiseVariance)),
Threshold = posteriors.Threshold,
NoiseVariance = noiseVariance,
});
}
public void ReadXml(XmlReader reader)
{
reader.MoveToFirstAttribute();
DynamicPopularityFactor = double.Parse(reader.GetAttribute("dynamic"));
ScoreAccuracy = Gaussian.FromMeanAndVariance(
double.Parse(reader.GetAttribute("scoreAccuracyMean")),
double.Parse(reader.GetAttribute("scoreAccuracyVariance")));
while (reader.ReadToFollowing("participant"))
{
var p = new Participant();
p.ReadXml(reader);
Participants.Add(p.Id, p);
}
}
/// <summary>
/// The entry point of the program, where the program control starts and ends.
/// </summary>
public static void Main()
{
const int T = 100;
const int K = 2;
const int N = 5;
const bool showFactorGraph = false;
TestHMM <ContinousHMM, double, double, Gaussian, Gaussian, double, Gamma, double>(
T,
K,
1,
Gaussian.FromMeanAndPrecision,
() => Gaussian.FromMeanAndVariance(0, 1000),
() => Gamma.FromShapeAndScale(1000, 0.001),
showFactorGraph);
// TModel, TEmit, TEmitDist, TEmitMeanDist, TEmitMean, TEmitPrecDist, TEmitPrec
TestHMM <MultivariateHMM, Vector, Vector, VectorGaussian, VectorGaussian, Vector, Wishart, PositiveDefiniteMatrix>(
T,
K,
1,
VectorGaussian.FromMeanAndPrecision,
() => VectorGaussian.FromMeanAndVariance(Vector.Zero(N), PositiveDefiniteMatrix.IdentityScaledBy(N, 1000)),
() => Wishart.FromShapeAndScale(N, PositiveDefiniteMatrix.IdentityScaledBy(N, 0.001)),
showFactorGraph);
TestHMM <BinaryHMM, bool, double, Bernoulli, Beta, double, Beta, double>(
T,
K,
1,
(m, p) => new Bernoulli(m),
() => new Beta(1, 1),
null,
showFactorGraph);
TestHMM <DiscreteHMM, int, double, Discrete, Dirichlet, Vector, Dirichlet, Vector>(
T,
K,
N,
(m, p) => new Discrete(m),
() => Dirichlet.Uniform(N),
null,
showFactorGraph);
// TestBinaryHiddenMarkovModel();
// TestDiscreteHiddenMarkovModel();
// TestMultivariateHMM();
}
