source("bayesserver.R")
# In this example we programatically create a simple Bayesian network.
# Note that you can automatically define nodes from data using
# classes in BayesServer.Data.Discovery,
# and you can automatically learn the parameters using classes in
# BayesServer.Learning.Parameters,
# however here we build a Bayesian network from scratch.
# If you are using a licensed version of Bayes Server, uncomment the following line and enter your license key
# licenseBayesServer("license-key-goes-here")
network <- new(Network, "Demo")
# add the nodes (variables)
aTrue <- new(State, "True")
aFalse <- new(State, "False")
a = new(Node, "A", toStateArray(aTrue, aFalse))
bTrue <- new(State, "True")
bFalse <- new(State, "False")
b <- new(Node, "B", toStateArray(bTrue, bFalse))
cTrue <- new(State, "True")
cFalse <- new(State, "False")
c <- new(Node, "C", toStateArray(cTrue, cFalse))
dTrue <- new(State, "True")
dFalse <- new(State, "False")
d = new(Node, "D", toStateArray(dTrue, dFalse))
nodes <- network$getNodes()
links <- network$getLinks()
nodes$add(a)
nodes$add(b)
nodes$add(c)
nodes$add(d)
# add some directed links
links$add(new(Link, a, b))
links$add(new(Link, a, c))
links$add(new(Link, b, d))
links$add(new(Link, c, d))
# at this point we have fully specified the structural (graphical) specification of the Bayesian Network.
# We must define the necessary probability distributions for each node.
# Each node in a Bayesian Network requires a probability distribution conditioned on it's parents.
# newDistribution() can be called on a Node to create the appropriate probability distribution for a node
# or it can be created manually.
# The interface Distribution has been designed to represent both discrete and continuous variables,
# As we are currently dealing with discrete distributions, we will use the
# Table class.
# To access the discrete part of a distribution, we use Distribution.Table.
# The Table class is used to define distributions over a number of discrete variables.
tableA <- a$newDistribution()$getTable() # access the table property of the Distribution
# IMPORTANT
# Note that calling Node.newDistribution() does NOT assign the distribution to the node.
# A distribution cannot be assigned to a node until it is correctly specified.
# If a distribution becomes invalid (e.g. a parent node is added), it is automatically set to null.
# as node A has no parents there is no ambiguity about the order of variables in the distribution
tableA$set(0.1, toStateArray(aTrue))
tableA$set(0.9, toStateArray(aFalse))
# now tableA is correctly specified we can assign it to Node A;
a$setDistribution(tableA)
# node B has node A as a parent, therefore its distribution will be P(B|A)
tableB <- b$newDistribution()$getTable()
tableB$set(0.2, toStateArray(aTrue, bTrue))
tableB$set(0.8, toStateArray(aTrue, bFalse))
tableB$set(0.15, toStateArray(aFalse, bTrue))
tableB$set(0.85, toStateArray(aFalse, bFalse))
b$setDistribution(tableB)
# specify P(C|A)
tableC <- c$newDistribution()$getTable()
tableC$set(0.3, toStateArray(aTrue, cTrue))
tableC$set(0.7, toStateArray(aTrue, cFalse))
tableC$set(0.4, toStateArray(aFalse, cTrue))
tableC$set(0.6, toStateArray(aFalse, cFalse))
c$setDistribution(tableC)
# specify P(D|B,C)
tableD <- d$newDistribution()$getTable()
# we could specify the values individually as above, or we can use a TableIterator as follows
iteratorD <- new(TableIterator, tableD, toNodeArray(b, c, d))
iteratorD$copyFrom(c(0.4, 0.6, 0.55, 0.45, 0.32, 0.68, 0.01, 0.99))
d$setDistribution(tableD)
# The network is now fully specified
# If required the network can be saved...
if (FALSE) # change this to true to save the network
{
network$save("fileName.bayes") # replace 'fileName.bayes' with your own path
}
# Now we will calculate P(A|D=True), i.e. the probability of A given the evidence that D is true
# use the factory design pattern to create the necessary inference related objects
factory <- new(RelevanceTreeInferenceFactory)
inference <- factory$createInferenceEngine(network)
queryOptions <- factory$createQueryOptions()
queryOutput <- factory$createQueryOutput()
# we could have created these objects explicitly instead, but as the number of algorithms grows
# this makes it easier to switch between them
evidence <- inference$getEvidence()
evidence$setState(dTrue) # set D = True
queryA <- new(Table, a)
inference$getQueryDistributions()$add(queryA)
inference$query(queryOptions, queryOutput) # note that this can raise an exception (see help for details)
print(sprintf("P(A|D=True) = {%f,%f}", queryA$get(toStateArray(aTrue)), queryA$get(toStateArray(aFalse))))
# Expected output ...
# P(A|D=True) = {0.0980748663101604,0.90192513368984}
# to perform another query we reuse all the objects
# now lets calculate P(A|D=True, C=True)
evidence$setState(cTrue)
# we will also return the log-likelihood of the case
queryOptions$setLogLikelihood(TRUE) # only request the log-likelihood if you really need it, as extra computation is involved
inference$query(queryOptions, queryOutput)
print(sprintf("P(A|D=True, C=True) = {%f,%f}, log-likelihood = %f.", queryA$get(toStateArray(aTrue)), queryA$get(toStateArray(aFalse)), queryOutput$getLogLikelihood()))
# Expected output ...
# P(A|D=True, C=True) = {0.0777777777777778,0.922222222222222}, log-likelihood = -2.04330249506396.
# Note that we can also calculate joint queries such as P(A,B|D=True,C=True)