/// <summary>
/// Constructs a new Glass/Sprinkler/Rain model
/// </summary>
public TesteModel()
{
// Set up the ranges
NumberOfExamples = Variable.New <int>().Named("NofE");
Range N = new Range(NumberOfExamples).Named("N");
// Embora todas as variáveis neste exemplo tenham apenas 2 estados (true/false),
// o exemplo é formulado de uma forma que mostra como se estender a vários estados
Range C = new Range(2).Named("C");
Range S = new Range(2).Named("S");
// Definir as prioridades e os parâmetros
ProbCloudyPrior = Variable.New <Dirichlet>().Named("ProbCloudyPrior");
ProbCloudy = Variable <Vector> .Random(ProbCloudyPrior).Named("ProbCloudy");
ProbCloudy.SetValueRange(C);
// Tabela de probabilidade do sprinkler condicionada estar nublado
CPTSprinklerPrior = Variable.Array <Dirichlet>(C).Named("CPTSprinklerPrior");
CPTSprinkler = Variable.Array <Vector>(C).Named("CPTSprinkler");
CPTSprinkler[C] = Variable <Vector> .Random(CPTSprinklerPrior[C]);
CPTSprinkler.SetValueRange(S);
// Definir as principais variáveis
Cloudy = Variable.Array <int>(N).Named("Cloudy");
Cloudy[N] = Variable.Discrete(ProbCloudy).ForEach(N);
Sprinkler = AddChildFromOneParent(Cloudy, CPTSprinkler).Named("Sprinkler");
}
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 virtual void CreateModel(int n)
{
InferenceEngine = new InferenceEngine(new VariationalMessagePassing());
InferenceEngine.ShowFactorGraph = true;
NumComponents = n;
Range ComponentRange = new Range(NumComponents).Named("component_index");
PriceLevelPriors = Variable.Array <Gaussian>(ComponentRange).Named("price_line_priors");
NoisesPriors = Variable.Array <Gamma>(ComponentRange).Named("noise_priors");
PriceLevels = Variable.Array <double>(ComponentRange).Named("price_lines");
Noises = Variable.Array <double>(ComponentRange).Named("noises");
// Iterate over each component in the gaussian mixture model.
using (Variable.ForEach(ComponentRange))
{
// Each price level, that is, a support/resistance line is modeled as a Gaussian
// whose mean and precision are from two prior distributions.
// The prior of the mean is a Gaussian, and the prior of the precision is a Gamma distribution.
PriceLevels[ComponentRange] = Variable.Random <double, Gaussian>(PriceLevelPriors[ComponentRange]);
Noises[ComponentRange] = Variable.Random <double, Gamma>(NoisesPriors[ComponentRange]);
}
//Mixing coefficients
MixingPrior = Variable.New <Dirichlet>().Named("price_line_mixture_prior");
MixingCoefficients = Variable <Vector> .Random(MixingPrior).Named("mixture_coefficients");
MixingCoefficients.SetValueRange(ComponentRange);
}
public NoParentNode(ModelNode node)
{
this.node = node;
ProbPrior = Variable.New <Dirichlet>().Named("Prob" + node.name + "Prior");
ProbPrior.ObservedValue = Dirichlet.Uniform(node.states.SizeAsInt);
Probability = Variable <Vector> .Random(ProbPrior).Named("Prob" + node.name);
Probability.SetValueRange(node.states);
}
/// <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");
}
public NoParentNodeCategoricalNonShared(ModelNodeNonShared node)
{
this.node = node;
ProbPrior = Variable.New <Dirichlet>().Named("Prob" + node.name + "Prior");
ProbPrior.ObservedValue = (node.original.distributions as NoParentNodeCategorical).ProbPrior;
Probability = Variable <Vector> .Random(ProbPrior).Named("Prob" + node.name);
Probability.SetValueRange(node.states);
}
public MarkovModel(int ChainLength, int NumStates)
{
ModelEvidence = Variable.Bernoulli(0.5);
using (Variable.If(ModelEvidence))
{
K = new Range(NumStates);
T = new Range(ChainLength);
ProbInitPrior = Variable.New <Dirichlet>(); // init state priors
ProbInit = Variable <Vector> .Random(ProbInitPrior);
ProbInit.SetValueRange(K);
CPTTransPrior = Variable.Array <Dirichlet>(K); // transition state priors
CPTTrans = Variable.Array <Vector>(K);
CPTTrans[K] = Variable <Vector> .Random(CPTTransPrior[K]);
CPTTrans.SetValueRange(K);
ZeroState = Variable.Discrete(ProbInit); // main model variables
States = Variable.Array <int>(T);
using (var block = Variable.ForEach(T))
{
var t = block.Index;
using (Variable.If(t == 0)) // init state
{
States[t] = Variable.DiscreteUniform(K);
/*
* using (Variable.Switch(ZeroState))
* {
* States[t] = Variable.Discrete(ProbInit);
* //States[t] = Variable.DiscreteUniform(K);
* }
*/
}
using (Variable.If(t > 0)) // transition states
{
using (Variable.Switch(States[t - 1]))
{
States[t] = Variable.Discrete(CPTTrans[States[t - 1]]);
}
}
}
}
DefineInferenceEngine();
}
/// <summary>
/// Constructs a new Glass/Sprinkler/Rain model
/// </summary>
public WetGlassSprinklerRainModel()
{
// Set up the ranges
NumberOfExamples = Variable.New <int>().Named("NofE");
Range N = new Range(NumberOfExamples).Named("N");
// Embora todas as variáveis neste exemplo tenham apenas 2 estados (true/false),
// o exemplo é formulado de uma forma que mostra como se estender a vários estados
Range C = new Range(2).Named("C");
Range S = new Range(2).Named("S");
Range R = new Range(2).Named("R");
Range W = new Range(2).Named("W");
// Definir as prioridades e os parâmetros
ProbCloudyPrior = Variable.New <Dirichlet>().Named("ProbCloudyPrior");
ProbCloudy = Variable <Vector> .Random(ProbCloudyPrior).Named("ProbCloudy");
ProbCloudy.SetValueRange(C);
// Tabela de probabilidade do sprinkler condicionada estar nublado
CPTSprinklerPrior = Variable.Array <Dirichlet>(C).Named("CPTSprinklerPrior");
CPTSprinkler = Variable.Array <Vector>(C).Named("CPTSprinkler");
CPTSprinkler[C] = Variable <Vector> .Random(CPTSprinklerPrior[C]);
CPTSprinkler.SetValueRange(S);
// Tabela de probabilidade de chuva condicionada a estar nublado
CPTRainPrior = Variable.Array <Dirichlet>(C).Named("CPTRainPrior");
CPTRain = Variable.Array <Vector>(C).Named("CPTRain");
CPTRain[C] = Variable <Vector> .Random(CPTRainPrior[C]);
CPTRain.SetValueRange(R);
// Tabela de probabilidade de grama molhada, condicionada por aspersão e chuva
CPTWetGrassPrior = Variable.Array(Variable.Array <Dirichlet>(R), S).Named("CPTWetGrassPrior");
CPTWetGrass = Variable.Array(Variable.Array <Vector>(R), S).Named("CPTWetGrass");
CPTWetGrass[S][R] = Variable <Vector> .Random(CPTWetGrassPrior[S][R]);
CPTWetGrass.SetValueRange(W);
// Definir as principais variáveis
Cloudy = Variable.Array <int>(N).Named("Cloudy");
Cloudy[N] = Variable.Discrete(ProbCloudy).ForEach(N);
Sprinkler = AddChildFromOneParent(Cloudy, CPTSprinkler).Named("Sprinkler");
Rain = AddChildFromOneParent(Cloudy, CPTRain).Named("Rain");
WetGrass = AddChildFromTwoParents(Sprinkler, Rain, CPTWetGrass).Named("WetGrass");
}
/// <summary>
/// Constructs a new Glass/Sprinkler/Rain model
/// </summary>
public WetGlassSprinklerRainModel()
{
// Set up the ranges
NumberOfExamples = Variable.New <int>().Named("NofE");
Range N = new Range(NumberOfExamples).Named("N");
// Although all the variables in this example have just 2 states (true/false),
// the example is formulated in a way that shows how to extend to multiple states
Range C = new Range(2).Named("C");
Range S = new Range(2).Named("S");
Range R = new Range(2).Named("R");
Range W = new Range(2).Named("W");
// Define the priors and the parameters
ProbCloudyPrior = Variable.New <Dirichlet>().Named("ProbCloudyPrior");
ProbCloudy = Variable <Vector> .Random(ProbCloudyPrior).Named("ProbCloudy");
ProbCloudy.SetValueRange(C);
// Sprinkler probability table conditioned on cloudiness
CPTSprinklerPrior = Variable.Array <Dirichlet>(C).Named("CPTSprinklerPrior");
CPTSprinkler = Variable.Array <Vector>(C).Named("CPTSprinkler");
CPTSprinkler[C] = Variable <Vector> .Random(CPTSprinklerPrior[C]);
CPTSprinkler.SetValueRange(S);
// Rain probability table conditioned on cloudiness
CPTRainPrior = Variable.Array <Dirichlet>(C).Named("CPTRainPrior");
CPTRain = Variable.Array <Vector>(C).Named("CPTRain");
CPTRain[C] = Variable <Vector> .Random(CPTRainPrior[C]);
CPTRain.SetValueRange(R);
// Wet grass probability table conditioned on sprinkler and rain
CPTWetGrassPrior = Variable.Array(Variable.Array <Dirichlet>(R), S).Named("CPTWetGrassPrior");
CPTWetGrass = Variable.Array(Variable.Array <Vector>(R), S).Named("CPTWetGrass");
CPTWetGrass[S][R] = Variable <Vector> .Random(CPTWetGrassPrior[S][R]);
CPTWetGrass.SetValueRange(W);
// Define the primary variables
Cloudy = Variable.Array <int>(N).Named("Cloudy");
Cloudy[N] = Variable.Discrete(ProbCloudy).ForEach(N);
Sprinkler = AddChildFromOneParent(Cloudy, CPTSprinkler).Named("Sprinkler");
Rain = AddChildFromOneParent(Cloudy, CPTRain).Named("Rain");
WetGrass = AddChildFromTwoParents(Sprinkler, Rain, CPTWetGrass).Named("WetGrass");
}
/// <summary>
/// Constructs a new Glass/Sprinkler/Rain model
/// </summary>
public WetGlassSprinklerRainModel()
{
// Set up the ranges
NumberOfExamples = Variable.New <int>().Named("NofE");
Range N = new Range(NumberOfExamples).Named("N");
Range C = new Range(CloudyStateCount).Named("C");
Range S = new Range(SprinklerStateCount).Named("S");
Range R = new Range(RainStateCount).Named("R");
Range W = new Range(WetGrassStateCount).Named("W");
// Define the priors and the parameters
ProbCloudyPrior = Variable.New <Dirichlet>().Named("ProbCloudyPrior");
ProbCloudy = Variable <Vector> .Random(ProbCloudyPrior).Named("ProbCloudy");
ProbCloudy.SetValueRange(C);
// Sprinkler probability table conditioned on cloudiness
CPTSprinklerPrior = Variable.Array <Dirichlet>(C).Named("CPTSprinklerPrior");
CPTSprinkler = Variable.Array <Vector>(C).Named("CPTSprinkler");
CPTSprinkler[C] = Variable <Vector> .Random(CPTSprinklerPrior[C]);
CPTSprinkler.SetValueRange(S);
// Rain probability table conditioned on cloudiness
CPTRainPrior = Variable.Array <Dirichlet>(C).Named("CPTRainPrior");
CPTRain = Variable.Array <Vector>(C).Named("CPTRain");
CPTRain[C] = Variable <Vector> .Random(CPTRainPrior[C]);
CPTRain.SetValueRange(R);
// Wet grass probability table conditioned on sprinkler and rain
CPTWetGrassPrior = Variable.Array(Variable.Array <Dirichlet>(R), S).Named("CPTWetGrassPrior");
CPTWetGrass = Variable.Array(Variable.Array <Vector>(R), S).Named("CPTWetGrass");
CPTWetGrass[S][R] = Variable <Vector> .Random(CPTWetGrassPrior[S][R]);
CPTWetGrass.SetValueRange(W);
// Define the primary variables
Cloudy = Variable.Array <int>(N).Named("Cloudy");
Cloudy[N] = Variable.Discrete(ProbCloudy).ForEach(N);
Sprinkler = AddChildFromOneParent(Cloudy, CPTSprinkler).Named("Sprinkler");
Rain = AddChildFromOneParent(Cloudy, CPTRain).Named("Rain");
WetGrass = AddChildFromTwoParents(Sprinkler, Rain, CPTWetGrass).Named("WetGrass");
}
public void BallCounting2()
{
double noise = 0.2;
int maxBalls = 8;
Range ball = new Range(maxBalls).Named("ball");
Variable <int> numBalls = Variable.DiscreteUniform(maxBalls + 1).Named("numBalls");
numBalls.SetValueRange(new Range(maxBalls + 1));
SwitchBlock block = Variable.Switch(numBalls);
Variable <int> numTrue = Variable.Binomial(numBalls, 0.5).Named("numTrue");
Variable <int> numObserved = Variable.New <int>().Named("numObserved");
Range observedBall = new Range(numObserved).Named("observedBall");
VariableArray <bool> observedTrue = Variable.Array <bool>(observedBall).Named("observedTrue");
using (Variable.ForEach(observedBall))
{
Variable <int> ballIndex = Variable.DiscreteUniform(ball, numBalls).Named("ballIndex");
observedTrue[observedBall] = ((ballIndex < numTrue) == Variable.Bernoulli(1 - noise));
}
block.CloseBlock();
InferenceEngine engine = new InferenceEngine();
for (int numObservedInt = 10; 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 numObservedTrue = 0;
for (int i = 0; i < data.Length; i++)
{
data[i] = (i < numObservedTrue);
}
numObserved.ObservedValue = data.Length;
observedTrue.ObservedValue = data;
//Console.WriteLine("numTrue = {0}", engine.Infer(numTrue));
Discrete numBallsActual = engine.Infer <Discrete>(numBalls);
Console.WriteLine("numBalls = {0}", numBallsActual);
Discrete numBallsExpected = BallCountingExact(maxBalls, numObservedInt, numObservedTrue, noise);
Console.WriteLine(" exact = {0}", numBallsExpected);
Assert.True(numBallsExpected.MaxDiff(numBallsActual) < 1e-10);
}
}
/// <summary>
/// Constructs an LDA model
/// </summary>
/// <param name="sizeVocab">Size of vocabulary</param>
/// <param name="numTopics">Number of topics</param>
public LDATopicInferenceModel(
int sizeVocab,
int numTopics)
{
SizeVocab = sizeVocab;
NumTopics = numTopics;
//---------------------------------------------
// The model
//---------------------------------------------
NumWordsInDoc = Variable.New <int>().Named("NumWordsInDoc");
Range W = new Range(SizeVocab).Named("W");
Range T = new Range(NumTopics).Named("T");
Range WInD = new Range(NumWordsInDoc).Named("WInD");
Theta = Variable.New <Vector>().Named("Theta");
ThetaPrior = Variable.New <Dirichlet>().Named("ThetaPrior");
ThetaPrior.SetValueRange(T);
Theta = Variable <Vector> .Random(ThetaPrior);
PhiPrior = Variable.Array <Dirichlet>(T).Named("PhiPrior");
PhiPrior.SetValueRange(W);
Phi = Variable.Array <Vector>(T).Named("Phi");
Phi[T] = Variable.Random <Vector, Dirichlet>(PhiPrior[T]);
Words = Variable.Array <int>(WInD).Named("Words");
WordCounts = Variable.Array <double>(WInD).Named("WordCounts");
using (Variable.ForEach(WInD))
{
using (Variable.Repeat(WordCounts[WInD]))
{
var topic = Variable.Discrete(Theta).Attrib(new ValueRange(T)).Named("topic");
topic.SetValueRange(T);
using (Variable.Switch(topic))
{
Words[WInD] = Variable.Discrete(Phi[topic]);
}
}
}
Engine = new InferenceEngine(new VariationalMessagePassing());
Engine.Compiler.ShowWarnings = false;
}
/// <summary>
/// Constructs a new Glass/Sprinkler/Rain model
/// </summary>
public WetGlassSprinklerRainModel()
{
// Set up the ranges
NumberOfExamples = Variable.New<int>().Named("NofE");
Range N = new Range(NumberOfExamples).Named("N");
// Although all the variables in this example have just 2 states (true/false),
// the example is formulated in a way that shows how to extend to multiple states
Range C = new Range(2).Named("C");
Range S = new Range(2).Named("S");
Range R = new Range(2).Named("R");
Range W = new Range(2).Named("W");
// Define the priors and the parameters
ProbCloudyPrior = Variable.New<Dirichlet>().Named("ProbCloudyPrior");
ProbCloudy = Variable<Vector>.Random(ProbCloudyPrior).Named("ProbCloudy");
ProbCloudy.SetValueRange(C);
// Sprinkler probability table conditioned on cloudiness
CPTSprinklerPrior = Variable.Array<Dirichlet>(C).Named("CPTSprinklerPrior");
CPTSprinkler = Variable.Array<Vector>(C).Named("CPTSprinkler");
CPTSprinkler[C] = Variable<Vector>.Random(CPTSprinklerPrior[C]);
CPTSprinkler.SetValueRange(S);
// Rain probability table conditioned on cloudiness
CPTRainPrior = Variable.Array<Dirichlet>(C).Named("CPTRainPrior");
CPTRain = Variable.Array<Vector>(C).Named("CPTRain"); ;
CPTRain[C] = Variable<Vector>.Random(CPTRainPrior[C]);
CPTRain.SetValueRange(R);
// Wet grass probability table conditioned on sprinkler and rain
CPTWetGrassPrior = Variable.Array(Variable.Array<Dirichlet>(R), S).Named("CPTWetGrassPrior");
CPTWetGrass = Variable.Array(Variable.Array<Vector>(R), S).Named("CPTWetGrass");
CPTWetGrass[S][R] = Variable<Vector>.Random(CPTWetGrassPrior[S][R]);
CPTWetGrass.SetValueRange(W);
// Define the primary variables
Cloudy = Variable.Array<int>(N).Named("Cloudy");
Cloudy[N] = Variable.Discrete(ProbCloudy).ForEach(N);
Sprinkler = AddChildFromOneParent(Cloudy, CPTSprinkler).Named("Sprinkler");
Rain = AddChildFromOneParent(Cloudy, CPTRain).Named("Rain");
WetGrass = AddChildFromTwoParents(Sprinkler, Rain, CPTWetGrass).Named("WetGrass");
}
public virtual void CreateModel()
{
inferenceEngine = new InferenceEngine(new VariationalMessagePassing());
numComponents = 2;
Range componentRange = new Range(numComponents);
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.Random <double, Gaussian>(averageTimePriors[componentRange]);
trafficNoise[componentRange] = Variable.Random <double, Gamma>(trafficNoisePriors[componentRange]);
}
mixingPrior = Variable.New <Dirichlet>();
mixingCoefficients = Variable <Vector> .Random(mixingPrior);
mixingCoefficients.SetValueRange(componentRange);
}
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 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.Random<double, Gaussian>(AverageTimePriors[ComponentRange]);
TrafficNoise[ComponentRange] = Variable.Random<double, Gamma>(TrafficNoisePriors[ComponentRange]);
}
//Mixing coefficients
MixingPrior = Variable.New<Dirichlet>();
MixingCoefficients = Variable<Vector>.Random(MixingPrior);
MixingCoefficients.SetValueRange(ComponentRange);
}
/// <summary>
/// Initializes the ranges of the variables.
/// </summary>
/// <param name="taskCount">The number of tasks.</param>
/// <param name="labelCount">The number of labels.</param>
protected virtual void DefineVariablesAndRanges(int taskCount, int labelCount)
{
WorkerCount = Variable.New <int>().Named("WorkerCount");
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);
// The confusion matrices for each worker
ConfusionMatrixPrior = Variable.Array(Variable.Array <Dirichlet>(c), k).Named("ConfusionMatrixPrior");
WorkerConfusionMatrix = Variable.Array(Variable.Array <Vector>(c), k).Named("ConfusionMatrix");
WorkerConfusionMatrix[k][c] = Variable <Vector> .Random(ConfusionMatrixPrior[k][c]);
WorkerConfusionMatrix.SetValueRange(c);
// 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");
// Constraint for online learning
TrueLabel[n] = Variable.Discrete(BackgroundLabelProb).ForEach(n);
Variable.ConstrainEqualRandom(TrueLabel[n], TrueLabelConstraint[n]);
// The worker labels
WorkerLabel = Variable.Array(Variable.Array <int>(kn), k).Named("WorkerLabel");
}
/// <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");
}
public MarkovMixtureModel(int NumberOfClusters)
{
NumClusters = Variable.Observed(NumberOfClusters);
NumSequences = Variable.New <int>();
NumStates = Variable.New <int>();
// set ranges
C = new Range(NumClusters).Named("C");
K = new Range(NumStates).Named("K");
// set cluster
ProbClusterPrior = Variable.New <Dirichlet>();
ProbCluster = Variable <Vector> .Random(ProbClusterPrior).Named("ProbCluster");
ProbCluster.SetValueRange(C);
// set init
ProbInitPrior = Variable.Array <Dirichlet>(C);
ProbInit = Variable.Array <Vector>(C).Named("ProbInit");
ProbInit[C] = Variable <Vector> .Random(ProbInitPrior[C]).Named("ProbInit");
ProbInit.SetValueRange(C);
// set trans prob. table
CPTTransPrior = Variable.Array(Variable.Array <Dirichlet>(K), C);
CPTTrans = Variable.Array(Variable.Array <Vector>(K), C).Named("CPTTrans");
CPTTrans[C][K] = Variable <Vector> .Random(CPTTransPrior[C][K]);
CPTTrans.SetValueRange(K);
// define jagged array sizes and ranges
N = new Range(NumSequences);
SequenceSizes = Variable.Array <int>(N);
T = new Range(SequenceSizes[N]);
// define primary model variables -- actual states
States = Variable.Array(Variable.Array <int>(T), N).Named("States");
States.SetValueRange(K);
// define cluster assignment array
Z = Variable.Array <int>(N);
using (Variable.ForEach(N))
{
Z[N] = Variable.Discrete(ProbCluster);
using (var block = Variable.ForEach(T))
{
var t = block.Index;
using (Variable.If(t == 0))
using (Variable.Switch(Z[N]))
States[N][T].SetTo(Variable.Discrete(ProbInit[Z[N]]));
var previousState = States[N][t - 1];
using (Variable.If(t > 0))
using (Variable.Switch(previousState))
using (Variable.Switch(Z[N]))
States[N][T].SetTo(Variable.Discrete(CPTTrans[Z[N]][previousState]));
}
}
engine = new InferenceEngine();
engine.Compiler.UseParallelForLoops = true;
}
public AsthmaModel(string modelName = "AsthmaModel", bool breakSymmetry = true)
{
BreakSymmetry = breakSymmetry;
NumYears = Variable.New <int>().Named("NumYears");
NumChildren = Variable.New <int>().Named("NumChildren");
NumAllergens = Variable.New <int>().Named("NumAllergens");
NumVulnerabilities = Variable.New <int>().Named("NumVulnerabilities");
years = new Range(this.NumYears).Named("years");
children = new Range(this.NumChildren).Named("children");
allergens = new Range(this.NumAllergens).Named("allergens");
classes = new Range(this.NumVulnerabilities).Named("classes");
sensitized = Variable.Array(Variable.Array <bool>(children, allergens), years).Named("sensitized");
skinTest = Variable.Array(Variable.Array <bool>(children, allergens), years).Named("skinTest");
igeTest = Variable.Array(Variable.Array <bool>(children, allergens), years).Named("igeTest");
skinTestMissing = Variable.Array(Variable.Array <bool>(children, allergens), years).Named("skinTestMissing");
igeTestMissing = Variable.Array(Variable.Array <bool>(children, allergens), years).Named("igeTestMissing");
probSensClassPrior = Variable.New <Dirichlet>().Named("probSensClassPrior");
probSensClass = Variable <Vector> .Random(probSensClassPrior).Named("probSensClass");
probSensClass.SetValueRange(classes);
sensClass = Variable.Array <int>(children).Named("sensClass");
sensClass[children] = Variable.Discrete(probSensClass).ForEach(children);
sensClassInitializer = Variable.New <IDistribution <int[]> >().Named("sensClassInitializer");
if (BreakSymmetry)
{
sensClass.InitialiseTo(sensClassInitializer);
}
// Transition probabilities
probSens1Prior = Variable.Array <Beta>(allergens, classes).Named("probSens1Prior");
probGainPrior = Variable.Array(Variable.Array <Beta>(allergens, classes), years).Named("probGainPrior");
probRetainPrior = Variable.Array(Variable.Array <Beta>(allergens, classes), years).Named("probRetainPrior");
probSens1 = Variable.Array <double>(allergens, classes).Named("probSens1");
probGain = Variable.Array(Variable.Array <double>(allergens, classes), years).Named("probGain");
probRetain = Variable.Array(Variable.Array <double>(allergens, classes), years).Named("probRetain");
probSens1[allergens, classes] = Variable <double> .Random(probSens1Prior[allergens, classes]);
probGain[years][allergens, classes] = Variable <double> .Random(probGainPrior[years][allergens, classes]);
probRetain[years][allergens, classes] = Variable <double> .Random(probRetainPrior[years][allergens, classes]);
// Emission probabilities
probSkinIfSensPrior = Variable.New <Beta>().Named("probSkinIfSensPrior");
probSkinIfNotSensPrior = Variable.New <Beta>().Named("probSkinIfNotSensPrior");
probIgeIfSensPrior = Variable.New <Beta>().Named("probIgeIfSensPrior");
probIgeIfNotSensPrior = Variable.New <Beta>().Named("probIgeIfNotSensPrior");
probSkinIfSens = Variable <double> .Random(probSkinIfSensPrior).Named("probSkinIfSens");
probSkinIfNotSens = Variable <double> .Random(probSkinIfNotSensPrior).Named("probSkinIfNotSens");
probIgeIfSens = Variable <double> .Random(probIgeIfSensPrior).Named("probIgeIfSens");
probIgeIfNotSens = Variable <double> .Random(probIgeIfNotSensPrior).Named("probIgeIfNotSens");
// Transitions
using (Variable.ForEach(children))
{
using (Variable.Switch(sensClass[children]))
{
using (Variable.ForEach(allergens))
{
using (var block = Variable.ForEach(years))
{
var year = block.Index;
var yearIs0 = (year == 0).Named("year == 0");
var yearIsGr0 = (year > 0).Named("year > 0");
using (Variable.If(yearIs0))
{
sensitized[year][children, allergens] = Variable.Bernoulli(probSens1[allergens, sensClass[children]]);
}
using (Variable.If(yearIsGr0))
{
var prevYear = (year - 1).Named("year - 1");
using (Variable.If(sensitized[prevYear][children, allergens]))
{
sensitized[year][children, allergens] = Variable.Bernoulli(probRetain[year][allergens, sensClass[children]]);
}
using (Variable.IfNot(sensitized[prevYear][children, allergens]))
{
sensitized[year][children, allergens] = Variable.Bernoulli(probGain[year][allergens, sensClass[children]]);
}
}
}
}
}
}
// Emissions
using (Variable.ForEach(children))
{
using (Variable.ForEach(allergens))
{
using (Variable.ForEach(years))
{
using (Variable.If(sensitized[years][children, allergens]))
{
using (Variable.IfNot(skinTestMissing[years][children, allergens]))
{
skinTest[years][children, allergens] = Variable.Bernoulli(probSkinIfSens);
}
using (Variable.IfNot(igeTestMissing[years][children, allergens]))
{
igeTest[years][children, allergens] = Variable.Bernoulli(probIgeIfSens);
}
}
using (Variable.IfNot(sensitized[years][children, allergens]))
{
using (Variable.IfNot(skinTestMissing[years][children, allergens]))
{
skinTest[years][children, allergens] = Variable.Bernoulli(probSkinIfNotSens);
}
using (Variable.IfNot(igeTestMissing[years][children, allergens]))
{
igeTest[years][children, allergens] = Variable.Bernoulli(probIgeIfNotSens);
}
}
}
}
}
Engine = new InferenceEngine()
{
ShowProgress = false,
ModelName = modelName
};
Engine.ProgressChanged += Engine_ProgressChanged;
}
/// <summary>
/// Constructs a new CreditNet model
/// </summary>
public CreditNetModel()
{
// Set up the ranges
NumberOfExamples = Variable.New <int>().Named("NofE");
Range N = new Range(NumberOfExamples).Named("N");
// Dimensions of model variables
Range A = new Range(3).Named("A"); // Age
Range PH = new Range(3).Named("PH"); // Payment History
Range G = new Range(2).Named("G"); // Gender
Range R = new Range(2).Named("R"); // Reliability
Range Ga = new Range(2).Named("Ga"); // Gambler
Range RD = new Range(2).Named("RD"); // Ratio of Debts to Income
Range E = new Range(3).Named("E"); // Education
Range I = new Range(3).Named("I"); // Income
Range As = new Range(3).Named("As"); // Assets
Range F = new Range(2).Named("F"); // Future Income
Range CW = new Range(2).Named("CW"); // Credit-Worthiness
// Define the priors and the parameters
// For Age:
ProbAgePrior = Variable.New <Dirichlet>().Named(nameof(ProbAgePrior));
ProbAge = Variable <Vector> .Random(ProbAgePrior).Named(nameof(ProbAge));
ProbAge.SetValueRange(A);
// For Gender:
ProbGenderPrior = Variable.New <Dirichlet>().Named(nameof(ProbGenderPrior));
ProbGender = Variable <Vector> .Random(ProbGenderPrior).Named(nameof(ProbGender));
ProbGender.SetValueRange(G);
// For Gambler:
ProbGamblerPrior = Variable.New <Dirichlet>().Named(nameof(ProbGamblerPrior));
ProbGambler = Variable <Vector> .Random(ProbGamblerPrior).Named(nameof(ProbGambler));
ProbGambler.SetValueRange(Ga);
// For Education
ProbEducationPrior = Variable.New <Dirichlet>().Named(nameof(ProbEducationPrior));
ProbEducation = Variable <Vector> .Random(ProbEducationPrior).Named(nameof(ProbEducation));
ProbEducation.SetValueRange(E);
// Define the CPT priors for one parent children
// Payment History probability table conditioned on Age
CPTPaymentHistoryPrior = Variable.Array <Dirichlet>(A).Named(nameof(CPTPaymentHistoryPrior));
CPTPaymentHistory = Variable.Array <Vector>(A).Named(nameof(CPTPaymentHistory));
CPTPaymentHistory[A] = Variable <Vector> .Random(CPTPaymentHistoryPrior[A]);
CPTPaymentHistory.SetValueRange(PH);
// Ratio of Debts to Income probability table conditioned on Gambler
CPTRatioOfDebtsToIncomePrior = Variable.Array <Dirichlet>(Ga).Named(nameof(CPTRatioOfDebtsToIncomePrior));
CPTRatioOfDebtsToIncome = Variable.Array <Vector>(Ga).Named(nameof(CPTRatioOfDebtsToIncome));
CPTRatioOfDebtsToIncome[Ga] = Variable <Vector> .Random(CPTRatioOfDebtsToIncomePrior[Ga]);
CPTRatioOfDebtsToIncome.SetValueRange(RD);
// Income probability table conditioned on Education
CPTIncomePrior = Variable.Array <Dirichlet>(E).Named(nameof(CPTIncomePrior));
CPTIncome = Variable.Array <Vector>(E).Named(nameof(CPTIncome));
CPTIncome[E] = Variable <Vector> .Random(CPTIncomePrior[E]);
CPTIncome.SetValueRange(I);
// Assets probability table conditioned on Income
CPTAssetsPrior = Variable.Array <Dirichlet>(I).Named(nameof(CPTAssetsPrior));
CPTAssets = Variable.Array <Vector>(I).Named(nameof(CPTAssets));
CPTAssets[I] = Variable <Vector> .Random(CPTAssetsPrior[I]);
CPTAssets.SetValueRange(As);
// Define the CPT priors for three parents children
// Reliability probability table conditioned on Age, Gender and Payment History
CPTReliabilityPrior = Variable.Array(Variable.Array(Variable.Array <Dirichlet>(PH), G), A).Named(nameof(CPTReliabilityPrior));
CPTReliability = Variable.Array(Variable.Array(Variable.Array <Vector>(PH), G), A).Named(nameof(CPTReliability));
CPTReliability[A][G][PH] = Variable <Vector> .Random(CPTReliabilityPrior[A][G][PH]);
CPTReliability.SetValueRange(R);
// Future Income probability table conditioned on Education, Income and Assets
CPTFutureIncomePrior = Variable.Array(Variable.Array(Variable.Array <Dirichlet>(As), I), E).Named(nameof(CPTFutureIncomePrior));
CPTFutureIncome = Variable.Array(Variable.Array(Variable.Array <Vector>(As), I), E).Named(nameof(CPTFutureIncome));
CPTFutureIncome[E][I][As] = Variable <Vector> .Random(CPTFutureIncomePrior[E][I][As]);
CPTFutureIncome.SetValueRange(F);
// Credit-Worthiness probability table conditioned on Ratio of Debts to Income, Reliability and Future Income
CPTCreditWorthinessPrior = Variable.Array(Variable.Array(Variable.Array <Dirichlet>(F), R), RD).Named(nameof(CPTCreditWorthinessPrior));
CPTCreditWorthiness = Variable.Array(Variable.Array(Variable.Array <Vector>(F), R), RD).Named(nameof(CPTCreditWorthiness));
CPTCreditWorthiness[RD][R][F] = Variable <Vector> .Random(CPTCreditWorthinessPrior[RD][R][F]);
CPTCreditWorthiness.SetValueRange(CW);
// Define the primary variables
// Roots
Age = Variable.Array <int>(N).Named(nameof(Age));
Age[N] = Variable.Discrete(ProbAge).ForEach(N);
Gender = Variable.Array <int>(N).Named(nameof(Gender));
Gender[N] = Variable.Discrete(ProbGender).ForEach(N);
Gambler = Variable.Array <int>(N).Named(nameof(Gambler));
Gambler[N] = Variable.Discrete(ProbGambler).ForEach(N);
Education = Variable.Array <int>(N).Named(nameof(Education));
Education[N] = Variable.Discrete(ProbEducation).ForEach(N);
// Single parent children
PaymentHistory = AddChildFromOneParent(Age, CPTPaymentHistory).Named(nameof(PaymentHistory));
RatioOfDebtsToIncome = AddChildFromOneParent(Gambler, CPTRatioOfDebtsToIncome).Named(nameof(RatioOfDebtsToIncome));
Income = AddChildFromOneParent(Education, CPTIncome).Named(nameof(Income));
Assets = AddChildFromOneParent(Income, CPTAssets).Named(nameof(Assets));
// Triple parent children
Reliability = AddChildFromThreeParents(Age, Gender, PaymentHistory, CPTReliability).Named(nameof(Reliability));
FutureIncome = AddChildFromThreeParents(Education, Income, Assets, CPTFutureIncome).Named(nameof(FutureIncome));
CreditWorthiness = AddChildFromThreeParents(RatioOfDebtsToIncome, Reliability, FutureIncome, CPTCreditWorthiness).Named(nameof(CreditWorthiness));
}
/// <summary>
/// Initializes the ranges of the variables.
/// </summary>
/// <param name="taskCount">The number of tasks.</param>
/// <param name="labelCount">The number of labels.</param>
protected virtual void DefineVariablesAndRanges(int taskCount, int labelCount)
{
WorkerCount = Variable.New<int>().Named("WorkerCount");
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);
// The confusion matrices for each worker
ConfusionMatrixPrior = Variable.Array(Variable.Array<Dirichlet>(c), k).Named("ConfusionMatrixPrior");
WorkerConfusionMatrix = Variable.Array(Variable.Array<Vector>(c), k).Named("ConfusionMatrix");
WorkerConfusionMatrix[k][c] = Variable<Vector>.Random(ConfusionMatrixPrior[k][c]);
WorkerConfusionMatrix.SetValueRange(c);
// 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");
// Constraint for online learning
TrueLabel[n] = Variable.Discrete(BackgroundLabelProb).ForEach(n);
Variable.ConstrainEqualRandom(TrueLabel[n], TrueLabelConstraint[n]);
// The worker labels
WorkerLabel = Variable.Array(Variable.Array<int>(kn), k).Named("WorkerLabel");
}
/// <summary>
/// Initializes a new instance of the <see cref="HiddenMarkovModel.HiddenMarkovModel"/> class.
/// </summary>
/// <param name="ChainLength">Chain length.</param>
/// <param name="NumStates">Number states.</param>
public HiddenMarkovModel(int ChainLength, int NumStates)
{
ModelEvidence = Variable.Bernoulli(0.5).Named("evidence");
using (Variable.If(ModelEvidence))
{
K = new Range(NumStates).Named("K");
T = new Range(ChainLength).Named("T");
// Init
ProbInitPrior = Variable.New <Dirichlet>().Named("ProbInitPrior");
ProbInit = Variable <Vector> .Random(ProbInitPrior).Named("ProbInit");
ProbInit.SetValueRange(K);
// Trans probability table based on init
CPTTransPrior = Variable.Array <Dirichlet>(K).Named("CPTTransPrior");
CPTTrans = Variable.Array <Vector>(K).Named("CPTTrans");
CPTTrans[K] = Variable <Vector> .Random(CPTTransPrior[K]);
CPTTrans.SetValueRange(K);
// Emit mean
EmitMeanPrior = Variable.Array <Gaussian>(K).Named("EmitMeanPrior");
EmitMean = Variable.Array <double>(K).Named("EmitMean");
EmitMean[K] = Variable <double> .Random(EmitMeanPrior[K]);
EmitMean.SetValueRange(K);
// Emit prec
EmitPrecPrior = Variable.Array <Gamma>(K).Named("EmitPrecPrior");
EmitPrec = Variable.Array <double>(K).Named("EmitPrec");
EmitPrec[K] = Variable <double> .Random(EmitPrecPrior[K]);
EmitPrec.SetValueRange(K);
// Define the primary variables
ZeroState = Variable.Discrete(ProbInit).Named("z0"); // zero state does not have emission variable
States = Variable.Array <int>(T);
Emissions = Variable.Array <double>(T);
// for block over length of chain
using (var block = Variable.ForEach(T))
{
var t = block.Index;
var previousState = States[t - 1];
// initial distribution
using (Variable.If((t == 0).Named("Initial")))
{
using (Variable.Switch(ZeroState))
{
States[T] = Variable.Discrete(CPTTrans[ZeroState]);
}
}
// transition distributions
using (Variable.If((t > 0).Named("Transition")))
{
using (Variable.Switch(previousState))
{
States[t] = Variable.Discrete(CPTTrans[previousState]);
}
}
// emission distribution
using (Variable.Switch(States[t]))
{
Emissions[t] = Variable.GaussianFromMeanAndPrecision(EmitMean[States[t]], EmitPrec[States[t]]);
}
}
}
DefineInferenceEngine();
}
public static void Test()
{
int[] observed = new int[] { 21, 27, 41, 35, 47, 54, 59, 19, 19, 16, 23, 35, 19, 30, 31, 37, 66, 20, 27, 25, 35, 28, 62, 31,
49, 40, 31, 14, 20, 37, 38, 25, 31, 39 };
int[] pathObserved = new int[] { 22, 24, 32, 50, 62, 73, 69, 19, 13, 8, 23, 27, 32, 22, 25, 39, 39, 17, 22, 24, 26, 26, 53, 26, 36, 38, 34, 19, 20, 45, 37, 21, 45, 41 };
Range range = new Range(observed.Length);
Variable <double> roomsMean = Variable.GammaFromMeanAndVariance(0.5, 0.5);
Variable <int> rooms = Variable.Poisson(roomsMean);
VariableArray <int> observedVar = Variable.Array <int>(range);
observedVar[range] = rooms.ForEach(range);
observedVar.ObservedValue = observed;
Range roomsRange = new Range(100);
Range pathRange = new Range(100);
rooms.SetValueRange(roomsRange);
observedVar.SetValueRange(roomsRange);
VariableArray <Gamma> CPTPrior = Variable.Array <Gamma>(roomsRange).Named("ProbPrior");
CPTPrior.ObservedValue = Enumerable.Repeat(Gamma.FromShapeAndScale(1, 1), pathRange.SizeAsInt).ToArray();
VariableArray <double> CPT = Variable.Array <double>(roomsRange).Named("MoreQQLessPewPew");
CPT[roomsRange] = Variable <double> .Random(CPTPrior[roomsRange]);
CPT.SetValueRange(pathRange);
var observedPaths = Variable.Array <int>(range);
using (Variable.ForEach(range))
using (Variable.Switch(observedVar[range]))
observedPaths[range] = Variable.Poisson(CPT[observedVar[range]]);
observedPaths.ObservedValue = pathObserved;
InferenceEngine Engine = new InferenceEngine();
Gamma posterior = Engine.Infer <Gamma>(roomsMean);
Gamma[] CPTPosterior = Engine.Infer <Gamma[]>(CPT);
string str = "";
for (int p1 = 0; p1 < roomsRange.SizeAsInt; p1++)
{
// for (int ii = 0; ii < pathRange.SizeAsInt - 1; ii++) {
if (CPTPosterior[p1].GetMean() > 1)
{
str += " E( path |" + p1 + ") = " + CPTPosterior[p1].GetMean() + "\n";
// str += " P(" + ii + "|" + p1 + ") = " + CPTPosterior[p1].GetMean() + "\n";
}
}
/*
* VariableArray<Dirichlet> CPTPrior = Variable.Array<Dirichlet>(roomsRange).Named("ProbPrior");
* CPTPrior.ObservedValue = Enumerable.Repeat(Dirichlet.Uniform(pathRange.SizeAsInt), pathRange.SizeAsInt).ToArray();
* VariableArray<Vector> CPT = Variable.Array<Vector>(roomsRange).Named("Prob");
* CPT[roomsRange] = Variable<Vector>.Random(CPTPrior[roomsRange]);
* CPT.SetValueRange(pathRange);
* var observedPaths = Variable.Array<int>(range);
*
* using (Variable.ForEach(range))
* using (Variable.Switch(observedVar[range]))
* observedPaths[range] = Variable.Discrete(CPT[observedVar[range]]);
* observedPaths.ObservedValue = pathObserved;
* InferenceEngine Engine = new InferenceEngine();
* Gamma posterior = Engine.Infer<Gamma>(roomsMean);
* Dirichlet[] CPTPosterior = Engine.Infer<Dirichlet[]>(CPT);
* string str = "";
* for (int p1 = 0; p1 < roomsRange.SizeAsInt; p1++) {
* for (int ii = 0; ii < pathRange.SizeAsInt - 1; ii++) {
* if (CPTPosterior[p1].GetMean()[ii] > 0.011) {
* str += " P(" + ii + "|" + p1 + ") = " + CPTPosterior[p1].GetMean()[ii] + "\n";
* }
* }
* }
*/
Console.WriteLine(posterior);
Console.WriteLine(str);
}
/// <summary>
/// Constructs an LDA model
/// </summary>
/// <param name="sizeVocab">Size of vocabulary</param>
/// <param name="numTopics">Number of topics</param>
public LDATopicInferenceModel(
int sizeVocab,
int numTopics)
{
SizeVocab = sizeVocab;
NumTopics = numTopics;
//---------------------------------------------
// The model
//---------------------------------------------
NumWordsInDoc = Variable.New<int>().Named("NumWordsInDoc");
Range W = new Range(SizeVocab).Named("W");
Range T = new Range(NumTopics).Named("T");
Range WInD = new Range(NumWordsInDoc).Named("WInD");
Theta = Variable.New<Vector>().Named("Theta");
ThetaPrior = Variable.New<Dirichlet>().Named("ThetaPrior");
ThetaPrior.SetValueRange(T);
Theta = Variable<Vector>.Random(ThetaPrior);
PhiPrior = Variable.Array<Dirichlet>(T).Named("PhiPrior");
PhiPrior.SetValueRange(W);
Phi = Variable.Array<Vector>(T).Named("Phi");
Phi[T] = Variable.Random<Vector, Dirichlet>(PhiPrior[T]);
Words = Variable.Array<int>(WInD).Named("Words");
WordCounts = Variable.Array<double>(WInD).Named("WordCounts");
using (Variable.ForEach(WInD))
{
using (Variable.Repeat(WordCounts[WInD]))
{
var topic = Variable.Discrete(Theta).Attrib(new ValueRange(T)).Named("topic");
topic.SetValueRange(T);
using (Variable.Switch(topic))
Words[WInD] = Variable.Discrete(Phi[topic]);
}
}
Engine = new InferenceEngine(new VariationalMessagePassing());
Engine.Compiler.ShowWarnings = false;
}
