def convert_to_table(self, evidence):
"""
This function evaluates a tabular CPT using observed evidence,
by taking 'slices' of the CPT. Returns the 'sliced' CPT and a list
of the observed nodes.
Parameters
----------
evidence: List
A list of any observed evidence, where evidence[i] = [] if
node i is hidden, or evidence[i] = SomeValue if node i has been
observed as having SomeValue.
"""
odom = []
vals = []
positions = []
count = 0
for i in self.domain:
if type(evidence[i]) != list:
odom.append(i)
vals.append(evidence[i])
positions.append(count)
count = count + 1
"""
The following code has the effect of 'slicing' the table. The idea is to
select a certain slice out of each dimension, in this case, select slice
vals[i] out of dimension positions[i]. So if positions = [0, 2, 3], and
we were slicing 4-D array T, the resulting slice would be equal to
T[vals[0], :, vals[1], vals[2]].
"""
index = mk_multi_index(len(self.domain), positions, vals)
self.T = self.T[index]
self.T = self.T.squeeze()
return odom
def test_mk_multi_index():
"""
FUNCTION: mk_multi_index, in general.py.
"""
"""Execute function"""
index = general.mk_multi_index(3, [1], [1])
"""Assert the function executed correctly"""
assert index == [slice(None, None, None), slice(1, 2, None), \
slice(None, None, None)]
def test_mk_multi_index():
"""
FUNCTION: mk_multi_index, in general.py.
"""
"""Execute function"""
index = general.mk_multi_index(3, [1], [1])
"""Assert the function executed correctly"""
assert index == [slice(None, None, None), slice(1, 2, None), slice(None, None, None)]
def convert_to_table(self, domain, evidence=[]):
"""
This function evaluates a tabular CPD's CPT using observed evidence,
by taking 'slices' of the CPT. Returns the 'sliced' CPT and a list
of the observed nodes.
Parameters
----------
domain: List
The domain over which the CPD is defined, which is a list of
indices of the nodes that the CPD encompasses.
evidence: List
A list of any observed evidence, where evidence[i] = [] if
node i is hidden, or evidence[i] = SomeValue if node i has been
observed as having SomeValue.
"""
odom = []
vals = []
positions = []
count = 0
"""If there is any observed evidence"""
if len(evidence) != 0:
"""For every node in the CPDs domain"""
for i in domain:
"""If this node has been observed"""
if evidence[i] is not None:
"""Add it to the list of observed nodes"""
odom.append(i)
vals.append(evidence[i])
positions.append(count)
count = count + 1
"""
The following code has the effect of 'slicing' the table. The idea is to
select a certain slice out of each dimension, in this case, select slice
vals[i] out of dimension positions[i]. So if positions = [0, 2, 3], and
we were slicing 4-D array T, the resulting slice would be equal to
T[vals[0], :, vals[1], vals[2]]. This has the effect of clamping
observed variables at their observed values.
"""
index = general.mk_multi_index(len(domain), positions, vals)
T = self.CPT[index]
T = T.squeeze()
return [T, odom]
def convert_to_table(self, domain, evidence=[]):
"""
This function evaluates a tabular CPD's CPT using observed evidence,
by taking 'slices' of the CPT. Returns the 'sliced' CPT and a list
of the observed nodes.
Parameters
----------
domain: List
The domain over which the CPD is defined, which is a list of
indices of the nodes that the CPD encompasses.
evidence: List
A list of any observed evidence, where evidence[i] = [] if
node i is hidden, or evidence[i] = SomeValue if node i has been
observed as having SomeValue.
"""
odom = []
vals = []
positions = []
count = 0
"""If there is any observed evidence"""
if len(evidence) != 0:
"""For every node in the CPDs domain"""
for i in domain:
"""If this node has been observed"""
if evidence[i] != []:
"""Add it to the list of observed nodes"""
odom.append(i)
vals.append(evidence[i])
positions.append(count)
count = count + 1
"""
The following code has the effect of 'slicing' the table. The idea is to
select a certain slice out of each dimension, in this case, select slice
vals[i] out of dimension positions[i]. So if positions = [0, 2, 3], and
we were slicing 4-D array T, the resulting slice would be equal to
T[vals[0], :, vals[1], vals[2]]. This has the effect of clamping
observed variables at their observed values.
"""
index = general.mk_multi_index(len(domain), positions, vals)
T = self.CPT[index]
T = T.squeeze()
return [T, odom]
def convert_to_table(self, evidence):
"""
This function evaluates a tabular CPT using observed evidence,
by taking 'slices' of the CPT. Returns the 'sliced' CPT and a list
of the observed nodes.
Parameters
----------
evidence: List
A list of any observed evidence, where evidence[i] = [] if
node i is hidden, or evidence[i] = SomeValue if node i has been
observed as having SomeValue.
"""
odom = []
vals = []
positions = []
count = 0
for i in self.domain:
if evidence[i] is not None:
odom.append(i)
vals.append(evidence[i])
positions.append(count)
count = count + 1
"""
The following code has the effect of 'slicing' the table. The idea is to
select a certain slice out of each dimension, in this case, select slice
vals[i] out of dimension positions[i]. So if positions = [0, 2, 3], and
we were slicing 4-D array T, the resulting slice would be equal to
T[vals[0], :, vals[1], vals[2]].
"""
index = mk_multi_index(len(self.domain), positions, vals)
self.T = self.T[index]
self.T = self.T.squeeze()
return odom
