public void TestMethod1() { // Person says 'there are _some_ nice people in the world' // Given the world has 4 people (very simple world) // _some_ implies not all -- but a literal listener // does not infer this implication. Uncertain <int> literaloutput = Implicature.LiteralListener(Implicature.Utterance.Some); var literalresult = new[] { 0.33, 0.33, 0.33 }; foreach (var item in literaloutput.Support().Zip(literalresult, Tuple.Create)) { Assert.IsTrue(ApproxEqual(item.Item1.Probability, item.Item2)); } // Here we frame the listener as someone that reasons // about a speaker's implication. In other words, // we infer that the person is implying that not all // people are nice Uncertain <int> inferredoutput = Implicature.Listener(Implicature.Utterance.Some); var inferredresult = new[] { 42, 0.42, 0.15 }; foreach (var item in literaloutput.Support().OrderBy(k => k.Value).Zip(literalresult, Tuple.Create)) { Assert.IsTrue(ApproxEqual(item.Item1.Probability, item.Item2)); } }
public void TestHMM2() { var comparer = new SequenceComparer <string>(); var states = new[] { "Healthy", "Fever" }; var emits = new[] { "normal", "cold", "dizzy" }; Uncertain <string>[] source = new[] { new Multinomial <string>(emits, new [] { 0.8, 0.1, 0.1 }), new Multinomial <string>(emits, new [] { 0.2, 0.7, 0.1 }), new Multinomial <string>(emits, new [] { 0.05, 0.05, 0.9 }), }; Uncertain <string[]> observations = source.USeq(3); var program = from obs in observations from result in HMM(obs) select result; var program1 = from obs in observations from result in HMM(obs).Inference(comparer) select result; var program2 = from obs in observations.Inference(comparer) from result in HMM(obs).Inference(comparer) select result; var output = program.Inference(comparer).Support().OrderByDescending(k => k.Probability).ToList(); var output1 = program1.Inference(comparer).Support().OrderByDescending(k => k.Probability).ToList(); var output2 = program2.Inference(comparer).Support().OrderByDescending(k => k.Probability).ToList(); var output3 = HMM2(observations).Inference(comparer).Support().OrderByDescending(k => k.Probability).ToList(); var timer = new System.Diagnostics.Stopwatch(); timer.Start(); var sampled = program.SampledInference(10000, comparer).Support().OrderByDescending(k => k.Probability).ToList(); timer.Stop(); System.Diagnostics.Debug.WriteLine(timer.Elapsed); timer.Reset(); timer.Start(); var sampled1 = program1.SampledInference(10000, comparer).Support().OrderByDescending(k => k.Probability).ToList(); timer.Stop(); System.Diagnostics.Debug.WriteLine(timer.Elapsed); timer.Reset(); timer.Start(); var sampled2 = program2.SampledInference(10000, comparer).Support().OrderByDescending(k => k.Probability).ToList(); timer.Stop(); System.Diagnostics.Debug.WriteLine(timer.Elapsed); Assert.IsTrue(comparer.Equals(output[0].Value, sampled[0].Value)); Assert.IsTrue(Math.Abs(output[0].Probability - sampled[0].Probability) < 0.1); Assert.IsTrue(comparer.Equals(output[0].Value, output3[0].Value)); Assert.IsTrue(Math.Abs(output[0].Probability - output3[0].Probability) < 0.1); int x = 10; }
public static Uncertain <T> SampledInference <T>(this Uncertain <T> source, int samplesize, IEqualityComparer <T> comparer = null) { var sampler = Sampler.Create(source); // cache data var data = sampler.Take(samplesize).ToList(); return(RunInference(data, comparer)); }
public void Constant_Sample() { // arrange Uncertain <double> X = 5.0; var sampler = Sampler.Create(X); // act var S = sampler.First(); // assert Assert.AreEqual(S.Value, 5.0); }
private static IEnumerable <Uncertain <int> > LiftedFunc(IEnumerable <Uncertain <int> > unput) { Uncertain <int> ustate = 0; foreach (var u in unput) { ustate = from s in ustate from i in u let f = Func(s, i) select f; yield return(ustate); } }
public void Base_Equality() { Uncertain <double> X = 5.0; if ((X == null).Pr()) { Assert.Fail(); } if ((null == X).Pr()) { Assert.Fail(); } }
public void TestDan() { var r = new RandomMath(); int N = 50; // Generate an array of independent estimates of whether a signal // is high or low Uncertain <bool>[] data = (from i in Enumerable.Range(0, N) let noise = r.NextGaussian(0, 0.01) let vad = i > 15 && i < 30 ? 0.9 : 0.1 let param = Math.Abs(vad + noise) let f = new Bernoulli(param > 1 ? 1 : param) select f).ToArray(); // history operator we chatted about Uncertain <bool[]> history = data.USeq(N); // Inference computes a weighted bool[] object: effectively a histogram // The call to SampledInference needs to know (i) how many samples to take and how to compare bool[] Uncertain <bool[]> posterior = history.SampledInference(10000, new SequenceComparer <bool>()); // now inspect by materializing a list List <Weighted <bool[]> > top5 = posterior .Support() // enumerate the histogram .OrderByDescending(k => k.Probability) // sorted by probability .Take(5) // just top 5 .ToList(); // produce list //var program = from bools in history // let sum = bools.Select(Convert.ToInt32).Sum() // from prior in new Gaussian(20, 0.01) // where sum == (int) prior // select bools; //Uncertain<bool[]> posterior1 = program.SampledInference(10000, new BoolArrayEqualityComparer()); Func <bool[], bool[]> Intervalize = _ => _; var program = from bools in data.USeq(N) select Intervalize(bools); // now inspect by materializing a list List <Weighted <bool[]> > top51 = posterior .Support() // enumerate the histogram .OrderByDescending(k => k.Probability) // sorted by probability .Take(5) // just top 5 .ToList(); // produce list // set breakpoint int x = 10; }
public void Base_Implicit() { // arrange Uncertain <double> X = 5.0; Uncertain <double> Y = 6.0; // act Uncertain <double> Z = from x in X from y in Y select x + y; // Y is implicitly cast // assert MeanAndConfidenceInterval m2 = Z.ExpectedValueWithConfidence(); Assert.IsTrue(m2.Mean > 11.0 - eps && m2.Mean < 11.0 + eps); }
public void Constant_BNN_Sample() { // arrange Uncertain <double> X = new Constant <double>(5.0); Uncertain <double> Y = new Constant <double>(6.0); Uncertain <double> Z = from x in X from y in Y select x + y; var sampler = Sampler.Create(Z); // act var S = sampler.First(); // assert Assert.AreEqual(S.Value, 11.0); }
public void Base_Implicit() { // arrange Uncertain <double> X = 5.0; Uncertain <double> Y = 6.0; // act Uncertain <double> Z = from x in X from y in Y select x + y; var sampler = Sampler.Create(Z); var s = sampler.First(); // assert Assert.AreEqual(s.Value, 11.0); }
public void Base_Binomial() { Uncertain <int> binomial = from a in new Flip(0.5) from b in new Flip(0.5) from c in new Flip(0.5) let path = Convert.ToInt32(a) + Convert.ToInt32(b) + Convert.ToInt32(c) select path; var dist = binomial.Inference().Support().OrderBy(k => k.Value).Select(k => k.Probability).ToList(); var items = new[] { 0.125, 0.375, 0.375, 0.125 }; for (int i = 0; i < items.Length; i++) { Assert.IsTrue(items[i] == dist[i]); } }
public void Gaussian_BNN_Sample() { // arrange Uncertain <double> X = new Gaussian(1.0, 1.0); Uncertain <double> Y = new Gaussian(4.0, 1.0); Uncertain <double> Z = from x in X from y in Y select x + y; var sampler = Sampler.Create(Z); foreach (var s in sampler.Take(100)) { // assert Assert.IsTrue(s.Value >= -3 && s.Value <= 13.0); } }
public void Uniform_BNN_Sample() { // arrange Uncertain <double> X = new Uniform <double>(1.0, 3.0); Uncertain <double> Y = new Uniform <double>(4.0, 5.0); Uncertain <double> Z = from x in X from y in Y select x + y; var sampler = Sampler.Create(Z); // act foreach (var p in sampler.Take(100)) { // act double s = p.Value; // assert Assert.IsTrue(s >= 1.0 && s <= 8.0); } }
public static Uncertain <T[]> MarkovModel <T>(this Uncertain <T[]> observations, Uncertain <T> init, Func <T, Uncertain <T> > transition, Func <T, Uncertain <T> > emission) where T : IEquatable <T> { Func <IEnumerable <T>, Uncertain <T[]> > RunOne = obs => { var initlst = from prior in init select FunctionalList.Cons(prior, FunctionalList.Empty <T>()); return(obs.Aggregate <T, Uncertain <FunctionalList <T> >, Uncertain <T[]> >( initlst, (list, obs_i) => { var program = from head in list let state = head.Head from next in transition(state) from emit in emission(next) where obs_i.Equals(emit) select FunctionalList.Cons(next, head); return program; }, uncertainlst => { return from sample in uncertainlst select sample.Reverse().Skip(1) /* skip prior */.ToArray(); })); }; return(from obs in observations from result in RunOne(obs) select result); //Uncertain < T[] > output = observations.Aggregate<Uncertain<T>, Uncertain<FunctionalList<T>>, Uncertain<T[]>>( // FunctionalList.Empty<T>(), // (i, j) => // { // return from lst in i // from sample in j // select FunctionalList.Cons(sample, lst); // }, // uncertainlst => // { // return from sample in uncertainlst // select sample.Reverse().ToArray(); // }); //return output; }
public static Uncertain <T[]> USeq <T>(this IEnumerable <Uncertain <T> > source, int num) { Uncertain <T[]> output = source.Take(num).Aggregate <Uncertain <T>, Uncertain <FunctionalList <T> >, Uncertain <T[]> >( FunctionalList.Empty <T>(), (i, j) => { return(from lst in i from sample in j select FunctionalList.Cons(sample, lst)); }, uncertainlst => { return(from sample in uncertainlst select sample.Reverse().ToArray()); }); return(output); }
public static Uncertain <R[]> USeq2 <T, R>(this IEnumerable <Uncertain <T> > source, Func <T[], R[]> selector) { Uncertain <R[]> output = source.Aggregate <Uncertain <T>, Uncertain <FunctionalList <T> >, Uncertain <R[]> >( FunctionalList.Empty <T>(), (i, j) => { return(from lst in i from sample in j select FunctionalList.Cons(sample, lst)); }, uncertainlst => { return(from sample in uncertainlst let vec = sample.Reverse().ToArray() select selector(vec)); }); return(output); }
public void Base_Sample() { Uncertain <GeoLocation> roads = null; Uncertain <GeoLocation> gps = null; Func <GeoLocation, GeoLocation, double> Likelihood = (a, b) => 1.0; var p = from pos in gps from road in roads let prob = Likelihood(pos, road) select new Weighted <GeoLocation>(pos, prob); // arrange Uncertain <double> X = 5.0; // act var sampler = Sampler.Create(X); var S = sampler.First(); // assert Assert.AreEqual(S.Value, 5.0); }
static Uncertain <string[]> HMM2(Uncertain <string[]> observations) { var states = new[] { "Healthy", "Fever" }; var emits = new[] { "normal", "cold", "dizzy" }; var start_probability = new Multinomial <string>(states, new[] { 0.6, 0.4 }); Func <string, Multinomial <string> > transition_probability = state => { if (state == "Healthy") { return(new Multinomial <string>(states, new[] { 0.7, 0.3 })); } if (state == "Fever") { return(new Multinomial <string>(states, new[] { 0.4, 0.6 })); } throw new Exception("Unknown state"); }; Func <string, Multinomial <string> > emission_probability = state => { if (state == "Healthy") { return(new Multinomial <string>(emits, new[] { 0.5, 0.4, 0.1 })); } if (state == "Fever") { return(new Multinomial <string>(emits, new[] { 0.1, 0.3, 0.6 })); } throw new Exception("Unknown state"); }; return(observations.MarkovModel <string>(start_probability, transition_probability, emission_probability)); }
public void Gaussian_BNN_Mean() { // arrange Uncertain <double> X = new Gaussian(1.0, 1.0); Uncertain <double> Y = new Gaussian(4.0, 2.0); Uncertain <double> Z = from x in X from y in Y select x + y; double Sum = 0.0; // act var sampler = Sampler.Create(Z); foreach (var s in sampler.Take(100)) { Sum += s.Value; } Sum /= 100.0; // assert // Z is known to be Gaussian(5.0, sqrt(5)) // If everything is working, this has about a 0.003% chance of a false positive // (99.9997% confidence interval with n=100, sigma=sqrt(5) is +/- 0.89) Assert.IsTrue(Sum >= 4.11 && Sum <= 5.89); }
public static Uncertain <T> Inference <T>(this Uncertain <T> source, IEqualityComparer <T> comparer = null) { return(RunInference(source.Support().ToList(), comparer)); }
public static Uncertain <T> Where <T>(this Uncertain <T> source, Predicate <T> predicate) { return(new Where <T>(source, predicate)); }