public void ImpossibleBranchTest1()
{
Variable <string> str = Variable.New <string>().Named("str");
Variable <bool> selector = Variable.Bernoulli(0.5).Named("selector");
using (Variable.If(selector))
{
var str1 = Variable.StringUniform();
var str2 = Variable.StringUniform();
str.SetTo(str1 + " " + str2);
}
using (Variable.IfNot(selector))
{
var str1 = Variable.StringUniform();
var str2 = Variable.StringUniform();
str.SetTo(str1 + "-" + str2);
}
str.ObservedValue = "ab-c";
var engine = new InferenceEngine();
var selectorPosterior = engine.Infer <Bernoulli>(selector);
Assert.Equal(1.0, selectorPosterior.GetProbFalse());
}
public void ImpossibleBranchTest3()
{
Variable <string> str1 = Variable.StringLower().Named("str1");
Variable <string> str2 = Variable.StringLower().Named("str2");
Variable <string> text = Variable.New <string>().Named("text");
Variable <int> selector = Variable.DiscreteUniform(2).Named("selector");
using (Variable.Case(selector, 0))
{
text.SetTo(str1 + Variable.Constant(" ") + str2);
}
using (Variable.Case(selector, 1))
{
text.SetTo(str1);
}
text.ObservedValue = "abc";
var engine = new InferenceEngine();
var selectorPosterior = engine.Infer <Discrete>(selector);
var str1Posterior = engine.Infer <StringDistribution>(str1);
var str2Posterior = engine.Infer <StringDistribution>(str2);
Assert.True(selectorPosterior.IsPointMass && selectorPosterior.Point == 1);
Assert.True(str1Posterior.IsPointMass && str1Posterior.Point == "abc");
Assert.Equal(StringDistribution.Lower(), str2Posterior);
}
public void GatedModelObservedOutputTest2()
{
Variable <bool> selector = Variable.Bernoulli(0.5);
Variable <string> concat = Variable.New <string>();
using (Variable.If(selector))
{
Variable <string> arg1 = Variable.StringLower();
Variable <string> arg2 = Variable.Random(StringDistribution.OneOf("cd", "d"));
concat.SetTo(arg1 + arg2);
}
using (Variable.IfNot(selector))
{
Variable <string> arg1 = "ab";
Variable <string> arg2 = Variable.Random(StringDistribution.OneOf("cd", "d", "e"));
concat.SetTo(arg1 + arg2);
}
concat.ObservedValue = "abcd";
var engine = new InferenceEngine();
var selectorPosterior = engine.Infer <Bernoulli>(selector);
Assert.Equal(0.0, selectorPosterior.GetProbTrue());
}
public void GatedModelUncertainOutputTest()
{
Variable <bool> selector = Variable.Bernoulli(0.5);
Variable <string> concat = Variable.New <string>();
using (Variable.If(selector))
{
Variable <string> arg1 = Variable.Random(StringDistribution.OneOf("ab", "abc"));
Variable <string> arg2 = Variable.Random(StringDistribution.OneOf("cd", "d"));
concat.SetTo(arg1 + arg2);
}
using (Variable.IfNot(selector))
{
Variable <string> arg1 = "ab";
Variable <string> arg2 = Variable.Random(StringDistribution.OneOf("cd", "d", "e"));
concat.SetTo(arg1 + arg2);
}
Variable.ConstrainEqualRandom(concat, StringDistribution.OneOf("abcd", "abd"));
var engine = new InferenceEngine();
var selectorPosterior = engine.Infer <Bernoulli>(selector);
Assert.Equal(9.0 / 17.0, selectorPosterior.GetProbTrue());
}
public void Valmir1()
{
var t = Variable.Bernoulli(.6);
Variable <bool> c = Variable.New <bool>();
using (Variable.If(t))
c.SetTo(Variable.Bernoulli(.3));
using (Variable.IfNot(t))
c.SetTo(Variable.Bernoulli(.8));
c.ObservedValue = true;
var ie = new InferenceEngine(new ExpectationPropagation());
Console.WriteLine("P(T|C)=" + ie.Infer(t));
}
/// <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 static void TestMixtureOf2Gaussians()
{
int mixtureSize = 2;
Range r = new Range(mixtureSize);
Variable <int> comp = Variable <int> .Discrete(r, new double[] { 0.5, 0.5 });
Variable <double> x = Variable <double> .New <double>().Named("x");
double[] means = new double[] { 1, 2 };
VariableArray <double> Means = Variable.Observed(means, r);
using (Variable.Switch(comp)){
x.SetTo(Variable.GaussianFromMeanAndPrecision(Means[comp], 1));
}
x.AddAttribute(new TraceMessages());
InferenceEngine engine = new InferenceEngine();
engine.OptimiseForVariables = new[] { x };
engine.Compiler.IncludeDebugInformation = true;
engine.Algorithm = new GibbsSampling();
engine.ModelName = "MyMixtureOf2Gaussians";
engine.ShowTimings = true;
// engine.ShowMsl = true;
// InferenceEngine.ShowFactorManager(true);
// this gives a Gaussian with mean 1.5
Console.WriteLine("inferred x = " + engine.Infer(x));
// How to get a Gaussian mixture ????
// => put prior on means and infer the the distribution on means instead
}
/// <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
//---------------------------------------------
var W = new Range(SizeVocab).Named("W");
var 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;
}
/// <summary>
/// Get an expression that evaluates to true when this loop counter is increasing in the currently executing loop.
/// </summary>
/// <returns></returns>
public Variable <bool> IsIncreasing()
{
Variable <bool> v = new Variable <bool>();
v.SetTo(new Func <int, bool>(Factors.InferNet.IsIncreasing).Method, this);
v.Inline = true;
return(v);
}
public Variable <double> GetCatchedMouse()
{
Variable <double> CatchedMouse = Variable.New <double>();
Variable <double> CatchableMouse = Cat.GetCatchableMouse();
Variable <double> MousePopulation = Mouse.GetPopulation();
Variable <bool> condition = CatchableMouse > MousePopulation;
using (Variable.If(condition))
{
CatchedMouse.SetTo(Mouse.GetPopulation());
}
using (Variable.IfNot(condition))
{
CatchedMouse.SetTo(CatchableMouse);
}
return(CatchedMouse);
}
public void CaseExampleEnum()
{
Variable <Coin> c = Variable.EnumDiscrete <Coin>(new double[] { 0.5, 0.5 });
Variable <double> x = Variable.New <double>();
Variable <int> cint = Variable.EnumToInt(c);
using (Variable.Case(cint, 0))
{
x.SetTo(Variable.GaussianFromMeanAndVariance(1, 1));
}
using (Variable.Case(cint, 1))
{
x.SetTo(Variable.GaussianFromMeanAndVariance(2, 1));
}
InferenceEngine engine = new InferenceEngine();
Gaussian expected = new Gaussian(1.5, 1.25);
Gaussian actual = engine.Infer <Gaussian>(x);
Console.WriteLine("x = {0} (should be {1})", actual, expected);
Assert.True(expected.MaxDiff(actual) < 1e-10);
}
public static void Run()
{
Variable <bool> knowsCsharp = Variable.Bernoulli(0.5).Attrib(new TraceMessages());
Variable <bool> knowsSql = Variable.Bernoulli(0.5).Attrib(new TraceMessages());
Variable <bool> knowsBoth = knowsCsharp & knowsSql;
Variable <bool> firstQuestion = Variable.New <bool>();
using (Variable.If(knowsCsharp)) firstQuestion.SetTo(Variable.Bernoulli(0.9));
using (Variable.IfNot(knowsCsharp)) firstQuestion.SetTo(Variable.Bernoulli(0.2));
Variable <bool> secondQuestion = Variable.New <bool>();
using (Variable.If(knowsSql)) secondQuestion.SetTo(Variable.Bernoulli(0.9));
using (Variable.IfNot(knowsSql)) secondQuestion.SetTo(Variable.Bernoulli(0.2));
Variable <bool> thirdQuestion = Variable.New <bool>();
using (Variable.If(knowsBoth)) thirdQuestion.SetTo(Variable.Bernoulli(0.9));
using (Variable.IfNot(knowsBoth)) thirdQuestion.SetTo(Variable.Bernoulli(0.2));
Variable <bool> fourthQuestion = Variable.New <bool>();
using (Variable.If(knowsBoth)) fourthQuestion.SetTo(Variable.Bernoulli(0.9));
using (Variable.IfNot(knowsBoth)) fourthQuestion.SetTo(Variable.Bernoulli(0.2));
// Observations and inference
firstQuestion.ObservedValue = true;
secondQuestion.ObservedValue = false;
thirdQuestion.ObservedValue = false;
fourthQuestion.ObservedValue = false;
InferenceEngine ie = new InferenceEngine();
ie.ShowTimings = true;
ie.ShowProgress = true;
ie.ShowSchedule = true;
ie.ShowFactorGraph = true;
Console.WriteLine("P(csharp)=" + ie.Infer(knowsCsharp));
Console.WriteLine("P(sql)=" + ie.Infer(knowsSql));
}
public override void CreateModel()
{
base.CreateModel();
Variable <int> componentIndex = Variable.Discrete(mixingCoefficients);
tomorrowsTime = Variable.New <double>();
using (Variable.Switch(componentIndex))
{
tomorrowsTime.SetTo(Variable.GaussianFromMeanAndPrecision
(averageTime[componentIndex], trafficNoise[componentIndex]));
}
}
protected override void ConstructModel()
{
base.ConstructModel();
if (ConditionalsHair == null)
{
throw new InvalidOperationException($"{nameof(ConditionalsHair)} cannot be null.");
}
hair = Variable.New <bool>().Named("hair=true");
using (Variable.If(murderer))
{
hair.SetTo(Variable.Bernoulli(ConditionalsHair.HairGivenAuburn));
}
using (Variable.IfNot(murderer))
{
hair.SetTo(Variable.Bernoulli(ConditionalsHair.HairGivenGrey));
}
hair.ObservedValue = HairObserved;
}
public void SimpleGatedModelTest1()
{
const double SelectorProbabilityTrue = 0.3;
Variable <string> str = Variable.New <string>().Named("str");
Variable <bool> selector = Variable.Bernoulli(SelectorProbabilityTrue).Named("selector");
using (Variable.If(selector))
{
str.SetTo("a");
}
using (Variable.IfNot(selector))
{
str.SetTo("b");
}
var engine = new InferenceEngine();
var strPosterior = engine.Infer <StringDistribution>(str);
StringInferenceTestUtilities.TestProbability(strPosterior, SelectorProbabilityTrue, "a");
StringInferenceTestUtilities.TestProbability(strPosterior, 1 - SelectorProbabilityTrue, "b");
}
protected override void ConstructModel()
{
base.ConstructModel();
if (ConditionalsWeapon == null)
{
throw new InvalidOperationException($"{nameof(ConditionalsWeapon)} cannot be null.");
}
weapon = Variable.New <int>().Named("weapon=revolver");
weapon.SetValueRange(new Range(2));
using (Variable.If(murderer))
{
weapon.SetTo(Variable.Discrete(new[] { ConditionalsWeapon.RevolverGivenAuburn, ConditionalsWeapon.DaggerGivenAuburn }));
}
using (Variable.IfNot(murderer))
{
weapon.SetTo(Variable.Discrete(new[] { ConditionalsWeapon.RevolverGivenGrey, ConditionalsWeapon.DaggerGivenGrey }));
}
weapon.ObservedValue = WeaponObserved == Weapon.Revolver ? 0 : 1;
}
public void ImpossibleBranchTest2()
{
Variable <string> subStr = Variable.New <string>().Named("subStr");
Variable <int> selector = Variable.DiscreteUniform(2).Named("selector");
using (Variable.Case(selector, 0))
{
var str = Variable.StringUniform();
subStr.SetTo(Variable.Substring(str, 2, 2));
}
using (Variable.Case(selector, 1))
{
var str = Variable.StringUniform();
subStr.SetTo(Variable.Substring(str, 2, 3));
}
subStr.ObservedValue = "ab";
var engine = new InferenceEngine();
var selectorPosterior = engine.Infer <Discrete>(selector);
Assert.Equal(1.0, selectorPosterior[0]);
}
public void GatedModelUncertainOutputTest()
{
Variable <bool> selector = Variable.Bernoulli(0.5);
Variable <string> substr = Variable.New <string>();
using (Variable.If(selector))
{
Variable <string> str = Variable.Random(StringDistribution.OneOf("bcad", "bacd", "bca"));
substr.SetTo(Variable.Substring(str, 0, 2));
}
using (Variable.IfNot(selector))
{
Variable <string> str = Variable.Random(StringDistribution.OneOf("dbc", "abdd", "a"));
substr.SetTo(Variable.Substring(str, 1, 2));
}
Variable.ConstrainEqualRandom(substr, StringDistribution.OneOf("bc", "ba"));
var engine = new InferenceEngine();
var selectorPosterior = engine.Infer <Bernoulli>(selector);
Assert.Equal(2.0 / 3.0, selectorPosterior.GetProbTrue(), LogProbEps);
}
public void GatedModelObservedOutputTest2()
{
Variable <bool> selector = Variable.Bernoulli(0.5);
Variable <string> substr = Variable.New <string>();
using (Variable.If(selector))
{
Variable <string> str = Variable.Random(StringDistribution.OneOf("dbc", "abcd", "abcc"));
substr.SetTo(Variable.Substring(str, 1, 2));
}
using (Variable.IfNot(selector))
{
Variable <string> str = Variable.StringLower();
substr.SetTo(Variable.Substring(str, 0, 2));
}
substr.ObservedValue = "bc";
var engine = new InferenceEngine();
var selectorPosterior = engine.Infer <Bernoulli>(selector);
Assert.Equal(1.0 / (1.0 + (1.0 / (26 * 26))), selectorPosterior.GetProbTrue(), LogProbEps);
}
/// <summary>
/// Initializes a new instance of the <see cref="TwoPlayerWithDraws" /> class.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <param name="showFactorGraph">if set to <c>true</c> [show factor graph].</param>
public TwoPlayerWithDraws(IModelParameters parameters, bool showFactorGraph = false) : base(parameters)
{
var performanceVariance = Variable.Observed(this.Parameters.PerformanceVariance).Named("performanceVariance");
this.drawMargin = Variable.New <double>().Named("drawMargin");
this.drawMarginPrior = Variable.New <Gaussian>().Named("drawMarginPrior");
this.drawMargin.SetTo(Variable <double> .Random(this.drawMarginPrior));
Variable.ConstrainTrue(this.drawMargin > 0);
this.skill1Prior = Variable.New <Gaussian>().Named("JSkillPrior").Attrib(new DoNotInfer());
this.skill2Prior = Variable.New <Gaussian>().Named("FSkillPrior").Attrib(new DoNotInfer());
this.player1skill = Variable.New <double>().Named("JSkill");
this.player2skill = Variable.New <double>().Named("FSkill");
player1skill.SetTo(Variable.Random <double, Gaussian>(skill1Prior));
player2skill.SetTo(Variable.Random <double, Gaussian>(skill2Prior));
var player1Performance = Variable.GaussianFromMeanAndVariance(player1skill, performanceVariance).Named("JPerf");
var player2Performance = Variable.GaussianFromMeanAndVariance(player2skill, performanceVariance).Named("FPerf");
var diff = (player1Performance - player2Performance).Named("diff");
this.outcome = Variable.DiscreteUniform(3).Named("outcome");
// The WinLoseDraw factor implemented using a constraint that's why it looks different in the factor graph viewer comparing to the book.
using (Variable.Case(this.outcome, 0))
{
// player 1 wins
Variable.ConstrainTrue(diff > this.drawMargin);
}
using (Variable.Case(this.outcome, 1))
{
// draw
Variable.ConstrainBetween(diff, -this.drawMargin, this.drawMargin);
}
using (Variable.Case(this.outcome, 2))
{
// player 2 wins
Variable.ConstrainTrue(diff < -this.drawMargin);
}
this.engine = Utils.GetDefaultEngine(showFactorGraph);
}
/// <summary>
/// Initializes a new instance of the <see cref="TwoPlayer" /> class.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <param name="showFactorGraph">if set to <c>true</c> [show factor graph].</param>
public TwoPlayer(IModelParameters parameters, bool showFactorGraph = false) : base(parameters)
{
var performanceVariance = Variable.Observed(this.Parameters.PerformanceVariance).Named("performanceVariance");
this.skill1Prior = Variable.New <Gaussian>().Named("JSkillPrior").Attrib(new DoNotInfer());
this.skill2Prior = Variable.New <Gaussian>().Named("FSkillPrior").Attrib(new DoNotInfer());
this.player1skill = Variable.New <double>().Named("JSkill");
this.player2skill = Variable.New <double>().Named("FSkill");
player1skill.SetTo(Variable.Random <double, Gaussian>(skill1Prior));
player2skill.SetTo(Variable.Random <double, Gaussian>(skill2Prior));
var player1Performance = Variable.GaussianFromMeanAndVariance(player1skill, performanceVariance).Named("JPerf");
var player2Performance = Variable.GaussianFromMeanAndVariance(player2skill, performanceVariance).Named("FPerf");
this.outcome = (player1Performance > player2Performance).Named("JWins");
this.engine = Utils.GetDefaultEngine(showFactorGraph);
}
private string InferGraph(double cloudyProb,
double sprinklerCloudyTProb, double sprinklerCloudyFProb,
double rainCloudyTProb, double rainCloudyFProb,
double wetGrassSprinklerTRainT, double wetGrassSprinklerTRainF,
double wetGrassSprinklerFRainT, double wetGrassSprinklerFRainF
)
{
Stopwatch stopwatch = new Stopwatch();
try
{
stopwatch.Start();
Variable <bool> cloudy = Variable.Bernoulli(cloudyProb).Named("Cloudy");
Variable <bool> sprinkler = Variable.New <bool>().Named("Sprinkler");
using (Variable.If(cloudy)) sprinkler.SetTo(Variable.Bernoulli(sprinklerCloudyTProb));
using (Variable.IfNot(cloudy)) sprinkler.SetTo(Variable.Bernoulli(sprinklerCloudyFProb));
Variable <bool> rain = Variable.New <bool>().Named("Rain");
using (Variable.If(cloudy)) rain.SetTo(Variable.Bernoulli(rainCloudyTProb));
using (Variable.IfNot(cloudy)) rain.SetTo(Variable.Bernoulli(rainCloudyFProb));
Variable <bool> wetGrass = Variable.New <bool>().Named("WetGrass");
using (Variable.If(sprinkler))
{
using (Variable.If(rain)) wetGrass.SetTo(Variable.Bernoulli(wetGrassSprinklerTRainT));
using (Variable.IfNot(rain)) wetGrass.SetTo(Variable.Bernoulli(wetGrassSprinklerTRainF));
}
using (Variable.IfNot(sprinkler))
{
using (Variable.If(rain)) wetGrass.SetTo(Variable.Bernoulli(wetGrassSprinklerFRainT));
using (Variable.IfNot(rain)) wetGrass.SetTo(Variable.Bernoulli(wetGrassSprinklerFRainF));
}
string rFormat = "Time= {0}" + Environment.NewLine
+ "P(R | W)= {1}" + Environment.NewLine
+ "P(S | W)= {2}" + Environment.NewLine
+ "P(R | W, ~C)= {3}" + Environment.NewLine
+ "P(S | W, ~C)= {4}" + Environment.NewLine
+ "P(R | W, S)={5}" + Environment.NewLine
+ "P(R | W, S, ~C)={6}";
wetGrass.ObservedValue = true;;
InferenceEngine ie = new InferenceEngine();
ie.ShowProgress = true;
ie.ShowTimings = true;
ie.ShowWarnings = true;
ie.ShowFactorGraph = ShowFactorGraphCheckbox.Checked;
ie.ShowSchedule = ShowScheduleCheckbox.Checked;
var p1 = (MicrosoftResearch.Infer.Distributions.Bernoulli)ie.Infer(rain);
var p2 = (MicrosoftResearch.Infer.Distributions.Bernoulli)ie.Infer(sprinkler);
cloudy.ObservedValue = false;
var p3 = (MicrosoftResearch.Infer.Distributions.Bernoulli)ie.Infer(rain);
var p4 = (MicrosoftResearch.Infer.Distributions.Bernoulli)ie.Infer(sprinkler);
cloudy.ClearObservedValue();
sprinkler.ObservedValue = true;
var p5 = (MicrosoftResearch.Infer.Distributions.Bernoulli)ie.Infer(rain);
cloudy.ObservedValue = false;
var p6 = (MicrosoftResearch.Infer.Distributions.Bernoulli)ie.Infer(rain);
string formatString = "0.000";
stopwatch.Stop();
return(string.Format(rFormat, stopwatch.ElapsedMilliseconds + " ms",
p1.GetProbTrue().ToString(formatString),
p2.GetProbTrue().ToString(formatString),
p3.GetProbTrue().ToString(formatString),
p4.GetProbTrue().ToString(formatString),
p5.GetProbTrue().ToString(formatString),
p6.GetProbTrue().ToString(formatString)
));
}
catch (Exception ex)
{
return(ex.Message);
}
}
public override void CreateModel()
{
base.CreateModel();
Variable<int> componentIndex = Variable.Discrete(MixingCoefficients);
TomorrowsTime = Variable.New<double>();
using (Variable.Switch(componentIndex))
{
TomorrowsTime.SetTo(
Variable.GaussianFromMeanAndPrecision(
AverageTime[componentIndex],
TrafficNoise[componentIndex]));
}
}
static void Main(string[] args)
{
// csharp skill prior
var csharpSkill = Variable.Bernoulli(0.5).Named("csharpSkill");
//csharp isCorrect p(isCorrect|csharp)
//0 0 = 0.8
//0 1 = 0.2
//1 0 = 0.1
//1 1 = 0.9
Variable <bool> isCorrect1 = Variable.New <bool>();
// add noise factor for csharp skill
using (Variable.If(csharpSkill))
{
isCorrect1.SetTo(Variable.Bernoulli(0.9));
}
using (Variable.IfNot(csharpSkill))
{
isCorrect1.SetTo(Variable.Bernoulli(0.2));
}
// sql skill prior
var sqlSkill = Variable.Bernoulli(0.5).Named("sqlSkill");
Variable <bool> isCorrect2 = Variable.New <bool>();
// add noise factor for sql skill
using (Variable.If(sqlSkill))
{
isCorrect2.SetTo(Variable.Bernoulli(0.9));
}
using (Variable.IfNot(sqlSkill))
{
isCorrect2.SetTo(Variable.Bernoulli(0.2));
}
//csharp sql hasSkills p(hasSkills|csharp, sql)
//0 0 0 = 1
//0 0 1 = 0
//0 1 0 = 1
//0 1 1 = 0
//1 0 0 = 1
//1 0 1 = 0
//1 1 0 = 0
//1 1 1 = 1
// and factor for csharp skill and sql skill
var hasSkills = ((csharpSkill & sqlSkill) == Variable.Bernoulli(1)).Named("hasSkills");
Variable <bool> isCorrect3 = Variable.New <bool>();
// add noise factor for has skills
using (Variable.If(hasSkills))
{
isCorrect3.SetTo(Variable.Bernoulli(0.9));
}
using (Variable.IfNot(hasSkills))
{
isCorrect3.SetTo(Variable.Bernoulli(0.2));
}
var engine = new InferenceEngine();
engine.Algorithm = new ExpectationPropagation();
isCorrect1.ObservedValue = true;
isCorrect2.ObservedValue = false;
isCorrect3.ObservedValue = false;
Console.WriteLine(engine.Infer(csharpSkill));
Console.WriteLine(engine.Infer(sqlSkill));
}
static void Main(string[] args)
{
Trace.Listeners.Add(new TextWriterTraceListener(Console.Out));
Trace.AutoFlush = true;
// csharp skill prior
var csharpSkill = Variable.Bernoulli(0.5).Named("csharpSkill");
//csharp isCorrect p(isCorrect|csharp)
//0 0 = 0.8
//0 1 = 0.2
//1 0 = 0.1
//1 1 = 0.9
Variable <bool> isCorrect1 = Variable.New <bool>();
// add noise factor for csharp skill
using (Variable.If(csharpSkill))
{
isCorrect1.SetTo(Variable.Bernoulli(0.9));
}
using (Variable.IfNot(csharpSkill))
{
isCorrect1.SetTo(Variable.Bernoulli(0.2));
}
// sql skill prior
var sqlSkill = Variable.Bernoulli(0.5).Named("sqlSkill");
Variable <bool> isCorrect2 = Variable.New <bool>();
// add noise factor for sql skill
using (Variable.If(sqlSkill))
{
isCorrect2.SetTo(Variable.Bernoulli(0.9));
}
using (Variable.IfNot(sqlSkill))
{
isCorrect2.SetTo(Variable.Bernoulli(0.2));
}
//csharp sql hasSkills p(hasSkills|csharp, sql)
//0 0 0 = 1
//0 0 1 = 0
//0 1 0 = 1
//0 1 1 = 0
//1 0 0 = 1
//1 0 1 = 0
//1 1 0 = 0
//1 1 1 = 1
// and factor for csharp skill and sql skill
var hasSkills3 = ((csharpSkill & sqlSkill) == Variable.Bernoulli(1)).Named("hasSkills3");
Variable <bool> isCorrect3 = Variable.New <bool>();
// add noise factor for has skills
using (Variable.If(hasSkills3))
{
isCorrect3.SetTo(Variable.Bernoulli(0.9));
}
using (Variable.IfNot(hasSkills3))
{
isCorrect3.SetTo(Variable.Bernoulli(0.2));
}
// and factor for csharp skill and sql skill
var hasSkills4 = ((csharpSkill & sqlSkill) == Variable.Bernoulli(1)).Named("hasSkills4");
Variable <bool> isCorrect4 = Variable.New <bool>();
// add noise factor for has skills
using (Variable.If(hasSkills4))
{
isCorrect4.SetTo(Variable.Bernoulli(0.9));
}
using (Variable.IfNot(hasSkills4))
{
isCorrect4.SetTo(Variable.Bernoulli(0.2));
}
var engine = new InferenceEngine();
engine.Algorithm = new ExpectationPropagation();
engine.NumberOfIterations = 10;
isCorrect1.ObservedValue = true;
isCorrect2.ObservedValue = false;
isCorrect3.ObservedValue = false;
isCorrect4.ObservedValue = false;
csharpSkill.AddAttribute(new TraceMessages());
sqlSkill.AddAttribute(new TraceMessages());
hasSkills3.AddAttribute(new TraceMessages());
hasSkills4.AddAttribute(new TraceMessages());
Console.WriteLine(engine.Infer(csharpSkill));
Console.WriteLine(engine.Infer(sqlSkill));
}