def eventVarInEvent_test_4(self):
"""
Test varInEvent() method
"""
event = Event(var=self.X, val=self.X.domain[0])
assert (event.varInEvent(self.X))
assert (not event.varInEvent(self.Y))
def eventVarInEvent_test_4(self):
"""
Test varInEvent() method
"""
event = Event(var=self.X, val=self.X.domain[0])
assert(event.varInEvent(self.X))
assert(not event.varInEvent(self.Y))
def eventRemoveVar_test_7(self):
"""
Test setValue method
"""
event = Event(var=self.X, val=self.X.domain[0])
event.removeVar(self.X)
event.removeVar(self.Y) # Already not in event
assert (not event.varInEvent(self.X))
assert (not event.varInEvent(self.Y))
def eventRemoveVar_test_7(self):
"""
Test setValue method
"""
event = Event(var=self.X, val=self.X.domain[0])
event.removeVar(self.X)
event.removeVar(self.Y) # Already not in event
assert(not event.varInEvent(self.X))
assert(not event.varInEvent(self.Y))
def _compute_event_prob(self, event: ppy.Event):
HashableFac.next_id = 0
# create factors
factors = set()
num_to_eliminate = 0
for i in self.network:
# Append factor to factors list, removing observations
fac = self.makeFactor(i.factor, event)
factors.add(HashableFac(fac))
if not event.varInEvent(i.node):
num_to_eliminate += 1
# run variable elimination
for n in range(0, num_to_eliminate):
new_factor_vars = {
} # for each variable, the set of variables in the factor if that variable is eliminated
factors_for_var = {
} # for each variable, the list of factors containing the variable
for hfac in factors:
fac = hfac.fac
rvset = set(fac.rand_vars)
for var in fac.rand_vars:
if var not in new_factor_vars:
new_factor_vars[var] = rvset.copy()
factors_for_var[var] = []
else:
new_factor_vars[var] = new_factor_vars[var].union(
rvset)
factors_for_var[var].append(hfac)
# find best variable to eliminate next according to min-degree strategy
best_var = None
best_size = -1
for var, s in new_factor_vars.items():
if best_var is None or len(s) < best_size:
best_var = var
best_size = len(s)
# eliminate the variable
rm_factors = factors_for_var[best_var]
new_factor = self.sumOut(best_var, rm_factors)
factors = factors.difference(rm_factors)
factors.add(HashableFac(new_factor))
prod = None
for f in factors:
if prod is None:
prod = f.fac
else:
prod = prod.mult(f.fac)
return prod.values[0]
def gibbsAsk(self, query_var, observed, samples_num):
# Result is a list of counts for each value in the domain of the query
# variable. Initialized with 0
res = {i: 0 for i in query_var.domain}
# Assure the observed argument is an Event
if type(observed) != Event:
observed = Event(observed)
# Create non evidence variable list, which are all the variables not
# present in the observations
non_evidence_vars = [i for i in self.network
if not observed.varInEvent(i.node)]
# Get markov blankets for each non evidence variable
mbs = dict()
for i in non_evidence_vars:
mbs[i.node.name] = self.markovBlanket(i)
# Make an initial sample
sample = self.sample(observed)
# Execute for samples_num samples
for i in range(samples_num):
for j in non_evidence_vars:
# Get distribution P(j | mb(j))
dist = j.factor
for k in mbs[j.node.name]:
dist *= k.factor
# Instantiate with previous sample, except for current j
# variable
sample.removeVar(j.node)
dist = dist.instVar(sample)
# Set new random value of current variable in sample
rvalue = self.pickRandomValue(dist.rand_vars[0].domain,
dist.values, random.random())
sample.setValue(j.node, rvalue)
# Increment count
res[rvalue] += 1
# Return the count list normalized
values = [res[i] for i in query_var.domain]
return Factor(query_var, values).normalize(query_var)
def gibbsAsk(self, query_var, observed, samples_num):
# Result is a list of counts for each value in the domain of the query
# variable. Initialized with 0
res = {i: 0 for i in query_var.domain}
# Assure the observed argument is an Event
if type(observed) != Event:
observed = Event(observed)
# Create non evidence variable list, which are all the variables not
# present in the observations
non_evidence_vars = [i for i in self.network
if not observed.varInEvent(i.node)]
# Get markov blankets for each non evidence variable
mbs = dict()
for i in non_evidence_vars:
mbs[i.node.name] = self.markovBlanket(i)
# Make an initial sample
sample = self.sample(observed)
# Execute for samples_num samples
for i in range(samples_num):
for j in non_evidence_vars:
# Get distribution P(j | mb(j))
dist = j.factor
for k in mbs[j.node.name]:
dist *= k.factor
# Instantiate with previous sample, except for current j
# variable
sample.removeVar(j.node)
dist = dist.instVar(sample)
# Set new random value of current variable in sample
rvalue = self.pickRandomValue(dist.rand_vars[0].domain,
dist.values, random.random())
sample.setValue(j.node, rvalue)
# Increment count
res[rvalue] += 1
# Return the count list normalized
values = [res[i] for i in query_var.domain]
return Factor(query_var, values).normalize(query_var)
