public MapVariable(
IRandomVariable <TIn> input,
Func <TIn, TOut> func)
{
_input = input;
_func = func;
}
// END-BayesInference
//
//
// PROTECTED METHODS
//
// function ENUMERATE-ALL(vars, e) returns a real number
protected double enumerateAll(ICollection <IRandomVariable> vars, ObservedEvidence e)
{
// if EMPTY?(vars) then return 1.0
if (0 == vars.Size())
{
return(1);
}
// Y <- FIRST(vars)
IRandomVariable Y = Util.first(vars);
// if Y has value y in e
if (e.containsValue(Y))
{
// then return P(y | parents(Y)) * ENUMERATE-ALL(REST(vars), e)
return(e.posteriorForParents(Y) * enumerateAll(Util.rest(vars), e));
}
/**
* <pre>
* else return ∑<sub>y</sub> P(y | parents(Y)) * ENUMERATE-ALL(REST(vars), e<sub>y</sub>)
* where e<sub>y</sub> is e extended with Y = y
* </pre>
*/
double sum = 0;
foreach (object y in ((IFiniteDomain)Y.getDomain()).GetPossibleValues())
{
e.setExtendedValue(Y, y);
sum += e.posteriorForParents(Y) * enumerateAll(Util.rest(vars), e);
}
return(sum);
}
public void resetBiases(IRandomVariable rv)
{
for (int j = 0; j < outputs; j++)
{
biases[j] = rv.next();
}
}
public virtual ICategoricalDistribution jointDistribution(params IProposition[] propositions)
{
ProbabilityTable d = null;
IProposition conjProp = ProbUtil.constructConjunction(propositions);
ISet <IRandomVariable> vars = CollectionFactory.CreateSet <IRandomVariable>(conjProp.getUnboundScope());
if (vars.Size() > 0)
{
IRandomVariable[] distVars = new IRandomVariable[vars.Size()];
int i = 0;
foreach (IRandomVariable rv in vars)
{
distVars[i] = rv;
++i;
}
ProbabilityTable ud = new ProbabilityTable(distVars);
object[] values = new object[vars.Size()];
CategoricalDistributionIterator di = new CategoricalDistributionIteratorJointDistribution(conjProp, vars, ud, values);
IRandomVariable[] X = conjProp.getScope().ToArray();
bayesInference.Ask(X, new AssignmentProposition[0], bayesNet).iterateOver(di);
d = ud;
}
else
{
// No Unbound Variables, therefore just return
// the singular probability related to the proposition.
d = new ProbabilityTable();
d.setValue(0, prior(propositions));
}
return(d);
}
public DynamicBayesNet(IBayesianNetwork priorNetwork,
IMap <IRandomVariable, IRandomVariable> X_0_to_X_1,
ISet <IRandomVariable> E_1, params INode[] rootNodes)
: base(rootNodes)
{
foreach (var x0_x1 in X_0_to_X_1)
{
IRandomVariable x0 = x0_x1.GetKey();
IRandomVariable x1 = x0_x1.GetValue();
this.X_0.Add(x0);
this.X_1.Add(x1);
this.X_0_to_X_1.Put(x0, x1);
this.X_1_to_X_0.Put(x1, x0);
}
this.E_1.AddAll(E_1);
// Assert the X_0, X_1, and E_1 sets are of expected sizes
ISet <IRandomVariable> combined = CollectionFactory.CreateSet <IRandomVariable>();
combined.AddAll(X_0);
combined.AddAll(X_1);
combined.AddAll(E_1);
if (SetOps.difference(CollectionFactory.CreateSet <IRandomVariable>(varToNodeMap.GetKeys()), combined).Size() != 0)
{
throw new IllegalArgumentException("X_0, X_1, and E_1 do not map correctly to the Nodes describing this Dynamic Bayesian Network.");
}
this.priorNetwork = priorNetwork;
X_1_VariablesInTopologicalOrder.AddAll(GetVariablesInTopologicalOrder());
X_1_VariablesInTopologicalOrder.RemoveAll(X_0);
X_1_VariablesInTopologicalOrder.RemoveAll(E_1);
}
/**
* Reset this instances persistent variables to be used between called to
* particleFiltering().
*
* @param N
* the number of samples to be maintained
* @param dbn
* a DBN with prior <b>P</b>(<b>X</b><sub>0</sub>), transition
* model <b>P</b>(<b>X</b><sub>1</sub> | <b>X</b><sub>0</sub>),
* sensor model <b>P</b>(<b>E</b><sub>1</sub> |
* <b>X</b><sub>1</sub>)
*/
public void initPersistent(int N, IDynamicBayesianNetwork dbn)
{
this.N = N;
this.dbn = dbn;
// persistent: S, a vector of samples of size N, initially generated
// from <b>P</b>(<b>X</b><sub>0</sub>)
S = new AssignmentProposition[N][];
S_tp1 = new AssignmentProposition[N][];
int[] indexes = new int[N];
for (int i = 0; i < N; ++i)
{
S[i] = new AssignmentProposition[this.dbn.GetX_0().Size()];
S_tp1[i] = new AssignmentProposition[this.dbn.GetX_0().Size()];
indexes[i] = i;
IMap <IRandomVariable, object> sample = priorSampler.priorSample(this.dbn.GetPriorNetwork());
int idx = 0;
foreach (var sa in sample)
{
S[i][idx] = new AssignmentProposition(this.dbn.GetX_0_to_X_1().Get(sa.GetKey()), sa.GetValue());
S_tp1[i][idx] = new AssignmentProposition(this.dbn.GetX_0_to_X_1().Get(sa.GetKey()), sa.GetValue());
idx++;
}
}
sensorModel = new FiniteBayesModel(dbn, new EliminationAsk());
sampleIndexes = new RandVar("SAMPLE_INDEXES", new FiniteIntegerDomain(indexes));
}
public void testGibbsAsk_compare()
{
// create two nodes: parent and child with an arc from parent to child
IRandomVariable rvParent = new RandVar("Parent", new BooleanDomain());
IRandomVariable rvChild = new RandVar("Child", new BooleanDomain());
FullCPTNode nodeParent = new FullCPTNode(rvParent, new double[] { 0.7, 0.3 });
new FullCPTNode(rvChild, new double[] { 0.8, 0.2, 0.2, 0.8 }, nodeParent);
// create net
BayesNet net = new BayesNet(nodeParent);
// query parent probability
IRandomVariable[] rvX = new IRandomVariable[] { rvParent };
// ...given child evidence (true)
AssignmentProposition[] propE = new AssignmentProposition[] { new AssignmentProposition(rvChild, true) };
// sample with LikelihoodWeighting
ICategoricalDistribution samplesLW = new LikelihoodWeighting().Ask(rvX, propE, net, 1000);
Assert.AreEqual(0.9, samplesLW.getValue(true), DELTA_THRESHOLD);
// sample with RejectionSampling
ICategoricalDistribution samplesRS = new RejectionSampling().Ask(rvX, propE, net, 1000);
Assert.AreEqual(0.9, samplesRS.getValue(true), DELTA_THRESHOLD);
// sample with GibbsAsk
ICategoricalDistribution samplesGibbs = new GibbsAsk().Ask(rvX, propE, net, 1000);
Assert.AreEqual(0.9, samplesGibbs.getValue(true), DELTA_THRESHOLD);
}
public override bool holds(IMap <IRandomVariable, object> possibleWorld)
{
bool holds = true;
bool first = true;
IRandomVariable rvL = null;
foreach (IRandomVariable rvC in getScope())
{
if (first)
{
rvL = rvC;
first = false;
continue;
}
if (!possibleWorld.Get(rvL).Equals(possibleWorld.Get(rvC)))
{
holds = false;
break;
}
rvL = rvC;
}
return(holds);
}
public AbstractTermProposition(IRandomVariable var)
{
if (null == var)
{
throw new IllegalArgumentException("The Random Variable for the Term must be specified.");
}
this.termVariable = var;
addScope(this.termVariable);
}
public SymmetricConfidenceInterval(IRandomVariable <T> rv, double confidence)
{
if (confidence < 0 || confidence > 1)
{
throw new ArgumentException("Confidence must be between 0 and 1");
}
alpha = 1 - confidence;
this.rv = rv;
}
public void resetWeights(IRandomVariable rv)
{
for (int i = 0; i < inputs; i++)
{
for (int j = 0; j < outputs; j++)
{
weights[j, i] = rv.next();
}
}
}
public SubsetProposition(string name, IFiniteDomain subsetDomain, IRandomVariable ofVar)
: base(name)
{
if (null == subsetDomain)
{
throw new IllegalArgumentException("Sum Domain must be specified.");
}
this.subsetDomain = subsetDomain;
this.varSubsetOf = ofVar;
addScope(this.varSubsetOf);
}
public void test_indexesOfValue()
{
RandVar X = new RandVar("X", new BooleanDomain());
RandVar Y = new RandVar("Y", new ArbitraryTokenDomain("A", "B", "C"));
RandVar Z = new RandVar("Z", new BooleanDomain());
// An ordered X,Y,Z enumeration of values should look like:
// 00: true, A, true
// 01: true, A, false
// 02: true, B, true
// 03: true, B, false
// 04: true, C, true
// 05: true, C, false
// 06: false, A, true
// 07: false, A, false
// 08: false, B, true
// 09: false, B, false
// 10: false, C, true
// 11: false, C, false
IRandomVariable[] vars = new IRandomVariable[] { X, Y, Z };
IMap <IRandomVariable, object> even = CollectionFactory.CreateInsertionOrderedMap <IRandomVariable, object>();
even.Put(X, true);
CollectionAssert.AreEqual(new int[] { 0, 1, 2, 3, 4, 5 },
ProbUtil.indexesOfValue(vars, 0, even));
even.Put(X, false);
CollectionAssert.AreEqual(new int[] { 6, 7, 8, 9, 10, 11 },
ProbUtil.indexesOfValue(vars, 0, even));
even.Put(Y, "A");
CollectionAssert.AreEqual(new int[] { 0, 1, 6, 7 },
ProbUtil.indexesOfValue(vars, 1, even));
even.Put(Y, "B");
CollectionAssert.AreEqual(new int[] { 2, 3, 8, 9 },
ProbUtil.indexesOfValue(vars, 1, even));
even.Put(Y, "C");
CollectionAssert.AreEqual(new int[] { 4, 5, 10, 11 },
ProbUtil.indexesOfValue(vars, 1, even));
even.Put(Z, true);
CollectionAssert.AreEqual(new int[] { 0, 2, 4, 6, 8, 10 },
ProbUtil.indexesOfValue(vars, 2, even));
even.Put(Z, false);
CollectionAssert.AreEqual(new int[] { 1, 3, 5, 7, 9, 11 },
ProbUtil.indexesOfValue(vars, 2, even));
}
public FullCPTNode(IRandomVariable var, double[] values, params INode[] parents)
: base(var, parents)
{
IRandomVariable[] conditionedOn = new IRandomVariable[GetParents().Size()];
int i = 0;
foreach (INode p in GetParents())
{
conditionedOn[i++] = p.GetRandomVariable();
}
cpt = new CPT(var, values, conditionedOn);
}
public void setExtendedValue(IRandomVariable rv, object value)
{
int idx = varIdxs.Get(rv);
extendedValues[idx] = value;
if (idx >= hiddenStart)
{
extendedIdx = idx;
}
else
{
extendedIdx = hiddenStart - 1;
}
}
public override bool Equals(object o)
{
if (this == o)
{
return(true);
}
if (!(o is IRandomVariable))
{
return(false);
}
// The name (not the name:domain combination) uniquely identifies a Random Variable
IRandomVariable other = (IRandomVariable)o;
return(this.name.Equals(other.getName()));
}
public AbstractNode(IRandomVariable var, params INode[] parents)
{
if (null == var)
{
throw new IllegalArgumentException("Random Variable for Node must be specified.");
}
this.variable = var;
this.parents = CollectionFactory.CreateSet <INode>();
if (null != parents)
{
foreach (INode p in parents)
{
((AbstractNode)p).addChild(this);
this.parents.Add(p);
}
}
this.parents = CollectionFactory.CreateReadOnlySet <INode>(this.parents);
this.children = CollectionFactory.CreateReadOnlySet <INode>(CollectionFactory.CreateSet <INode>());
}
public CPT(IRandomVariable on, double[] values, params IRandomVariable[] conditionedOn)
{
this.on = on;
if (null == conditionedOn)
{
conditionedOn = new IRandomVariable[0];
}
IRandomVariable[] tableVars = new IRandomVariable[conditionedOn.Length + 1];
for (int i = 0; i < conditionedOn.Length; ++i)
{
tableVars[i] = conditionedOn[i];
parents.Add(conditionedOn[i]);
}
tableVars[conditionedOn.Length] = on;
table = new ProbabilityTable(values, tableVars);
onDomain.AddAll(((IFiniteDomain)on.getDomain()).GetPossibleValues());
checkEachRowTotalsOne();
}
/**
*
* @param probabilityChoice
* a probability choice for the sample
* @param Xi
* a Random Variable with a finite domain from which a random
* sample is to be chosen based on the probability choice.
* @param distribution
* Xi's distribution.
* @return a Random Sample from Xi's domain.
*/
public static object sample(double probabilityChoice, IRandomVariable Xi, double[] distribution)
{
IFiniteDomain fd = (IFiniteDomain)Xi.getDomain();
if (fd.Size() != distribution.Length)
{
throw new IllegalArgumentException("Size of domain Xi " + fd.Size()
+ " is not equal to the size of the distribution "
+ distribution.Length);
}
int i = 0;
double total = distribution[0];
while (probabilityChoice > total)
{
++i;
total += distribution[i];
}
return(fd.GetValueAt(i));
}
//
// PRIVATE METHODS
//
private IFactor makeFactor(IRandomVariable var, AssignmentProposition[] e, IBayesianNetwork bn)
{
INode n = bn.GetNode(var);
if (!(n is IFiniteNode))
{
throw new IllegalArgumentException("Elimination-Ask only works with finite Nodes.");
}
IFiniteNode fn = (IFiniteNode)n;
ICollection <AssignmentProposition> evidence = CollectionFactory.CreateQueue <AssignmentProposition>();
foreach (AssignmentProposition ap in e)
{
if (fn.GetCPT().Contains(ap.getTermVariable()))
{
evidence.Add(ap);
}
}
return(fn.GetCPT().GetFactorFor(evidence.ToArray()));
}
public ICategoricalDistribution backward(ICategoricalDistribution b_kp2t, ICollection <AssignmentProposition> e_kp1)
{
ICategoricalDistribution b_kp1t = new ProbabilityTable(b_kp2t.getFor());
// Set up required working variables
IProposition[] props = new IProposition[b_kp1t.getFor().Size()];
int i = 0;
foreach (IRandomVariable rv in b_kp1t.getFor())
{
IRandomVariable prv = tToTm1StateVarMap.Get(rv);
props[i] = new RandVar(prv.getName(), prv.getDomain());
++i;
}
IProposition Xk = ProbUtil.constructConjunction(props);
AssignmentProposition[] ax_kp1 = new AssignmentProposition[tToTm1StateVarMap.Size()];
IMap <IRandomVariable, AssignmentProposition> x_kp1VarAssignMap = CollectionFactory.CreateInsertionOrderedMap <IRandomVariable, AssignmentProposition>();
i = 0;
foreach (IRandomVariable rv in b_kp1t.getFor())
{
ax_kp1[i] = new AssignmentProposition(rv, "<Dummy Value>");
x_kp1VarAssignMap.Put(rv, ax_kp1[i]);
++i;
}
IProposition x_kp1 = ProbUtil.constructConjunction(ax_kp1);
props = e_kp1.ToArray();
IProposition pe_kp1 = ProbUtil.constructConjunction(props);
// ∑<sub>x<sub>k+1</sub></sub>
CategoricalDistributionIterator ib_kp2t = new CategoricalDistributionIteratorImpl2(x_kp1VarAssignMap,
sensorModel, transitionModel, b_kp1t, pe_kp1, Xk, x_kp1);
b_kp2t.iterateOver(ib_kp2t);
return(b_kp1t);
}
public double posteriorForParents(IRandomVariable rv)
{
INode n = bn.GetNode(rv);
if (!(n is IFiniteNode))
{
throw new IllegalArgumentException("Enumeration-Ask only works with finite Nodes.");
}
IFiniteNode fn = (IFiniteNode)n;
object[] vals = new object[1 + fn.GetParents().Size()];
int idx = 0;
foreach (INode pn in n.GetParents())
{
vals[idx] = extendedValues[varIdxs.Get(pn.GetRandomVariable())];
idx++;
}
vals[idx] = extendedValues[varIdxs.Get(rv)];
return(fn.GetCPT().GetValue(vals));
}
private ICollection <IFactor> sumOut(IRandomVariable var, ICollection <IFactor> factors, IBayesianNetwork bn)
{
ICollection <IFactor> summedOutFactors = CollectionFactory.CreateQueue <IFactor>();
ICollection <IFactor> toMultiply = CollectionFactory.CreateQueue <IFactor>();
foreach (IFactor f in factors)
{
if (f.contains(var))
{
toMultiply.Add(f);
}
else
{
// This factor does not contain the variable
// so no need to sum out - see AIMA3e pg. 527.
summedOutFactors.Add(f);
}
}
summedOutFactors.Add(pointwiseProduct(toMultiply).sumOut(var));
return(summedOutFactors);
}
/// <summary>
/// Instantiate a Hidden Markov Model.
/// </summary>
/// <param name="stateVariable">
/// the single discrete random variable used to describe the process states 1,...,S.
/// </param>
/// <param name="transitionModel">
/// the transition model:<para />
/// P(Xt | Xt-1)<para />
/// is represented by an S * S matrix T where
/// Tij= P(Xt = j | Xt-1 = i).
/// </param>
/// <param name="sensorModel">
/// the sensor model in matrix form:<para />
/// P(et | Xt = i) for each state i. For
/// mathematical convenience we place each of these values into an
/// S * S diagonal matrix.
/// </param>
/// <param name="prior">the prior distribution represented as a column vector in Matrix form.</param>
public HiddenMarkovModel(IRandomVariable stateVariable, Matrix transitionModel, IMap <object, Matrix> sensorModel, Matrix prior)
{
if (!stateVariable.getDomain().IsFinite())
{
throw new IllegalArgumentException("State Variable for HHM must be finite.");
}
this.stateVariable = stateVariable;
stateVariableDomain = (IFiniteDomain)stateVariable.getDomain();
if (transitionModel.GetRowDimension() != transitionModel
.GetColumnDimension())
{
throw new IllegalArgumentException("Transition Model row and column dimensions must match.");
}
if (stateVariableDomain.Size() != transitionModel.GetRowDimension())
{
throw new IllegalArgumentException("Transition Model Matrix does not map correctly to the HMM's State Variable.");
}
this.transitionModel = transitionModel;
foreach (Matrix smVal in sensorModel.GetValues())
{
if (smVal.GetRowDimension() != smVal.GetColumnDimension())
{
throw new IllegalArgumentException("Sensor Model row and column dimensions must match.");
}
if (stateVariableDomain.Size() != smVal.GetRowDimension())
{
throw new IllegalArgumentException("Sensor Model Matrix does not map correctly to the HMM's State Variable.");
}
}
this.sensorModel = sensorModel;
if (transitionModel.GetRowDimension() != prior.GetRowDimension() &&
prior.GetColumnDimension() != 1)
{
throw new IllegalArgumentException("Prior is not of the correct dimensions.");
}
this.prior = prior;
}
public RVInfo(IRandomVariable rv)
{
variable = rv;
varDomain = (IFiniteDomain)variable.getDomain();
}
public bool contains(IRandomVariable rv)
{
return(randomVarInfo.GetKeys().Contains(rv));
}
public bool containsValue(IRandomVariable rv)
{
return(varIdxs.Get(rv) <= extendedIdx);
}
public virtual bool Contains(IRandomVariable rv)
{
return(table.contains(rv));
}
public AssignmentProposition(IRandomVariable forVariable, object value)
: base(forVariable)
{
setValue(value);
}
public void test_indexOf()
{
RandVar X = new RandVar("X", new BooleanDomain());
RandVar Y = new RandVar("Y", new ArbitraryTokenDomain("A", "B", "C"));
RandVar Z = new RandVar("Z", new BooleanDomain());
// An ordered X,Y,Z enumeration of values should look like:
// 00: true, A, true
// 01: true, A, false
// 02: true, B, true
// 03: true, B, false
// 04: true, C, true
// 05: true, C, false
// 06: false, A, true
// 07: false, A, false
// 08: false, B, true
// 09: false, B, false
// 10: false, C, true
// 11: false, C, false
IRandomVariable[] vars = new IRandomVariable[] { X, Y, Z };
IMap <IRandomVariable, object> even = CollectionFactory.CreateInsertionOrderedMap <IRandomVariable, object>();
even.Put(X, true);
even.Put(Y, "A");
even.Put(Z, true);
Assert.AreEqual(0, ProbUtil.indexOf(vars, even));
even.Put(Z, false);
Assert.AreEqual(1, ProbUtil.indexOf(vars, even));
even.Put(Y, "B");
even.Put(Z, true);
Assert.AreEqual(2, ProbUtil.indexOf(vars, even));
even.Put(Z, false);
Assert.AreEqual(3, ProbUtil.indexOf(vars, even));
even.Put(Y, "C");
even.Put(Z, true);
Assert.AreEqual(4, ProbUtil.indexOf(vars, even));
even.Put(Z, false);
Assert.AreEqual(5, ProbUtil.indexOf(vars, even));
//
even.Put(X, false);
even.Put(Y, "A");
even.Put(Z, true);
Assert.AreEqual(6, ProbUtil.indexOf(vars, even));
even.Put(Z, false);
Assert.AreEqual(7, ProbUtil.indexOf(vars, even));
even.Put(Y, "B");
even.Put(Z, true);
Assert.AreEqual(8, ProbUtil.indexOf(vars, even));
even.Put(Z, false);
Assert.AreEqual(9, ProbUtil.indexOf(vars, even));
even.Put(Y, "C");
even.Put(Z, true);
Assert.AreEqual(10, ProbUtil.indexOf(vars, even));
even.Put(Z, false);
Assert.AreEqual(11, ProbUtil.indexOf(vars, even));
}
