def setup(self, network, inference_engine, query_options):
distributions = []
variables = []
for variable_name in [self._variable_a_name, self._variable_b_name]:
variable = bayesianpy.network.get_variable(network, variable_name)
if not bayesianpy.network.get_variable(network, variable_name):
raise ValueError(
"Variable {} does not exist in the network".format(
variable_name))
if bayesianpy.network.is_variable_continuous(variable_name):
distributions.append(bayesServer().CLGaussian(variable))
else:
distributions.append(bayesServer().Table(variable))
variables.append(variable)
for query in distributions:
inference_engine.getQueryDistributions().add(
bayesServerInference().QueryDistribution(query))
query_options.setQueryEvidenceMode(
bayesServerInference().QueryEvidenceMode.RETRACT_QUERY_EVIDENCE)
self._distributions = distributions
self._variables = variables
def setup(self, network, inference_engine, query_options):
contexts = []
for h in self._head_variables + self._tail_variables:
v = bayesianpy.network.get_variable(network, h)
if bayesianpy.network.is_variable_discrete(v):
if h in self._head_variables:
#raise ValueError("Bayespy only supports discrete tail variables (BayesServer is fine with it though!)")
self._is_discrete_head = True
self._discrete_variables.append(v.getName())
else:
if h in self._tail_variables:
raise ValueError(
"Bayespy only supports continuous head variables (BayesServer is fine with it though!)"
)
contexts.append(bayesServer().VariableContext(
v,
bayesServer().HeadTail.HEAD
if h in self._head_variables else bayesServer().HeadTail.TAIL))
self._network = network
if self._is_discrete_head:
self._distribution = bayesServer().Table(contexts)
else:
self._distribution = bayesServer().CLGaussian(contexts)
self._query_distribution = bayesServerInference().QueryDistribution(
self._distribution)
inference_engine.getQueryDistributions().add(self._query_distribution)
def __init__(self, network, inference_engine, logger):
self._factory = bayesServerInference().RelevanceTreeInferenceFactory()
self._query_options = self._factory.createQueryOptions()
self._query_output = self._factory.createQueryOutput()
self._inference_engine = inference_engine
self._network = network
self._logger = logger
def setup(self, network, inference_engine, query_options):
distribution = None
self._variable = bayesianpy.network.get_variable(
network, self._target_variable_name)
if bayesianpy.network.is_variable_discrete(self._variable):
distribution = bayesServer().Table(self._variable)
if distribution is None:
raise ValueError(
"{} needs to be discrete in QueryMostLikelyState".format(
self._target_variable_name))
query_options.setQueryEvidenceMode(
bayesServerInference().QueryEvidenceMode.RETRACT_QUERY_EVIDENCE)
qd = bayesServerInference().QueryDistribution(distribution)
self._distribution = distribution
inference_engine.getQueryDistributions().add(qd)
def setup(self, network, inference_engine, query_options):
self._variable = bayesianpy.network.get_variable(
network, self._variable_name)
if not bayesianpy.network.get_variable(network, self._variable_name):
raise ValueError(
"Variable {} does not exist in the network".format(
self._variable_name))
if not bayesianpy.network.is_variable_continuous(self._variable):
raise ValueError("{} needs to be continuous.".format(
self._variable_name))
self._query = bayesServer().CLGaussian(self._variable)
if self._retract_evidence:
query_options.setQueryEvidenceMode(bayesServerInference(
).QueryEvidenceMode.RETRACT_QUERY_EVIDENCE)
inference_engine.getQueryDistributions().add(
bayesServerInference().QueryDistribution(self._query))
def setup(self, network, inference_engine, query_options):
variables = [
bayesianpy.network.get_variable(network, n)
for n in self._variable_names
]
if len(variables) == 0:
raise ValueError(
"QueryLogLikelihood: Requires a non-empty list for creating a distribution"
)
if len(variables) == 1:
self._distribution = bayesServer().CLGaussian(variables[0])
else:
self._distribution = bayesServer().CLGaussian(variables)
query_options.setQueryEvidenceMode(
bayesServerInference().QueryEvidenceMode.RETRACT_QUERY_EVIDENCE)
qd = bayesServerInference().QueryDistribution(self._distribution)
qd.setQueryLogLikelihood(True)
self._query_distribution = qd
inference_engine.getQueryDistributions().add(qd)
def create(self, loglikelihood=False, conflict=False, retract=False):
query_options = self.get_inference_factory().createQueryOptions()
query_output = self.get_inference_factory().createQueryOutput()
inference_engine = self.get_inference_factory().createInferenceEngine(
self._network)
query_options.setLogLikelihood(loglikelihood)
query_options.setConflict(conflict)
if retract:
query_options.setQueryEvidenceMode(bayesServerInference(
).QueryEvidenceMode.RETRACT_QUERY_EVIDENCE)
return inference_engine, query_options, query_output
def get_inference_factory():
if InferenceEngine._inference_factory is None:
InferenceEngine._inference_factory = bayesServerInference(
).RelevanceTreeInferenceFactory()
return InferenceEngine._inference_factory
