public void MarginalPrototypeOfConstantInGateTest() { Range item = new Range(2).Named("i"); var bools = Variable.Array <bool>(item).Named("bools"); bools.ObservedValue = Util.ArrayInit(item.SizeAsInt, i => false); var Response = Variable.Array <int>(item).Named("response"); Response.ObservedValue = Util.ArrayInit(item.SizeAsInt, i => 0); var correct = Variable.Array <bool>(item).Named("correct"); using (Variable.ForEach(item)) { correct[item] = Variable.Bernoulli(0.1); using (Variable.If(bools[item])) { using (Variable.If(correct[item])) Response[item] = Variable.Constant(1); using (Variable.IfNot(correct[item])) Response[item] = Variable.DiscreteUniform(4) + Variable.Constant(1); } using (Variable.IfNot(bools[item])) { Response[item] = Variable.Constant(0); } } InferenceEngine engine = new InferenceEngine(); Console.WriteLine(engine.Infer(correct)); Console.WriteLine(engine.Infer(Response)); }
public Gaussian[] IndexOfMaximumFactorGate2(Discrete y, out double logEvidence) { var ev = Variable.Bernoulli(0.5).Named("ev"); int N = y.Dimension; var n = new Range(N).Named("n"); var block = Variable.If(ev); var x = Variable.Array <double>(n).Named("x"); x[n] = Variable.GaussianFromMeanAndPrecision(0, 1).ForEach(n); var yVar = Variable <int> .Random(y).Named("y"); var indices = Variable.Observed(new int[] { 0, 1, 2 }, n); yVar.SetValueRange(n); using (Variable.Switch(yVar)) { indices[yVar] = IndexOfMaximum(x).Named("temp"); } block.CloseBlock(); var ie = new InferenceEngine(); //ie.NumberOfIterations = 2; logEvidence = ie.Infer <Bernoulli>(ev).LogOdds; return(ie.Infer <Gaussian[]>(x)); }
public void GPClassificationTest4() { bool[] yData = new bool[] { false, false, true, false }; double[] xData = new double[] { -1.555555555555556, -1.111111111111111, -0.2222222222222223, 1.555555555555555 }; Vector[] xVec = Array.ConvertAll(xData, v => Vector.Constant(1, v)); Vector[] basis = new Vector[] { Vector.Zero(1) }; IKernelFunction kf = new SquaredExponential(0.0); SparseGPFixed sgpf = new SparseGPFixed(kf, basis); Variable <bool> evidence = Variable.Bernoulli(0.5).Named("evidence"); IfBlock block = Variable.If(evidence); Variable <IFunction> f = Variable.Random <IFunction>(new SparseGP(sgpf)).Named("f"); Range item = new Range(xVec.Length).Named("item"); VariableArray <Vector> x = Variable.Array <Vector>(item).Named("x"); x.ObservedValue = xVec; VariableArray <bool> y = Variable.Array <bool>(item).Named("y"); y.ObservedValue = yData; VariableArray <double> h = Variable.Array <double>(item).Named("h"); h[item] = Variable.FunctionEvaluate(f, x[item]); y[item] = (h[item] > 0); block.CloseBlock(); InferenceEngine engine = new InferenceEngine(); SparseGP sgp = engine.Infer <SparseGP>(f); Vector alphaExpected = Vector.FromArray(new double[] { 0.409693797629808 }); Console.WriteLine("alpha = {0} should be {1}", sgp.Alpha, alphaExpected); }
public void CoinFlips() { int threshold = 20; int N = 100; var n = new Range(N).Named("n"); var coins = Variable.Array <bool>(n).Named("coins"); coins[n] = Variable.Bernoulli(.5).ForEach(n); var RunLength = new Variable <int> [N]; var zero = Variable.Random(Discrete.PointMass(0, N)); RunLength[0] = Variable.Constant(0); var thresholdExceeded = Variable.Bernoulli(0); for (int i = 1; i < N; i++) { RunLength[i] = Variable.New <int>(); using (Variable.If(coins[i - 1])) RunLength[i].SetTo(RunLength[i - 1] + 1); using (Variable.IfNot(coins[i - 1])) RunLength[i].SetTo(zero); thresholdExceeded |= RunLength[i] > threshold; } var ie = new InferenceEngine(); Console.WriteLine(ie.Infer(RunLength[10])); }
public BpmPredict() { nFeatures = Variable.New <int>().Named("nFeatures"); Range feature = new Range(nFeatures).Named("feature"); w = Variable.Array <double>(feature).Named("w"); //VariableArray<Gaussian> wPrior = Variable.Array<Gaussian>(feature).Named("wPrior"); //w[feature] = Variable<double>.Random(wPrior[feature]); wPrior = Variable.New <GaussianArray>().Named("wPrior"); w.SetTo(Variable <double[]> .Random(wPrior)); biasPrior = Variable.New <Gaussian>().Named("biasPrior"); bias = Variable <double> .Random(biasPrior).Named("bias"); xValueCount = Variable.New <int>().Named("xValueCount"); Range userFeature = new Range(xValueCount).Named("userFeature"); xValues = Variable.Array <double>(userFeature).Named("xValues"); xIndices = Variable.Array <int>(userFeature).Named("xIndices"); y = Variable.New <bool>().Named("y"); VariableArray <double> product = Variable.Array <double>(userFeature).Named("product"); VariableArray <double> wSparse = Variable.Subarray(w, xIndices); product[userFeature] = xValues[userFeature] * wSparse[userFeature]; Variable <double> score = Variable.Sum(product).Named("score"); y = (Variable.GaussianFromMeanAndVariance(score + bias, 1.0) > 0); engine = new InferenceEngine(); engine.Compiler.FreeMemory = false; engine.Compiler.ReturnCopies = false; engine.OptimiseForVariables = new IVariable[] { y }; engine.ModelName = "BpmPredict"; }
/// <summary> /// Returns the community score matrix prior. /// </summary> /// <returns>The community score matrix prior.</returns> private VectorGaussian[] GetScoreMatrixPrior() { var dim = new Range(LabelCount); var mean = Variable.VectorGaussianFromMeanAndPrecision(Vector.Zero(LabelCount), PositiveDefiniteMatrix.IdentityScaledBy(LabelCount, 1)); var prec = Variable.WishartFromShapeAndRate(1.0, PositiveDefiniteMatrix.IdentityScaledBy(LabelCount, 1)); var score = Variable.VectorGaussianFromMeanAndPrecision(mean, prec); var confusion = Variable.Softmax(score); confusion.SetValueRange(dim); var confusionConstraint = Variable.New <Dirichlet>(); Variable.ConstrainEqualRandom(confusion, confusionConstraint); var engine = new InferenceEngine(new VariationalMessagePassing()) { ShowProgress = false }; engine.Compiler.WriteSourceFiles = false; var scorePrior = new VectorGaussian[LabelCount]; for (int d = 0; d < LabelCount; d++) { confusionConstraint.ObservedValue = new Dirichlet(Util.ArrayInit(LabelCount, i => i == d ? (InitialWorkerBelief / (1 - InitialWorkerBelief)) * (LabelCount - 1) : 1.0)); scorePrior[d] = engine.Infer <VectorGaussian>(score); } return(scorePrior); }
public void RunAnyPlayersMatchup(Participant[] participants) { var range = new Range(participants.Length); var results = Variable.Array <bool>(range); var popularities = Variable.Array <double>(range); var variances = Variable.Array <double>(range); var priors = Variable.Array <Gaussian>(range); priors.ObservedValue = participants.Select( p => p.popularityGaussian).ToArray(); variances.ObservedValue = participants.Select( p => DynamicPopularityFactor * DynamicPopularityFactor).ToArray(); using (var loop = Variable.ForEach(range)) { popularities[range] = Variable.GaussianFromMeanAndVariance( Variable <double> .Random(priors[range]), variances[range]); using (Variable.If(loop.Index > 0)) { results[loop.Index] .SetTo(popularities[loop.Index - 1] > popularities[loop.Index]); results.ObservedValue = participants.Select(p => true).ToArray(); } } var participantPosts = Ranking.Engine.Infer <Gaussian[]>(popularities); for (int i = 0; i < participants.Length; i++) { participants[i].popularityGaussian = participantPosts[i]; } }
public void MixtureWithConstantSelector() { Range Trange = new Range(2).Named("Trange"); VariableArray <double> x = Variable.Constant(new double[] { 1, 15 }, Trange).Named("x"); Range Krange = new Range(2).Named("Krange"); VariableArray <double> means = Variable.Array <double>(Krange); means[Krange] = Variable.GaussianFromMeanAndPrecision(2, 1).ForEach(Krange); VariableArray <int> c = Variable.Constant(new int[] { 0, 1 }, Trange).Named("c"); c[Trange] = Variable.DiscreteUniform(Krange).ForEach(Trange); using (Variable.ForEach(Trange)) { using (Variable.Switch(c[Trange])) { x[Trange] = Variable.GaussianFromMeanAndPrecision(means[c[Trange]], 1); } } InferenceEngine ie = new InferenceEngine(new VariationalMessagePassing()); Console.WriteLine(ie.Infer(means)); }
public virtual void CreateModel() { NumComponents = 2; Range ComponentRange = new Range(NumComponents); InferenceEngine = new InferenceEngine(new VariationalMessagePassing()); InferenceEngine.ShowProgress = false; AverageTimePriors = Variable.Array <Gaussian>(ComponentRange); TrafficNoisePriors = Variable.Array <Gamma>(ComponentRange); AverageTime = Variable.Array <double>(ComponentRange); TrafficNoise = Variable.Array <double>(ComponentRange); using (Variable.ForEach(ComponentRange)) { AverageTime[ComponentRange] = Variable <double> .Random(AverageTimePriors[ComponentRange]); TrafficNoise[ComponentRange] = Variable <double> .Random(TrafficNoisePriors[ComponentRange]); } // Mixing coefficients MixingPrior = Variable.New <Dirichlet>(); MixingCoefficients = Variable <Vector> .Random(MixingPrior); MixingCoefficients.SetValueRange(ComponentRange); }
public void Mixture1() { double[] data = { 7 }; int T = data.Length; VariableArray <double> x = Variable.Constant(data).Named("data"); Range i = x.Range; Variable <Vector> D = Variable.Dirichlet(new double[] { 1, 1 }); VariableArray <int> c = Variable.Array <int>(i); using (Variable.ForEach(i)) { c[i] = Variable.Discrete(D); using (Variable.Case(c[i], 0)) { x[i] = Variable.GaussianFromMeanAndPrecision(5.5, 1); } using (Variable.Case(c[i], 1)) { x[i] = Variable.GaussianFromMeanAndPrecision(8, 1); } } InferenceEngine ie = new InferenceEngine(new VariationalMessagePassing()); double[] DVibesResult = new double[] { -1.15070203880043, -0.67501576717763 }; VmpTests.TestDirichletMoments(ie, D, DVibesResult); double[][] cVibesResult = new double[T][]; cVibesResult[0] = new double[] { 0.24961241199438, 0.75038758800562 }; VmpTests.TestDiscrete(ie, c, cVibesResult); }
public void Mixture2() { double[] data = { .5, 12, 11 }; int T = data.Length; VariableArray <double> x = Variable.Constant(data).Named("data"); Range i = x.Range; Variable <Vector> D = Variable.Dirichlet(new double[] { 1, 1 }); VariableArray <int> c = Variable.Array <int>(i); using (Variable.ForEach(i)) { c[i] = Variable.Discrete(D); using (Variable.Case(c[i], 0)) { x[i] = Variable.GaussianFromMeanAndPrecision(5, 1); } using (Variable.Case(c[i], 1)) { x[i] = Variable.GaussianFromMeanAndPrecision(10, 1); } } InferenceEngine ie = new InferenceEngine(new VariationalMessagePassing()); double[] DVibesResult = new double[] { -1.08333333348476, -0.58333333335936 }; VmpTests.TestDirichletMoments(ie, D, DVibesResult); double[][] cVibesResult = new double[T][]; cVibesResult[0] = new double[] { 1.00000000000000, 0.00000000000000 }; cVibesResult[1] = new double[] { 0.00000000000000, 1.00000000000000 }; cVibesResult[2] = new double[] { 0.00000000000000, 1.00000000000000 }; VmpTests.TestDiscrete(ie, c, cVibesResult); }
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); }
public void PottsGridTest() { int size = 10; Range rows = new Range(size).Named("rows"); Range cols = new Range(size).Named("cols"); var states = Variable.Array <bool>(rows, cols).Named("states"); Bernoulli[,] unary = new Bernoulli[size, size]; for (int i = 0; i < size; i++) { for (int j = 0; j < size; j++) { var xdist = System.Math.Abs(i - size / 2) / ((double)size); var ydist = System.Math.Abs(j - size / 2) / ((double)size); bool inrect = (xdist < 0.2) && (ydist < 0.2); unary[i, j] = new Bernoulli(inrect ? 0.8 : 0.2); } } var p = Variable.Observed(unary, rows, cols); states[rows, cols] = Variable.Random <bool, Bernoulli>(p[rows, cols]); double logCost = 0; using (ForEachBlock rowBlock = Variable.ForEach(rows)) { using (ForEachBlock colBlock = Variable.ForEach(cols)) { using (Variable.If(rowBlock.Index >= 1)) { Variable.Potts(states[rowBlock.Index, colBlock.Index], states[rowBlock.Index + -1, colBlock.Index], logCost); } using (Variable.If(colBlock.Index >= 1)) { Variable.Potts(states[rowBlock.Index, colBlock.Index], states[rowBlock.Index, colBlock.Index + -1], logCost); } } } InferenceEngine engine = new InferenceEngine(); engine.Algorithm = new MaxProductBeliefPropagation(); engine.ShowTimings = true; engine.NumberOfIterations = 20; var result = engine.Infer <Bernoulli[, ]>(states); for (int i = 0; i < result.GetLength(0); i++) { for (int j = 0; j < result.GetLength(1); j++) { Console.Write("{0:f5} ", result[i, j].GetProbTrue()); } Console.WriteLine(); } }
public void MarginalPrototypeOfConstantInGateTest2() { Range r = new Range(3); var skills = Variable.Array <double>(r).Named("skills"); var results = Variable.Array <int>(r).Named("results"); using (Variable.ForEach(r)) { skills[r] = Variable.GaussianFromMeanAndPrecision(25.5, 0.05); var b = (skills[r] - 25) > 0; using (Variable.If(b)) { results[r] = 0; } using (Variable.IfNot(b)) { results[r] = 1; } } int[] observedResults = new int[3] { 0, 0, 0 }; Variable.ConstrainEqual(results, observedResults); InferenceEngine engine = new InferenceEngine(); Console.WriteLine(engine.Infer(skills)); }
public static VariableArray <Vector> CPT1(Range rY, Range rS) { int dimS = rS.SizeAsInt; int dimY = rY.SizeAsInt; double pc = 1 / (double)(dimS * dimY); var priorObs = new Dirichlet[dimS]; for (int i = 0; i < dimS; i++) { priorObs[i] = Dirichlet.Symmetric(dimS, pc); } var priorVar = Variable.Array <Dirichlet>(rS); priorVar.ObservedValue = priorObs; var cpt = Variable.Array <Vector>(rS); cpt[rS] = Variable <Vector> .Random(priorVar[rS]); cpt.SetValueRange(rY); return(cpt); }
public DistributionArray <Bernoulli> TestNaiveBayes(double a, out double noiseEstimate) { noiseEstimate = double.NaN; int K = xtrain[0].Count; // Create target y VariableArray <bool> y = Variable.Observed(ytrain).Named("y"); Variable <Vector> meanTrue = Variable.Random(new VectorGaussian(Vector.Zero(K), PositiveDefiniteMatrix.Identity(K))).Named("m1"); Variable <Vector> meanFalse = Variable.Random(new VectorGaussian(Vector.Zero(K), PositiveDefiniteMatrix.Identity(K))).Named("m2"); var precTrue = Variable.Random(new Wishart(a, PositiveDefiniteMatrix.Identity(K))); var precFalse = Variable.Random(new Wishart(a, PositiveDefiniteMatrix.Identity(K))); NaiveBayes(xtrain, meanTrue, meanFalse, precTrue, precFalse, y); //InferenceEngine.DefaultEngine.Compiler.UseSerialSchedules = true; InferenceEngine engine = new InferenceEngine(new VariationalMessagePassing()); var meanTruePost = engine.Infer <VectorGaussian>(meanTrue); var meanFalsePost = engine.Infer <VectorGaussian>(meanFalse); var precTruePost = engine.Infer <Wishart>(precTrue); var precFalsePost = engine.Infer <Wishart>(precFalse); var testRange = new Range(ytest.Length); VariableArray <bool> yt = Variable.Array <bool>(testRange).Named("ytest"); yt[testRange] = Variable.Bernoulli(0.5).ForEach(testRange); NaiveBayes(xtest, Variable.Random(meanTruePost), Variable.Random(meanFalsePost), Variable.Random <PositiveDefiniteMatrix>(precTruePost), Variable.Random <PositiveDefiniteMatrix>(precFalsePost), yt); return(engine.Infer <DistributionArray <Bernoulli> >(yt)); }
public Gaussian[] IndexOfMaximumFactorGate(Discrete y, out double logEvidence) { var ev = Variable.Bernoulli(0.5).Named("ev"); int N = y.Dimension; var n = new Range(N).Named("n"); var block = Variable.If(ev); var x = Variable.Array <double>(n).Named("x"); x[n] = Variable.GaussianFromMeanAndPrecision(0, 1).ForEach(n); var yVar = Variable <int> .Random(y).Named("y"); for (int index = 0; index < N; index++) { using (Variable.Case(yVar, index)) { //var temp = Variable.Observed<int>(index).Named("temp"+index) ; //temp.SetTo(Variable<int>.Factor(MMath.IndexOfMaximumDouble, x).Named("fac"+index)); var temp = IndexOfMaximum(x).Named("temp" + index); temp.ObservedValue = index; } } block.CloseBlock(); var ie = new InferenceEngine(); ie.ModelName = "FactorGate"; ie.OptimiseForVariables = new List <IVariable>() { x, ev }; logEvidence = ie.Infer <Bernoulli>(ev).LogOdds; return(ie.Infer <Gaussian[]>(x)); }
public DistributionArray <Bernoulli> TestNaiveBayesDiagonalHierarchical(double a, out double noiseEstimate) { noiseEstimate = double.NaN; var xtrainArray = xtrain.Select(i => i.ToArray()).ToArray(); var xtestArray = xtest.Select(i => i.ToArray()).ToArray(); int K = xtrain[0].Count; var k = new Range(K); // Create target y VariableArray <bool> y = Variable.Observed(ytrain).Named("y"); var meanTrue = Variable.Array <double>(k); meanTrue[k] = Variable.GaussianFromMeanAndPrecision( Variable.GaussianFromMeanAndPrecision(0, 1), Variable.GammaFromShapeAndRate(.1, .1)).ForEach(k); var precTrue = Variable.Array <double>(k); precTrue[k] = Variable.GammaFromShapeAndRate( 1, Variable.GammaFromShapeAndRate(.1, .1)).ForEach(k); var meanFalse = Variable.Array <double>(k); meanFalse[k] = Variable.GaussianFromMeanAndPrecision( Variable.GaussianFromMeanAndPrecision(0, 1), Variable.GammaFromShapeAndRate(.1, .1)).ForEach(k); var precFalse = Variable.Array <double>(k); precFalse[k] = Variable.GammaFromShapeAndRate( 1, Variable.GammaFromShapeAndRate(.1, .1)).ForEach(k); NaiveBayesDiagonal(xtrainArray, meanTrue, meanFalse, precTrue, precFalse, y); //InferenceEngine.DefaultEngine.Compiler.UseSerialSchedules = true; InferenceEngine engine = new InferenceEngine(new VariationalMessagePassing()); var meanTruePost = engine.Infer <Gaussian[]>(meanTrue); var meanFalsePost = engine.Infer <Gaussian[]>(meanFalse); var precTruePost = engine.Infer <Gamma[]>(precTrue); var precFalsePost = engine.Infer <Gamma[]>(precFalse); var testRange = new Range(ytest.Length); VariableArray <bool> yt = Variable.Array <bool>(testRange).Named("ytest"); yt[testRange] = Variable.Bernoulli(0.5).ForEach(testRange); var meanTruePrior = Variable.Observed <Gaussian>(meanTruePost, k); var precTruePrior = Variable.Observed <Gamma>(precTruePost, k); var meanFalsePrior = Variable.Observed <Gaussian>(meanFalsePost, k); var precFalsePrior = Variable.Observed <Gamma>(precFalsePost, k); meanTrue = Variable.Array <double>(k); meanTrue[k] = Variable <double> .Random(meanTruePrior[k]); precTrue = Variable.Array <double>(k); precTrue[k] = Variable <double> .Random(precTruePrior[k]); meanFalse = Variable.Array <double>(k); meanFalse[k] = Variable <double> .Random(meanFalsePrior[k]); precFalse = Variable.Array <double>(k); precFalse[k] = Variable <double> .Random(precFalsePrior[k]); NaiveBayesDiagonal(xtestArray, meanTrue, meanFalse, precTrue, precFalse, yt); return(engine.Infer <DistributionArray <Bernoulli> >(yt)); }
public void StringFormatSimpleTest() { // number of objects var J = new Range(2).Named("J"); var names = Variable.Array <string>(J).Named("names"); names[J] = Variable.Random(WordString()).ForEach(J); Variable.ConstrainEqual(names[0], "John"); var i = Variable.DiscreteUniform(J); var template = Variable.Random(StringDistribution.Any()); var s = Variable.New <string>(); using (Variable.Switch(i)) { s.SetTo(Variable.StringFormat(template, names[i])); } s.ObservedValue = "John was here"; var engine = new InferenceEngine { NumberOfIterations = 10 }; engine.Compiler.RecommendedQuality = QualityBand.Experimental; engine.Compiler.GivePriorityTo(typeof(ReplicateOp_NoDivide)); Console.WriteLine("posterior=" + engine.Infer(i)); }
/// <summary> /// Constructs an LDA model /// </summary> /// <param name="sizeVocab">Size of vocabulary</param> /// <param name="numTopics">Number of topics</param> public LDAPredictionModel(int sizeVocab, int numTopics) { SizeVocab = sizeVocab; NumTopics = numTopics; PredictionSparsity = Sparsity.Sparse; //--------------------------------------------- // The model //--------------------------------------------- Range W = new Range(SizeVocab).Named("W"); Range T = new Range(NumTopics).Named("T"); ThetaPrior = Variable.New <Dirichlet>().Named("ThetaPrior"); PhiPrior = Variable.Array <Dirichlet>(T).Named("PhiPrior").Attrib(new ValueRange(W)); Theta = Variable.New <Vector>().Named("Theta"); Phi = Variable.Array <Vector>(T).Named("Phi"); Theta = Variable.Random <Vector, Dirichlet>(ThetaPrior); Phi[T] = Variable.Random <Vector, Dirichlet>(PhiPrior[T]); Word = Variable.New <int>().Named("Word"); Word.SetSparsity(PredictionSparsity); var topic = Variable.Discrete(Theta).Attrib(new ValueRange(T)).Named("topic"); using (Variable.Switch(topic)) { Word.SetTo(Variable.Discrete(Phi[topic])); } Engine = new InferenceEngine(new VariationalMessagePassing()); Engine.Compiler.ShowWarnings = false; }
public void amin() { int X_No = 5; int Z_No = 3; Range X_Range = new Range(X_No).Named("X_Range"); Range Z_Range = new Range(Z_No).Named("Z_Range"); int[][] Index = new int[][] { new int[] { 0, 1, 3 }, new int[] { 1, 2, 4 }, new int[] { 2, 4 } }; int[] sizes = new int[Z_No]; for (int i = 0; i < Z_No; i++) { sizes[i] = Index[i].Length; } VariableArray <int> sizesVar = Variable.Constant(sizes, Z_Range); Range Index_Range = new Range(sizesVar[Z_Range]).Named("Index_Range"); VariableArray <VariableArray <int>, int[][]> indexVar = Variable.Array(Variable.Array <int>(Index_Range), Z_Range).Named("indexVar"); indexVar.ObservedValue = Index; VariableArray <double> Var_X = Variable.Array <double>(X_Range).Named("Var_X"); VariableArray <double> Var_Z = Variable.Array <double>(Z_Range); Var_X[X_Range] = Variable.GaussianFromMeanAndPrecision(0, 1).ForEach(X_Range); Var_Z[Z_Range] = Variable.Sum(Variable.GetItems(Var_X, indexVar[Z_Range])); InferenceEngine ie = new InferenceEngine(); Console.WriteLine(ie.Infer(Var_Z)); }
public void PruningTest() { int numT = 2; int numD = 2; var D = new Range(numD); var T = new Range(numT); double alpha = 0.5; Vector v = Vector.Constant(numT, alpha, Sparsity.Sparse); // Using an observed prior: var prior = Variable.New <Dirichlet>(); prior.ObservedValue = new Dirichlet(v); var theta1 = Variable.Array <Vector>(D).Named("theta1"); theta1[D] = Variable.Random <Vector, Dirichlet>(prior).ForEach(D); // Using a constant vector var theta2 = Variable.Array <Vector>(D).Named("theta2"); theta2[D] = Variable.Dirichlet(T, Vector.Constant(numT, alpha, Sparsity.Sparse)).ForEach(D); // These should give the same result. var engine = new InferenceEngine(new VariationalMessagePassing()); var postTheta1 = engine.Infer <Dirichlet[]>(theta1); var postTheta2 = engine.Infer <Dirichlet[]>(theta2); for (int i = 0; i < numD; i++) { Assert.Equal(postTheta2[i], postTheta1[i]); } }
public void AlexJames() { // Data about tasks: true = correct, false = incorrect bool[] TaskA_Math = { false, true, true, true, true, true, true, true, false, false }; // Range for A int numA = TaskA_Math.Length; Range taskARange = new Range(numA); VariableArray <bool> data = Variable.Array <bool>(taskARange); // The prior var taskA_performance = Variable.Beta(1, 1); // The likelihood model data[taskARange] = Variable.Bernoulli(taskA_performance).ForEach(taskARange); // Attach data data.ObservedValue = TaskA_Math; // Inference engine (EP) InferenceEngine engine = new InferenceEngine(); // Infer probability of Task A Math so can predict Task B_Math etc. Console.WriteLine("isCorrect = {0}", engine.Infer <Beta>(taskA_performance).GetMean()); }
public static VariableArray <VariableArray <Vector>, Vector[][]> CPT2(Range rY, Range rS0, Range rS1) { int dimS0 = rS0.SizeAsInt; int dimS1 = rS1.SizeAsInt; int dimY = rY.SizeAsInt; double pc = 1 / (double)(dimS0 * dimS1 * dimY); var priorObs = new Dirichlet[dimS0][]; for (int i0 = 0; i0 < dimS0; i0++) { priorObs[i0] = new Dirichlet[dimS1]; for (int i1 = 0; i1 < dimS1; i1++) { priorObs[i0][i1] = Dirichlet.Symmetric(dimY, pc); } } var priorVar = Variable.Array(Variable.Array <Dirichlet>(rS1), rS0); priorVar.ObservedValue = priorObs; var cpt = Variable.Array(Variable.Array <Vector>(rS1), rS0); cpt[rS0][rS1] = Variable <Vector> .Random(priorVar[rS0][rS1]); cpt.SetValueRange(rY); return(cpt); }
public void LocalArrayMarginalPrototypeTest2() { var Topics_size = Variable.New <int>().Named("Topics_size"); var Topics_range = new Range(Topics_size).Named("Topics_range"); var Docs_size = Variable.New <int>().Named("Docs_size"); var Docs_range = new Range(Docs_size).Named("Docs_range"); ; var Docs_DocTopicDist = Variable.Array <Vector>(Docs_range).Named("Docs_DocTopicDist"); // "Cannot index Dirichlet.Uniform(v5.Length) by vint__1[index2] since v5 has an implicit dependency on Docs_range. Try making the dependency explicit by putting v5 into an array indexed by Docs_range" using (Variable.ForEach(Docs_range)) { var v5 = Variable.Array <double>(Topics_range).Named("v5"); // the problematic array var v6 = Variable.Constant <double>(5); var v7 = Variable.Constant <double>(5.1); var v8 = Variable.Constant <double>(5.2); var v9 = Variable.Constant <double>(5.3); var v10 = Variable.Constant <double>(5.4); var v11 = Variable.Constant <double>(5.5); var v12 = Variable.Constant <double>(5.6); v5[Variable.Constant <int>(0)] = v6; v5[Variable.Constant <int>(1)] = v7; v5[Variable.Constant <int>(2)] = v8; v5[Variable.Constant <int>(3)] = v9; v5[Variable.Constant <int>(4)] = v10; v5[Variable.Constant <int>(5)] = v11; v5[Variable.Constant <int>(6)] = v12; var v13 = v5; Docs_DocTopicDist[Docs_range] = Variable.Dirichlet(Topics_range, Variable.Vector(v13)); } var Occs_size = Variable.New <int>(); var Occs_range = new Range(Occs_size); var Occs_DocID = Variable.Array <int>(Occs_range); Occs_DocID.SetValueRange(Docs_range); var Occs_OccTopic = Variable.Array <int>(Occs_range); Occs_OccTopic.SetValueRange(Topics_range); using (Variable.ForEach(Occs_range)) { var v3 = Occs_DocID[Occs_range]; var v4 = Docs_DocTopicDist[v3]; Occs_OccTopic[Occs_range] = Variable.Discrete(Topics_range, v4); } Topics_size.ObservedValue = 7; Docs_size.ObservedValue = 3; Occs_size.ObservedValue = 4; Occs_DocID.ObservedValue = new int[] { 0, 1, 2, 2 }; InferenceEngine engine = new InferenceEngine(); engine.OptimiseForVariables = new IVariable[] { Docs_DocTopicDist, Occs_OccTopic }; Console.WriteLine("Z=" + engine.Infer(Docs_DocTopicDist) + engine.Infer(Occs_OccTopic)); }
// Construct a DINA model in Infer.NET public static void DinaModel( bool[][] responsesData, int nSkills, int[][] skillsRequired, Beta slipPrior, Beta guessPrior, out VariableArray <double> pSkill, out VariableArray <double> slip, out VariableArray <double> guess, out VariableArray <VariableArray <bool>, bool[][]> hasSkill) { // The Infer.NET model follows the same structure as the sampler above, but using Variables and Ranges int nStudents = responsesData.Length; int nQuestions = skillsRequired.Length; Range student = new Range(nStudents); Range question = new Range(nQuestions); Range skill = new Range(nSkills); var responses = Variable.Array(Variable.Array <bool>(question), student).Named("responses"); responses.ObservedValue = responsesData; pSkill = Variable.Array <double>(skill).Named("pSkill"); pSkill[skill] = Variable.Beta(1, 1).ForEach(skill); slip = Variable.Array <double>(question).Named("slip"); slip[question] = Variable.Random(slipPrior).ForEach(question); guess = Variable.Array <double>(question).Named("guess"); guess[question] = Variable.Random(guessPrior).ForEach(question); hasSkill = Variable.Array(Variable.Array <bool>(skill), student).Named("hasSkill"); hasSkill[student][skill] = Variable.Bernoulli(pSkill[skill]).ForEach(student); VariableArray <int> nSkillsRequired = Variable.Array <int>(question).Named("nSkillsRequired"); nSkillsRequired.ObservedValue = Util.ArrayInit(nQuestions, q => skillsRequired[q].Length); Range skillForQuestion = new Range(nSkillsRequired[question]).Named("skillForQuestion"); var skillsRequiredForQuestion = Variable.Array(Variable.Array <int>(skillForQuestion), question).Named("skillsRequiredForQuestion"); skillsRequiredForQuestion.ObservedValue = skillsRequired; skillsRequiredForQuestion.SetValueRange(skill); using (Variable.ForEach(student)) { using (Variable.ForEach(question)) { VariableArray <bool> hasSkills = Variable.Subarray(hasSkill[student], skillsRequiredForQuestion[question]); Variable <bool> hasAllSkills = Variable.AllTrue(hasSkills); using (Variable.If(hasAllSkills)) { responses[student][question] = !Variable.Bernoulli(slip[question]); } using (Variable.IfNot(hasAllSkills)) { responses[student][question] = Variable.Bernoulli(guess[question]); } } } }
public void GPClassificationTest2() { bool[] yData = new bool[] { false, true, false }; double[] xData = new double[] { -1.555555555555556, -0.2222222222222223, 1.555555555555555 }; Vector[] xVec = Array.ConvertAll(xData, v => Vector.Constant(1, v)); Vector[] basis = new Vector[] { Vector.Zero(1) }; IKernelFunction kf = new SquaredExponential(0.0); SparseGPFixed sgpf = new SparseGPFixed(kf, basis); Variable <bool> evidence = Variable.Bernoulli(0.5).Named("evidence"); IfBlock block = Variable.If(evidence); Variable <IFunction> f = Variable.Random <IFunction>(new SparseGP(sgpf)).Named("f"); Range item = new Range(xVec.Length).Named("item"); VariableArray <Vector> x = Variable.Array <Vector>(item).Named("x"); x.ObservedValue = xVec; VariableArray <bool> y = Variable.Array <bool>(item).Named("y"); y.ObservedValue = yData; VariableArray <double> h = Variable.Array <double>(item).Named("h"); h[item] = Variable.FunctionEvaluate(f, x[item]); y[item] = (h[item] > 0); block.CloseBlock(); InferenceEngine engine = new InferenceEngine(); SparseGP sgp = engine.Infer <SparseGP>(f); Vector alphaExpected = Vector.FromArray(new double[] { 0.573337393823702 }); Console.WriteLine("alpha = {0} should be {1}", sgp.Alpha, alphaExpected); double[] xTest = new double[] { -2, -1, 0.0 }; Vector[] xTestVec = Array.ConvertAll(xTest, v => Vector.Constant(1, v)); double[] yMeanTest = new double[] { 0.077592778583272, 0.347746707713812, 0.573337393823702 }; double[] yVarTest = new double[] { 0.986784459962251, 0.734558782611933, 0.278455962249970 }; for (int i = 0; i < xTestVec.Length; i++) { Gaussian pred = sgp.Marginal(xTestVec[i]); Gaussian predExpected = new Gaussian(yMeanTest[i], yVarTest[i]); Console.WriteLine("f({0}) = {1} should be {2}", xTest[i], pred, predExpected); Assert.True(predExpected.MaxDiff(pred) < 1e-4); } double evExpected = -2.463679892165236; double evActual = engine.Infer <Bernoulli>(evidence).LogOdds; Console.WriteLine("evidence = {0} should be {1}", evActual, evExpected); Assert.True(MMath.AbsDiff(evExpected, evActual, 1e-6) < 1e-4); }
public void BallCountingNoisy2() { // Variables describing the population int maxBalls = 8; Range ball = new Range(maxBalls).Named("ball"); Variable <int> numBalls = Variable.DiscreteUniform(maxBalls + 1).Named("numBalls"); VariableArray <bool> isBlue = Variable.Array <bool>(ball).Named("isBlue"); isBlue[ball] = Variable.Bernoulli(0.5).ForEach(ball); // Variables describing the observations Range draw = new Range(10).Named("draw"); using (Variable.ForEach(draw)) { Variable <int> ballIndex = Variable.DiscreteUniform(ball, numBalls).Named("ballIndex"); if (false) { using (Variable.Switch(ballIndex)) { Variable <bool> switchedColor = Variable.Bernoulli(0.2).Named("switchedColor"); using (Variable.If(switchedColor)) { Variable.ConstrainFalse(isBlue[ballIndex]); } using (Variable.IfNot(switchedColor)) { Variable.ConstrainTrue(isBlue[ballIndex]); } } } else { Variable <bool> switchedColor = Variable.Bernoulli(0.2).Named("switchedColor"); using (Variable.If(switchedColor)) { using (Variable.Switch(ballIndex)) Variable.ConstrainFalse(isBlue[ballIndex]); } using (Variable.IfNot(switchedColor)) { using (Variable.Switch(ballIndex)) Variable.ConstrainTrue(isBlue[ballIndex]); } } } // Inference queries about the program // ----------------------------------- InferenceEngine engine = new InferenceEngine(); Discrete numBallsActual = engine.Infer <Discrete>(numBalls); Console.WriteLine("numBalls = {0}", numBallsActual); Discrete numBallsExpected = new Discrete(0, 0.463, 0.2354, 0.1137, 0.06589, 0.04392, 0.0322, 0.02521, 0.02068); Assert.True(numBallsExpected.MaxDiff(numBallsActual) < 1e-4); }
/// <summary> /// Defines the variables and the ranges of CBCC. /// </summary> /// <param name="taskCount">The number of tasks.</param> /// <param name="labelCount">The number of labels.</param> protected override void DefineVariablesAndRanges(int taskCount, int labelCount) { WorkerCount = Variable.New <int>().Named("WorkerCount"); m = new Range(CommunityCount).Named("m"); n = new Range(taskCount).Named("n"); c = new Range(labelCount).Named("c"); k = new Range(WorkerCount).Named("k"); // The tasks for each worker WorkerTaskCount = Variable.Array <int>(k).Named("WorkerTaskCount"); kn = new Range(WorkerTaskCount[k]).Named("kn"); WorkerTaskIndex = Variable.Array(Variable.Array <int>(kn), k).Named("WorkerTaskIndex"); WorkerTaskIndex.SetValueRange(n); WorkerLabel = Variable.Array(Variable.Array <int>(kn), k).Named("WorkerLabel"); // The background probability vector BackgroundLabelProbPrior = Variable.New <Dirichlet>().Named("BackgroundLabelProbPrior"); BackgroundLabelProb = Variable <Vector> .Random(BackgroundLabelProbPrior).Named("BackgroundLabelProb"); BackgroundLabelProb.SetValueRange(c); // Community membership CommunityProbPrior = Variable.New <Dirichlet>().Named("CommunityProbPrior"); CommunityProb = Variable <Vector> .Random(CommunityProbPrior).Named("CommunityProb"); CommunityProb.SetValueRange(m); Community = Variable.Array <int>(k).Attrib(QueryTypes.Marginal).Attrib(QueryTypes.MarginalDividedByPrior).Named("Community"); CommunityConstraint = Variable.Array <Discrete>(k).Named("CommunityConstraint"); Community[k] = Variable.Discrete(CommunityProb).ForEach(k); Variable.ConstrainEqualRandom(Community[k], CommunityConstraint[k]); // Initialiser to break symmetry for community membership CommunityInit = Variable.Array <Discrete>(k).Named("CommunityInit"); Community[k].InitialiseTo(CommunityInit[k]); // Community parameters CommunityScoreMatrixPrior = Variable.Array(Variable.Array <VectorGaussian>(c), m).Named("CommunityScoreMatrixPrior"); CommunityScoreMatrix = Variable.Array(Variable.Array <Vector>(c), m).Named("CommunityScoreMatrix"); CommunityScoreMatrix[m][c] = Variable <Vector> .Random(CommunityScoreMatrixPrior[m][c]); CommunityConfusionMatrix = Variable.Array(Variable.Array <Vector>(c), m).Named("CommunityConfusionMatrix"); CommunityConfusionMatrix[m][c] = Variable.Softmax(CommunityScoreMatrix[m][c]); CommunityScoreMatrix.SetValueRange(c); // Parameters for each worker ScoreMatrix = Variable.Array(Variable.Array <Vector>(c), k).Attrib(QueryTypes.Marginal).Attrib(QueryTypes.MarginalDividedByPrior).Named("ScoreMatrix"); ScoreMatrixConstraint = Variable.Array(Variable.Array <VectorGaussian>(c), k).Named("ScoreMatrixConstraint"); WorkerConfusionMatrix = Variable.Array(Variable.Array <Vector>(c), k).Named("ConfusionMatrix"); // The unobserved 'true' label for each task TrueLabel = Variable.Array <int>(n).Attrib(QueryTypes.Marginal).Attrib(QueryTypes.MarginalDividedByPrior).Named("Truth"); TrueLabelConstraint = Variable.Array <Discrete>(n).Named("TruthConstraint"); TrueLabel[n] = Variable.Discrete(BackgroundLabelProb).ForEach(n); Variable.ConstrainEqualRandom(TrueLabel[n], TrueLabelConstraint[n]); // The labels given by the workers WorkerLabel = Variable.Array(Variable.Array <int>(kn), k).Named("WorkerLabel"); }
internal void BirdCounting3() { double noise = 0.2; int maxBirds = 8; Range numBirdRange = new Range(maxBirds + 1).Named("numBirdRange"); Variable <int> numBirds = Variable.DiscreteUniform(numBirdRange).Named("numBirds"); SwitchBlock block = Variable.Switch(numBirds); Range bird = new Range(maxBirds).Named("bird"); VariableArray <bool> isMale = Variable.Array <bool>(bird).Named("isMale"); isMale[bird] = Variable.Bernoulli(0.5).ForEach(bird); Variable <int> numObserved = Variable.New <int>().Named("numObserved"); Range observedBird = new Range(numObserved).Named("observedBird"); VariableArray <bool> observedMale = Variable.Array <bool>(observedBird).Named("observedMale"); //VariableArray<int> birdIndices = Variable.Array<int>(observedBird).Named("birdIndices"); using (Variable.ForEach(observedBird)) { //birdIndices[observedBird] = Variable.DiscreteUniform(numBirds); //Variable<int> birdIndex = birdIndices[observedBird]; Variable <int> birdIndex = Variable.DiscreteUniform(bird, numBirds).Named("birdIndex"); using (Variable.Switch(birdIndex)) { #if true //Variable.ConstrainEqual(observedMale[observedBird], isMale[birdIndex]); observedMale[observedBird] = (isMale[birdIndex] == Variable.Bernoulli(1 - noise)); #else using (Variable.If(isMale[birdIndex])) { observedMale[observedBird] = Variable.Bernoulli(0.8); } using (Variable.IfNot(isMale[birdIndex])) { observedMale[observedBird] = Variable.Bernoulli(0.2); } #endif } } block.CloseBlock(); InferenceEngine engine = new InferenceEngine(); for (int numObservedInt = 6; numObservedInt <= 10; numObservedInt++) { Console.WriteLine("numObserved = {0}", numObservedInt); // weird behavior with 1 different out of >=9 obs, no obs noise bool[] data = new bool[numObservedInt]; int numObservedMale = 0; for (int i = 0; i < data.Length; i++) { data[i] = (i < numObservedMale); } numObserved.ObservedValue = data.Length; observedMale.ObservedValue = data; //Console.WriteLine("birdIndices = {0}", engine.Infer(birdIndices)); Console.WriteLine("isMale = {0}", engine.Infer(isMale)); Console.WriteLine("numBirds = {0}", engine.Infer(numBirds)); Console.WriteLine(" exact = {0}", BallCountingExact(maxBirds, numObservedInt, numObservedMale, noise)); } }