def test_gbt(self):
def test(m, places):
self.assertAlmostEqual(0.3 * 0.8 / (1 - 0.7 * 0.2), m['ab'], places)
self.assertAlmostEqual(0.3 * 0.2 / (1 - 0.7 * 0.2), m['a'], places)
self.assertAlmostEqual(0.7 * 0.8 / (1 - 0.7 * 0.2), m['b'], places)
pl = [('a', 0.3), ('b', 0.8), ('c', 0.0)]
test(MassFunction.gbt(pl), 10)
test(MassFunction.gbt(pl, sample_count=10000), 2)
pl = {'a':0.3, 'b':0.8, 'c':0.0, 'd':1.0}
self._assert_equal_belief(MassFunction.gbt(pl), MassFunction.gbt(pl, sample_count=10000), 1)
def test_markov(self):
def test(m, places):
self.assertAlmostEqual(0.4 * 0.8, m[(4, 6)], places)
self.assertAlmostEqual(0.4 * 0.2, m[(5,)], places)
self.assertAlmostEqual(0.6 * 0.2 * 0.2, m[(0, 1)], places)
self.assertAlmostEqual(0.6 * 0.2 * 0.8, m[(-1, 1)], places)
self.assertAlmostEqual(0.6 * 0.2 * 0.8, m[(0, 2)], places)
self.assertAlmostEqual(0.6 * 0.8 * 0.8, m[(-1, 0, 1, 2)], places)
m = MassFunction([((0, 1), 0.6), ((5,), 0.4)])
transition_model = lambda s: MassFunction([((s - 1, s + 1), 0.8), ((s,), 0.2)])
transition_model_mc = lambda s, n: transition_model(s).sample(n)
test(m.markov(transition_model), 10)
test(m.markov(transition_model_mc, sample_count=10000), 2)
def test_combine_gbt(self):
pl = [('b', 0.8), ('c', 0.5)]
correct = self.m1.combine_conjunctive(MassFunction.gbt(pl))
self._assert_equal_belief(correct, self.m1.combine_gbt(pl), 10)
self._assert_equal_belief(self.m1.combine_gbt(pl), self.m1.combine_gbt(pl, sample_count=10000), 1)
self._assert_equal_belief(self.m2.combine_gbt(pl), self.m2.combine_gbt(pl, sample_count=10000), 1)
# Bayesian special case
p_prior = self.m1.pignistic()
p_posterior = p_prior.combine_gbt(pl)
p_correct = MassFunction()
for s, l in pl:
p_correct[(s,)] = l * p_prior[(s,)]
p_correct.normalize()
self._assert_equal_belief(p_correct, p_posterior, 10)
def test_from_samples(self):
"""
Example 1 (default) and example 7 (ordered) from:
T. Denoeux (2006), "Constructing belief functions from sample data using multinomial confidence regions",
International Journal of Approximate Reasoning 42, 228-252.
Example 6 (consonant) from:
A. Aregui, T. Denoeux (2008), "Constructing consonant belief functions from sample data using confidence sets of pignistic probabilities",
International Journal of Approximate Reasoning 49, 575-594.
"""
precipitation_data = {1:48, 2:17, 3:19, 4:11, 5:6, 6:9}
failure_mode_data = {1:5, 2:11, 3:19, 4:30, 5:58, 6:67, 7:92, 8:118, 9:173, 10:297}
psych_data = {1:91, 2:49, 3:37, 4:43}
# default
m = MassFunction.from_samples(psych_data, 0.05, mode='default')
p_lower, p_upper = MassFunction._confidence_intervals(psych_data, 0.05)
def p_lower_set(hs):
l = u = 0
for h in psych_data.keys():
if h in hs:
l += p_lower[h]
else:
u += p_upper[h]
return max(l, 1 - u)
bel_sum = 0
for h in m.all():
bel = m.bel(h)
bel_sum += bel
self.assertLessEqual(bel, p_lower_set(h)) # constraint (24)
self.assertEqual(1, sum(m.values())) # constraint (25)
self.assertGreaterEqual(min(m.values()), 0) # constraint (26)
self.assertGreaterEqual(bel_sum, 6.23) # optimization criterion
# ordered
m = MassFunction.from_samples(precipitation_data, 0.05, mode='ordered')
self.assertAlmostEqual(0.32, m[(1,)], 2)
self.assertAlmostEqual(0.085, m[(2,)], 3)
self.assertAlmostEqual(0.098, m[(3,)], 3)
self.assertAlmostEqual(0.047, m[(4,)], 3)
self.assertAlmostEqual(0.020, m[(5,)], 3)
self.assertAlmostEqual(0.035, m[(6,)], 3)
self.assertAlmostEqual(0.13, m[range(1, 5)], 2)
self.assertAlmostEqual(0.11, m[range(1, 6)], 2)
self.assertAlmostEqual(0.012, m[range(2, 6)], 2)
self.assertAlmostEqual(0.14, m[range(2, 7)], 2)
# consonant
poss = {1: 0.171, 2: 0.258, 3: 0.353, 4: 0.462, 5: 0.688, 6: 0.735, 7: 0.804, 8: 0.867, 9: 0.935, 10: 1.0} # 8: 0.873
m = MassFunction.from_samples(failure_mode_data, 0.1, mode='consonant')
self._assert_equal_belief(MassFunction.from_possibility(poss), m, 1)
# consonant-approximate
m = MassFunction.from_samples(failure_mode_data, 0.1, mode='consonant-approximate')
poss = {1: 0.171, 2: 0.258, 3: 0.353, 4: 0.462, 5: 0.688, 6: 0.747, 7: 0.875, 8: 0.973, 9: 1.0, 10: 1.0}
self._assert_equal_belief(MassFunction.from_possibility(poss), m, 2)
# bayesian
m = MassFunction.from_samples(precipitation_data, 0.05, mode='bayesian')
for e, n in precipitation_data.items():
self.assertEqual(n / sum(precipitation_data.values()), m[(e,)])
def test_combine_cautious(self):
"""
Examples from:
T. Denoeux (2008), "Conjunctive and disjunctive combination of belief functions induced by nondistinct bodies of evidence",
Artificial Intelligence 172, 234-264.
"""
m1 = MassFunction({'ab':0.3, 'bc':0.5, 'abc':0.2})
m2 = MassFunction({'b':0.3, 'bc':0.4, 'abc':0.3})
m = m1.combine_cautious(m2)
self.assertAlmostEqual(0.0, m[''])
self.assertAlmostEqual(0.0, m['a'])
self.assertAlmostEqual(0.6, m['b'])
self.assertAlmostEqual(0.12, m['ab'])
self.assertAlmostEqual(0.0, m['c'])
self.assertAlmostEqual(0.0, m['ac'])
self.assertAlmostEqual(0.2, m['bc'])
self.assertAlmostEqual(0.08, m['abc'])
def test_pignistic_inverse(self):
"""
Example 1 from:
A. Aregui, T. Denoeux (2008), "Constructing consonant belief functions from sample data using confidence sets of pignistic probabilities",
International Journal of Approximate Reasoning 49, 575-594.
"""
p = MassFunction({'a':0.7, 'b':0.2, 'c':0.1})
m = MassFunction.pignistic_inverse(p)
self.assertEqual(0.5, m['a'])
self.assertAlmostEqual(0.2, m['ab'])
self.assertAlmostEqual(0.3, m['abc'])
def test_from_possibility(self):
"""
Example 1 from:
D. Dubois, H. Prade, P. Smets (2008), "A definition of subjective possibility",
International Journal of Approximate Reasoning 48 (2), 352-364.
"""
x = 0.6
poss = {'a':1, 'b':x, 'c':1-x}
m = MassFunction.from_possibility(poss)
self.assertEqual(1 - x, m['a'])
self.assertEqual(2 * x - 1, m['ab'])
self.assertEqual(1 - x, m['abc'])
def test_weight_function(self):
"""
Examples from:
T. Denoeux (2008), "Conjunctive and disjunctive combination of belief functions induced by nondistinct bodies of evidence",
Artificial Intelligence 172, 234-264.
"""
m1 = MassFunction({'ab':0.3, 'bc':0.5, 'abc':0.2})
w1 = m1.weight_function()
self.assertAlmostEqual(1.0, w1[frozenset('')])
self.assertAlmostEqual(1.0, w1[frozenset('a')])
self.assertAlmostEqual(7./4., w1[frozenset('b')])
self.assertAlmostEqual(2./5., w1[frozenset('ab')])
self.assertAlmostEqual(1.0, w1[frozenset('c')])
self.assertAlmostEqual(1.0, w1[frozenset('ac')])
self.assertAlmostEqual(2./7., w1[frozenset('bc')])
m2 = MassFunction({'b':0.3, 'bc':0.4, 'abc':0.3})
w2 = m2.weight_function()
self.assertAlmostEqual(1.0, w2[frozenset('')])
self.assertAlmostEqual(1.0, w2[frozenset('a')])
self.assertAlmostEqual(0.7, w2[frozenset('b')])
self.assertAlmostEqual(1.0, w2[frozenset('ab')])
self.assertAlmostEqual(1.0, w2[frozenset('c')])
self.assertAlmostEqual(1.0, w2[frozenset('ac')])
self.assertAlmostEqual(3./7., w2[frozenset('bc')])
def test_confidence_intervals(self):
"""
Numbers taken from:
W.L. May, W.D. Johnson, A SAS macro for constructing simultaneous confidence intervals for multinomial proportions,
Computer methods and Programs in Biomedicine 53 (1997) 153–162.
"""
hist = {1:91, 2:49, 3:37, 4:43}
lower, upper = MassFunction._confidence_intervals(hist, 0.05)
self.assertAlmostEqual(0.33, lower[1], places=2)
self.assertAlmostEqual(0.16, lower[2], places=2)
self.assertAlmostEqual(0.11, lower[3], places=2)
self.assertAlmostEqual(0.14, lower[4], places=2)
for h, p_u in upper.items():
p = hist[h] / sum(hist.values())
self.assertAlmostEqual(2 * p - lower[h], p_u, places=1)
def test_from_array(self):
self._assert_equal_belief(self.m1, MassFunction.from_array(self.m1.to_array(), self.m1.frame()))
def test_to_array_index(self):
self.assertEqual(0, MassFunction._to_array_index((), ('a', 'b', 'c')))
self.assertEqual(1, MassFunction._to_array_index(('a',), ('a', 'b', 'c')))
self.assertEqual(2, MassFunction._to_array_index(('b',), ('a', 'b', 'c')))
self.assertEqual(4, MassFunction._to_array_index(('c',), ('a', 'b', 'c')))
self.assertEqual(7, MassFunction._to_array_index(('a', 'b', 'c'), ('a', 'b', 'c')))
def test_frame(self):
self.assertEqual({'a', 'b', 'c', 'd'}, self.m1.frame())
self.assertEqual({'a', 'b', 'c'}, self.m2.frame())
self.assertEqual(set(), MassFunction().frame())
def test_gbt_pignistic(self):
likelihoods = {'a': 0.3, 'b': 0.8, 'c': 0.0, 'd': 0.5, 'e': 1.0}
p = MassFunction.gbt(likelihoods).pignistic()
for s in p:
self.assertAlmostEqual(p[s],
gbt_pignistic(tuple(s)[0], likelihoods), 8)
def error_combine_gbt_1000_imp():
m = MassFunction.gbt(random_likelihoods(6))
lh = random_likelihoods(10)
return measure_error(m.combine_gbt(lh), m.combine_gbt, lh, sample_count=1000, importance_sampling=True)
def time_markov():
m = MassFunction.gbt(random_likelihoods(4))
return measure_time(MassFunction.gbt(random_likelihoods(4)).markov, lambda s: m)
def time_combine_gbt():
return measure_time(MassFunction.gbt(random_likelihoods(6)).combine_gbt, random_likelihoods(6))
def time_combine_gbt_1000():
return measure_time(MassFunction.gbt(random_likelihoods(6)).combine_gbt,
random_likelihoods(6),
sample_count=1000)
def time_combine_gbt():
return measure_time(
MassFunction.gbt(random_likelihoods(6)).combine_gbt,
random_likelihoods(6))
def time_combine_disjunctive_1000():
m1 = MassFunction.gbt(random_likelihoods(6))
m2 = MassFunction.gbt(random_likelihoods(6))
return measure_time(m1.combine_disjunctive, m2, sample_count=1000)
def time_combine_disjunctive():
m1 = MassFunction.gbt(random_likelihoods(6))
m2 = MassFunction.gbt(random_likelihoods(6))
return measure_time(m1.combine_disjunctive, m2)
#n_bits = ecg_signal[3]
#ecg_signal = ecg_signal[4:]
return ev_dist
# Read prob distribution from MLII
ev_dist_MLII = read_ev_dist('ev_dist_MLII_Shanon')
# Read prob distribution from RR
ev_dist_RR = read_ev_dist('ev_dist_RR_Shanon')
# for each instance
final_output = list()
for i in range(0, len(ev_dist_RR)):
# Make the mass asignation
m1 = MassFunction(ev_dist_MLII[i])
m2 = MassFunction(ev_dist_RR[i])
# compute the combination with DS
#m1_2_disj = m1.combine_disjunctive(m2)
m1_2 = m1.combine_conjunctive(m2)
# Pignistic to make a decision
output = m1_2.pignistic()
# Keep output
output_array = [output['N'], output['S'], output['V'], output['F']]
#print(output_array)
max_val = max(output_array)
decision = output_array.index(max_val)
#print('Class: ' + str(decision) + ' val = ' + str(max_val))
"""
Author: Sari Haj Hussein
"""
from pyds import MassFunction
from pyuds import pyuds
import cgi
import cgitb
formhtml = """Content-Type: text/html\n\n
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>pyuds Web Interface</title>
<script type="text/javascript">
function MM_uncertaintyMenu(targ,selObj,restore){
var verboseCheckBox = document.getElementById("verbose");
if (selObj.selectedIndex == 2)
verboseCheckBox.disabled = false;
else
verboseCheckBox.disabled = true;
}
</script>
</head>
<body>
<center>
<table>
<tr>
<td>
<p style="font-size:72px;font-weight:bold;margin:auto"><a href="https://sourceforge.net/projects/pyuds/" target="_blank" style="text-decoration:none;color:#000;outline:none">pyuds</a>
df = pd.DataFrame({
"m": ms,
"Bel": beliefs,
"Pl": plausibilities
},
index=hypotheses)
return df
########### EXERCICE 1
''' OMEGA = {Setosa (S), Versicolor (V), Virginica (I) } '''
# 1/ Modélisation des connaissances
m1 = MassFunction({'V': 0.6, 'SVI': 0.4})
m2 = MassFunction({'S': 0.1, 'SI': 0.5, 'SVI': 0.4})
m3 = MassFunction({'SVI': 1})
print("1/ Modélisation des connaissances :\n")
print('M1 : ' + str(m1))
print('M2 : ' + str(m2))
print('M3 : ' + str(m3) + "\n\n\n")
# 2/ Calcul des degrés de croyance et des degrés de plausibilité du premier expert
df_m1 = calcul_degres_croyances_plausibilite(m1)
print(
"2/ Calcul des degrés de croyance et des degrés de plausibilité du premier expert\n"
)
print(df_m1.to_markdown())
def test_multiple_dimensions(self):
md1 = MassFunction({(('a', 1), ('b', 2)): 0.8, (('a', 1), ): 0.2})
md2 = MassFunction({(('a', 1), ('b', 2), ('c', 1)): 1.0})
md12 = md1 & md2
self.assertAlmostEqual(0.2, md12[{('a', 1)}])
self.assertAlmostEqual(0.8, md12[{('a', 1), ('b', 2)}])
def test_gbt_q(self):
likelihoods = {'a':0.3, 'b':0.8, 'c':0.0, 'd':0.5}
m = MassFunction.gbt(likelihoods)
for h in m:
self.assertAlmostEqual(m.q(h), gbt_q(h, likelihoods), 8)
def time_combine_gbt_1000_imp():
return measure_time(MassFunction.gbt(random_likelihoods(6)).combine_gbt,
random_likelihoods(6),
sample_count=1000,
importance_sampling=True)
def time_combine_gbt_1000_imp():
return measure_time(MassFunction.gbt(random_likelihoods(6)).combine_gbt, random_likelihoods(6), sample_count=1000, importance_sampling=True)
def time_pignistic():
return measure_time(MassFunction.gbt(random_likelihoods(12)).pignistic)
def error_gbt_1000():
lh = random_likelihoods(10)
return measure_error(MassFunction.gbt(lh), MassFunction.gbt, lh, sample_count=1000)
def time_markov():
m = MassFunction.gbt(random_likelihoods(4))
return measure_time(
MassFunction.gbt(random_likelihoods(4)).markov, lambda s: m)
def time_q_h():
return measure_time(MassFunction.gbt(random_likelihoods(12)).q, frozenset(range(10)))
def time_markov_1000():
samples = MassFunction.gbt(random_likelihoods(4)).sample(1000)
return measure_time(MassFunction.gbt(random_likelihoods(4)).markov,
lambda s, n: samples[:n],
sample_count=1000)
def test_from_array(self):
self._assert_equal_belief(
self.m1,
MassFunction.from_array(self.m1.to_array(self.m1.frame()),
self.m1.frame()))
def error_gbt_1000():
lh = random_likelihoods(10)
return measure_error(MassFunction.gbt(lh),
MassFunction.gbt,
lh,
sample_count=1000)
def test_norm(self):
self.assertEqual(0, self.m1.norm(self.m1))
self.assertEqual(0, self.m1.norm(self.m1, p=1))
m3 = MassFunction({'e': 1.0})
len_m1 = sum([v**2 for v in self.m1.values()])
self.assertEqual((1 + len_m1)**0.5, self.m1.norm(m3))
def time_bel_h():
return measure_time(MassFunction.gbt(random_likelihoods(12)).bel,
hypothesis=frozenset(range(10)))
def test_from_array_index(self):
self.assertEqual(frozenset(), MassFunction._from_array_index(0, ('a', 'b', 'c')))
self.assertEqual(frozenset(('a',)), MassFunction._from_array_index(1, ('a', 'b', 'c')))
self.assertEqual(frozenset(('b',)), MassFunction._from_array_index(2, ('a', 'b', 'c')))
self.assertEqual(frozenset(('c',)), MassFunction._from_array_index(4, ('a', 'b', 'c')))
self.assertEqual(frozenset(('a', 'b', 'c')), MassFunction._from_array_index(7, ('a', 'b', 'c')))
def time_from_bel():
bel = MassFunction({(s, ): 1.0 for s in range(10)}).normalize().bel()
return measure_time(MassFunction.from_bel, bel)
def time_from_pl():
pl = MassFunction({(s, ): 1.0 for s in range(10)}).normalize().pl()
return measure_time(MassFunction.from_pl, pl)
def time_q_h():
return measure_time(
MassFunction.gbt(random_likelihoods(12)).q, frozenset(range(10)))
def test_gbt_m(self):
likelihoods = [('a', 0.3), ('b', 0.8), ('c', 0.0), ('d', 0.5)] # likelihoods as a list
m = MassFunction.gbt(likelihoods)
for h, v in m.items():
self.assertAlmostEqual(v, gbt_m(h, likelihoods), 8)
def time_q():
return measure_time(
MassFunction({(s, ): 1.0
for s in range(12)}).normalize().q)
def test_from_bel(self):
self._assert_equal_belief(self.m1, MassFunction.from_bel(self.m1.bel()), 8)
self._assert_equal_belief(self.m2, MassFunction.from_bel(self.m2.bel()), 8)
self._assert_equal_belief(self.m3, MassFunction.from_bel(self.m3.bel()), 8)
def time_from_q():
q = MassFunction({(s, ): 1.0 for s in range(10)}).normalize().q()
return measure_time(MassFunction.from_q, q)
def time_combine_gbt_1000():
return measure_time(MassFunction.gbt(random_likelihoods(6)).combine_gbt, random_likelihoods(6), sample_count=1000)
def time_combine_disjunctive():
m1 = MassFunction.gbt(random_likelihoods(6))
m2 = MassFunction.gbt(random_likelihoods(6))
return measure_time(m1.combine_disjunctive, m2)
def time_pignistic():
return measure_time(MassFunction.gbt(random_likelihoods(12)).pignistic)
class PyDSTest(unittest.TestCase):
def setUp(self):
self.m1 = MassFunction({'a': 0.4, 'b': 0.2, 'ad': 0.1, 'abcd': 0.3})
self.m2 = MassFunction({'b': 0.5, 'c': 0.2, 'ac': 0.3, 'a': 0.0})
self.m3 = MassFunction({
(): 0.4,
'c': 0.2,
'ac': 0.3,
'ab': 0.1
}) # unnormalized mass function
random.seed(0) # make tests deterministic
def _assert_equal_belief(self, m1, m2, places=8):
for h in m1.focal() | m2.focal():
self.assertAlmostEqual(m1[h], m2[h], places)
def test_init(self):
"""Test equivalence of different mass function initialization methods."""
m1 = MassFunction([(('a', ), 0.4), (('b', ), 0.2), (('a', 'd'), 0.1),
(('a', 'b', 'c', 'd'), 0.3)])
self.assertEqual(self.m1, m1)
m1 = MassFunction([('a', 0.4), ('b', 0.2), ('ad', 0.1), ('abcd', 0.3)])
self.assertEqual(self.m1, m1)
def test_items(self):
self.assertEqual(0.0, self.m1['x'])
self.m1['ad'] += 0.5
self.assertEqual(0.6, self.m1['ad'])
def test_copy(self):
c = self.m1.copy()
for k in self.m1.keys():
self.assertEqual(self.m1.bel(k), c.bel(k))
c['a'] = 0.3
# assert that the original object remains unchanged
self.assertEqual(0.4, self.m1['a'])
def test_del(self):
del self.m1['a']
self.assertEqual(3, len(self.m1))
self.assertEqual(0.0, self.m1['a'])
def test_bel(self):
# compute the belief of a single hypothesis
self.assertEqual(0.4, self.m1.bel('a'))
self.assertEqual(0.5, self.m1.bel('ad'))
self.assertEqual(1, self.m1.bel('abcd'))
self.assertEqual(0.0, self.m3.bel(''))
self.assertEqual(0.0, self.m3.bel('a'))
self.assertEqual(0.5, self.m3.bel('ac'))
self.assertAlmostEqual(0.6, self.m3.bel('abc'))
# compute the entire belief function
bel2 = self.m2.bel()
self.assertEqual(8, len(bel2))
for h, v in bel2.items():
self.assertEqual(self.m2.bel(h), v)
bel3 = self.m3.bel()
self.assertEqual(8, len(bel3))
for h, v in bel3.items():
self.assertEqual(self.m3.bel(h), v)
def test_from_bel(self):
self._assert_equal_belief(self.m1,
MassFunction.from_bel(self.m1.bel()), 8)
self._assert_equal_belief(self.m2,
MassFunction.from_bel(self.m2.bel()), 8)
self._assert_equal_belief(self.m3,
MassFunction.from_bel(self.m3.bel()), 8)
def test_pl(self):
# compute the plausibility of a single hypothesis
self.assertEqual(0.8, self.m1.pl('a'))
self.assertEqual(0.5, self.m1.pl('b'))
self.assertEqual(0.8, self.m1.pl('ad'))
self.assertEqual(1, self.m1.pl('abcd'))
self.assertEqual(0.0, self.m3.pl(''))
self.assertAlmostEqual(0.1, self.m3.pl('b'))
self.assertAlmostEqual(0.6, self.m3.pl('abc'))
# compute the entire plausibility function
pl2 = self.m2.pl()
self.assertEqual(8, len(pl2))
for h, v in pl2.items():
self.assertEqual(self.m2.pl(h), v)
pl3 = self.m3.pl()
self.assertEqual(8, len(pl3))
for h, v in pl3.items():
self.assertEqual(self.m3.pl(h), v)
def test_from_pl(self):
self._assert_equal_belief(self.m1, MassFunction.from_pl(self.m1.pl()),
8)
self._assert_equal_belief(self.m2, MassFunction.from_pl(self.m2.pl()),
8)
self._assert_equal_belief(self.m3, MassFunction.from_pl(self.m3.pl()),
8)
def test_q(self):
# compute the commonality of a single hypothesis
self.assertEqual(0.8, self.m1.q('a'))
self.assertEqual(0.5, self.m1.q('b'))
self.assertEqual(0.4, self.m1.q('ad'))
self.assertEqual(0.3, self.m1.q('abcd'))
self.assertEqual(1.0, self.m3.q(''))
self.assertEqual(0.4, self.m3.q('a'))
self.assertEqual(0.3, self.m3.q('ac'))
# compute the entire commonality function
q2 = self.m2.q()
self.assertEqual(8, len(q2))
for h, v in q2.items():
self.assertEqual(self.m2.q(h), v)
q3 = self.m3.q()
self.assertEqual(8, len(q3))
for h, v in q3.items():
self.assertEqual(self.m3.q(h), v)
def test_from_q(self):
self._assert_equal_belief(self.m1, MassFunction.from_q(self.m1.q()), 8)
self._assert_equal_belief(self.m2, MassFunction.from_q(self.m2.q()), 8)
self._assert_equal_belief(self.m3, MassFunction.from_q(self.m3.q()), 8)
def test_condition(self):
m1 = self.m1.condition('ad')
self.assertEqual(0.5, m1['a'])
self.assertEqual(0.5, m1['ad'])
m1_un = self.m1.condition('ad', normalization=False)
self.assertEqual(0.2, m1_un[''])
self.assertEqual(0.4, m1_un['a'])
self.assertEqual(0.4, m1_un['ad'])
m3 = self.m3.condition('ac')
self.assertEqual(0.5, m3['ac'])
self.assertAlmostEqual(1.0 / 3.0, m3['c'])
self.assertAlmostEqual(1.0 / 6.0, m3['a'])
m3_un = self.m3.condition('ab', normalization=False)
self.assertAlmostEqual(0.6, m3_un[set()])
self.assertEqual(0.3, m3_un['a'])
self.assertEqual(0.1, m3_un['ab'])
def test_combine_conjunctive(self):
def test(m, empty_mass, places=10):
self.assertAlmostEqual(empty_mass, m[set()], places)
norm = 0.55 + empty_mass
self.assertAlmostEqual(0.15 / norm, m['a'], places)
self.assertAlmostEqual(0.25 / norm, m['b'], places)
self.assertAlmostEqual(0.06 / norm, m['c'], places)
self.assertAlmostEqual(0.09 / norm, m['ac'], places)
# normalized
test(self.m1 & self.m2, 0.0)
test(self.m1.combine_conjunctive(self.m2, sample_count=10000), 0.0, 1)
test(
self.m1.combine_conjunctive(self.m2,
sample_count=1000,
importance_sampling=True), 0.0)
# unnormalized
test(self.m1.combine_conjunctive(self.m2, normalization=False), 0.45)
test(
self.m1.combine_conjunctive(self.m2,
normalization=False,
sample_count=10000), 0.45, 1)
test(
self.m1.combine_conjunctive(self.m2,
normalization=False,
sample_count=10000,
importance_sampling=True), 0.45,
1) # ImpSam should be ignored
# combine multiple mass functions
m_single = self.m1.combine_conjunctive(self.m1).combine_conjunctive(
self.m2)
m_multi = self.m1.combine_conjunctive([self.m1, self.m2])
self._assert_equal_belief(m_single, m_multi, 10)
# combine incompatible mass function
self.assertFalse(self.m1 & MassFunction({(0, 1): 0.8, (0, ): 0.2}))
def test_combine_disjunctive(self):
def test(m, places):
self.assertAlmostEqual(0.2, m['ab'], places)
self.assertAlmostEqual(0.2, m['ac'], places)
self.assertAlmostEqual(0.1, m['b'], places)
self.assertAlmostEqual(0.04, m['bc'], places)
self.assertAlmostEqual(0.06, m['abc'], places)
self.assertAlmostEqual(0.05, m['abd'], places)
self.assertAlmostEqual(0.05, m['acd'], places)
self.assertAlmostEqual(0.3, m['abcd'], places)
test(self.m1 | self.m2, 10)
test(self.m1.combine_disjunctive(self.m2, sample_count=10000), 1)
# combine multiple mass functions
m_single = self.m1.combine_disjunctive(self.m1).combine_disjunctive(
self.m2)
m_multi = self.m1.combine_disjunctive([self.m1, self.m2])
for h, v in m_single.items():
self.assertAlmostEqual(v, m_multi[h])
def test_weight_function(self):
"""
Examples from:
T. Denoeux (2008), "Conjunctive and disjunctive combination of belief functions induced by nondistinct bodies of evidence",
Artificial Intelligence 172, 234-264.
"""
m1 = MassFunction({'ab': 0.3, 'bc': 0.5, 'abc': 0.2})
w1 = m1.weight_function()
self.assertAlmostEqual(1.0, w1[frozenset('')])
self.assertAlmostEqual(1.0, w1[frozenset('a')])
self.assertAlmostEqual(7. / 4., w1[frozenset('b')])
self.assertAlmostEqual(2. / 5., w1[frozenset('ab')])
self.assertAlmostEqual(1.0, w1[frozenset('c')])
self.assertAlmostEqual(1.0, w1[frozenset('ac')])
self.assertAlmostEqual(2. / 7., w1[frozenset('bc')])
m2 = MassFunction({'b': 0.3, 'bc': 0.4, 'abc': 0.3})
w2 = m2.weight_function()
self.assertAlmostEqual(1.0, w2[frozenset('')])
self.assertAlmostEqual(1.0, w2[frozenset('a')])
self.assertAlmostEqual(0.7, w2[frozenset('b')])
self.assertAlmostEqual(1.0, w2[frozenset('ab')])
self.assertAlmostEqual(1.0, w2[frozenset('c')])
self.assertAlmostEqual(1.0, w2[frozenset('ac')])
self.assertAlmostEqual(3. / 7., w2[frozenset('bc')])
def test_combine_cautious(self):
"""
Examples from:
T. Denoeux (2008), "Conjunctive and disjunctive combination of belief functions induced by nondistinct bodies of evidence",
Artificial Intelligence 172, 234-264.
"""
m1 = MassFunction({'ab': 0.3, 'bc': 0.5, 'abc': 0.2})
m2 = MassFunction({'b': 0.3, 'bc': 0.4, 'abc': 0.3})
m = m1.combine_cautious(m2)
self.assertAlmostEqual(0.0, m[''])
self.assertAlmostEqual(0.0, m['a'])
self.assertAlmostEqual(0.6, m['b'])
self.assertAlmostEqual(0.12, m['ab'])
self.assertAlmostEqual(0.0, m['c'])
self.assertAlmostEqual(0.0, m['ac'])
self.assertAlmostEqual(0.2, m['bc'])
self.assertAlmostEqual(0.08, m['abc'])
def test_conflict(self):
self.assertAlmostEqual(-log(0.55), self.m1.conflict(self.m2), 8)
self.assertAlmostEqual(-log(0.55),
self.m1.conflict(self.m2, sample_count=10000),
1)
self.assertEqual(float('inf'), self.m1.conflict(MassFunction({'e':
1})))
def test_normalize(self):
v = self.m1['a']
del self.m1['a']
self.m1.normalize()
self.assertAlmostEqual(0.2 / (1 - v), self.m1['b'])
self.assertAlmostEqual(0.1 / (1 - v), self.m1['ad'])
self.assertAlmostEqual(0.3 / (1 - v), self.m1['abcd'])
self.assertEqual(0, len(MassFunction().normalize()))
def test_multiple_dimensions(self):
md1 = MassFunction({(('a', 1), ('b', 2)): 0.8, (('a', 1), ): 0.2})
md2 = MassFunction({(('a', 1), ('b', 2), ('c', 1)): 1.0})
md12 = md1 & md2
self.assertAlmostEqual(0.2, md12[{('a', 1)}])
self.assertAlmostEqual(0.8, md12[{('a', 1), ('b', 2)}])
def test_map(self):
# vacuous extension
frame = {1, 2}
extended = self.m3.map(lambda h: product(h, frame))
result = MassFunction({
(): 0.4,
(('c', 1), ('c', 2)): 0.2,
(('a', 1), ('a', 2), ('c', 1), ('c', 2)): 0.3,
(('a', 1), ('a', 2), ('b', 1), ('b', 2)): 0.1
})
self.assertEqual(result, extended)
# projection
projected = extended.map(lambda h: (t[0] for t in h))
self.assertEqual(self.m3, projected)
def test_pignistic(self):
p1 = self.m1.pignistic()
self.assertEqual(0.525, p1['a'])
self.assertEqual(0.275, p1['b'])
self.assertEqual(0.075, p1['c'])
self.assertEqual(0.125, p1['d'])
p3 = self.m3.pignistic()
self.assertEqual(0.2 / 0.6, p3['a'])
self.assertEqual(0.05 / 0.6, p3['b'])
self.assertEqual(0.35 / 0.6, p3['c'])
def test_local_conflict(self):
c = 0.5 * log(1 / 0.5, 2) + 0.2 * log(1 / 0.2, 2) + 0.3 * log(
2 / 0.3, 2)
self.assertEqual(c, self.m2.local_conflict())
self.assertTrue(isnan(self.m3.local_conflict()))
# pignistic entropy
h = -0.125 * log(0.125, 2) - 0.075 * log(0.075, 2) - 0.275 * log(
0.275, 2) - 0.525 * log(0.525, 2)
self.assertAlmostEqual(h, self.m1.pignistic().local_conflict())
def test_hartley_measure(self):
self.assertEqual(0.1 + 0.3 * log(4, 2), self.m1.hartley_measure())
def test_norm(self):
self.assertEqual(0, self.m1.norm(self.m1))
self.assertEqual(0, self.m1.norm(self.m1, p=1))
m3 = MassFunction({'e': 1.0})
len_m1 = sum([v**2 for v in self.m1.values()])
self.assertEqual((1 + len_m1)**0.5, self.m1.norm(m3))
def test_prune(self):
self.assertTrue('a' in self.m2)
pruned = self.m2.prune()
self.assertFalse('a' in pruned)
self._assert_equal_belief(self.m2, pruned, 10)
def test_sample(self):
sample_count = 1000
samples_ran = self.m1.sample(sample_count, quantization=False)
samples_ml = self.m1.sample(sample_count, quantization=True)
self.assertEqual(sample_count, len(samples_ran))
self.assertEqual(sample_count, len(samples_ml))
for h, v in self.m1.items():
self.assertAlmostEqual(v,
float(samples_ran.count(h)) / sample_count,
places=1)
self.assertAlmostEqual(v,
float(samples_ml.count(h)) / sample_count,
places=20)
self.assertEqual(0, len(MassFunction().sample(sample_count)))
def test_markov(self):
def test(m, places):
self.assertAlmostEqual(0.4 * 0.8, m[(4, 6)], places)
self.assertAlmostEqual(0.4 * 0.2, m[(5, )], places)
self.assertAlmostEqual(0.6 * 0.2 * 0.2, m[(0, 1)], places)
self.assertAlmostEqual(0.6 * 0.2 * 0.8, m[(-1, 1)], places)
self.assertAlmostEqual(0.6 * 0.2 * 0.8, m[(0, 2)], places)
self.assertAlmostEqual(0.6 * 0.8 * 0.8, m[(-1, 0, 1, 2)], places)
m = MassFunction([((0, 1), 0.6), ((5, ), 0.4)])
transition_model = lambda s: MassFunction([((s - 1, s + 1), 0.8),
((s, ), 0.2)])
transition_model_mc = lambda s, n: transition_model(s).sample(n)
test(m.markov(transition_model), 10)
test(m.markov(transition_model_mc, sample_count=10000), 2)
def test_gbt(self):
def test(m, places):
self.assertAlmostEqual(0.3 * 0.8 / (1 - 0.7 * 0.2), m['ab'],
places)
self.assertAlmostEqual(0.3 * 0.2 / (1 - 0.7 * 0.2), m['a'], places)
self.assertAlmostEqual(0.7 * 0.8 / (1 - 0.7 * 0.2), m['b'], places)
pl = [('a', 0.3), ('b', 0.8), ('c', 0.0)]
test(MassFunction.gbt(pl), 10)
test(MassFunction.gbt(pl, sample_count=10000), 2)
pl = {'a': 0.3, 'b': 0.8, 'c': 0.0, 'd': 1.0}
self._assert_equal_belief(MassFunction.gbt(pl),
MassFunction.gbt(pl, sample_count=10000), 1)
def test_frame(self):
self.assertEqual({'a', 'b', 'c', 'd'}, self.m1.frame())
self.assertEqual({'a', 'b', 'c'}, self.m2.frame())
self.assertEqual(set(), MassFunction().frame())
def test_singletons(self):
self.assertSetEqual(
{frozenset('a'),
frozenset('b'),
frozenset('c'),
frozenset('d')}, self.m1.singletons())
def test_focal(self):
self.assertEqual(4, len(list(self.m1.focal())))
for f in self.m1.focal():
self.assertTrue(f in self.m1, f)
self.m1[{'b'}] = 0
self.assertEqual(3, len(self.m1.focal()))
self.assertFalse({'b'} in self.m1.focal())
def test_core(self):
self.assertEqual({'a', 'b', 'c', 'd'}, self.m1.core())
self.m1[{'a', 'b', 'c', 'd'}] = 0
self.assertEqual({'a', 'b', 'd'}, self.m1.core())
self.assertEqual(set(), MassFunction().core())
# test combined core
self.assertEqual({'a', 'b'}, self.m1.core(self.m2))
def test_all(self):
expected = {
frozenset(),
frozenset('a'),
frozenset('b'),
frozenset('ab')
}
self.assertSetEqual(expected,
set(MassFunction({
'a': 0.1,
'b': 0
}).all()))
def test_max_bel(self):
self.assertEqual(frozenset('a'), self.m1.max_bel())
self.assertEqual(frozenset('c'), self.m3.max_bel())
self.assertTrue(
MassFunction({
('ab'): 1
}).max_bel() in {frozenset('a'), frozenset('b')})
def test_max_pl(self):
self.assertEqual(frozenset('a'), self.m1.max_pl())
self.assertEqual(frozenset('c'), self.m3.max_pl())
self.assertTrue(
MassFunction({
('ab'): 0.8,
'c': 0.2
}).max_pl() in {frozenset('a'), frozenset('b')})
def test_combine_gbt(self):
pl = [('b', 0.8), ('c', 0.5)]
correct = self.m1.combine_conjunctive(MassFunction.gbt(pl))
self._assert_equal_belief(correct, self.m1.combine_gbt(pl), 10)
self._assert_equal_belief(self.m1.combine_gbt(pl),
self.m1.combine_gbt(pl, sample_count=10000),
1)
self._assert_equal_belief(self.m2.combine_gbt(pl),
self.m2.combine_gbt(pl, sample_count=10000),
1)
# Bayesian special case
p_prior = self.m1.pignistic()
p_posterior = p_prior.combine_gbt(pl)
p_correct = MassFunction()
for s, l in pl:
p_correct[(s, )] = l * p_prior[(s, )]
p_correct.normalize()
self._assert_equal_belief(p_correct, p_posterior, 10)
def test_is_probabilistic(self):
self.assertFalse(self.m1.is_probabilistic())
self.assertTrue(self.m1.pignistic().is_probabilistic())
for p in self.m1.sample_probability_distributions(100):
self.assertTrue(p.is_probabilistic())
def test_sample_probability_distributions(self):
for p in self.m1.sample_probability_distributions(100):
self.assertTrue(self.m1.is_compatible(p))
def test_from_possibility(self):
"""
Example 1 from:
D. Dubois, H. Prade, P. Smets (2008), "A definition of subjective possibility",
International Journal of Approximate Reasoning 48 (2), 352-364.
"""
x = 0.6
poss = {'a': 1, 'b': x, 'c': 1 - x}
m = MassFunction.from_possibility(poss)
self.assertEqual(1 - x, m['a'])
self.assertEqual(2 * x - 1, m['ab'])
self.assertEqual(1 - x, m['abc'])
def test_pignistic_inverse(self):
"""
Example 1 from:
A. Aregui, T. Denoeux (2008), "Constructing consonant belief functions from sample data using confidence sets of pignistic probabilities",
International Journal of Approximate Reasoning 49, 575-594.
"""
p = MassFunction({'a': 0.7, 'b': 0.2, 'c': 0.1})
m = MassFunction.pignistic_inverse(p)
self.assertEqual(0.5, m['a'])
self.assertAlmostEqual(0.2, m['ab'])
self.assertAlmostEqual(0.3, m['abc'])
def test_to_array_index(self):
self.assertEqual(0, MassFunction._to_array_index((), ('a', 'b', 'c')))
self.assertEqual(
1, MassFunction._to_array_index(('a', ), ('a', 'b', 'c')))
self.assertEqual(
2, MassFunction._to_array_index(('b', ), ('a', 'b', 'c')))
self.assertEqual(
4, MassFunction._to_array_index(('c', ), ('a', 'b', 'c')))
self.assertEqual(
7, MassFunction._to_array_index(('a', 'b', 'c'), ('a', 'b', 'c')))
def test_from_array_index(self):
self.assertEqual(frozenset(),
MassFunction._from_array_index(0, ('a', 'b', 'c')))
self.assertEqual(frozenset(('a', )),
MassFunction._from_array_index(1, ('a', 'b', 'c')))
self.assertEqual(frozenset(('b', )),
MassFunction._from_array_index(2, ('a', 'b', 'c')))
self.assertEqual(frozenset(('c', )),
MassFunction._from_array_index(4, ('a', 'b', 'c')))
self.assertEqual(frozenset(('a', 'b', 'c')),
MassFunction._from_array_index(7, ('a', 'b', 'c')))
def test_to_array(self):
self.assertListEqual([0, 0, 0.5, 0.0, 0.2, 0.3, 0, 0],
list(self.m2.to_array(('a', 'b', 'c'))))
def test_from_array(self):
self._assert_equal_belief(
self.m1,
MassFunction.from_array(self.m1.to_array(self.m1.frame()),
self.m1.frame()))
def test_confidence_intervals(self):
"""
Numbers taken from:
W.L. May, W.D. Johnson, A SAS macro for constructing simultaneous confidence intervals for multinomial proportions,
Computer methods and Programs in Biomedicine 53 (1997) 153-162.
"""
hist = {1: 91, 2: 49, 3: 37, 4: 43}
lower, upper = MassFunction._confidence_intervals(hist, 0.05)
self.assertAlmostEqual(0.33, lower[1], places=2)
self.assertAlmostEqual(0.16, lower[2], places=2)
self.assertAlmostEqual(0.11, lower[3], places=2)
self.assertAlmostEqual(0.14, lower[4], places=2)
for h, p_u in upper.items():
p = hist[h] / float(sum(hist.values()))
self.assertAlmostEqual(2. * p - lower[h], p_u, places=1)
def test_from_samples(self):
"""
Example 1 (maxbel) and example 7 (ordered) from:
T. Denoeux (2006), "Constructing belief functions from sample data using multinomial confidence regions",
International Journal of Approximate Reasoning 42, 228-252.
Example 6 (mcd) from:
A. Aregui, T. Denoeux (2008), "Constructing consonant belief functions from sample data using confidence sets of pignistic probabilities",
International Journal of Approximate Reasoning 49, 575-594.
"""
precipitation_data = {1: 48, 2: 17, 3: 19, 4: 11, 5: 6, 6: 9}
failure_mode_data = {
1: 5,
2: 11,
3: 19,
4: 30,
5: 58,
6: 67,
7: 92,
8: 118,
9: 173,
10: 297
}
psych_data = {1: 91, 2: 49, 3: 37, 4: 43}
# maxbel
m = MassFunction.from_samples(psych_data, method='maxbel', alpha=0.05)
p_lower, p_upper = MassFunction._confidence_intervals(psych_data, 0.05)
def p_lower_set(hs):
l = u = 0
for h in psych_data.keys():
if h in hs:
l += p_lower[h]
else:
u += p_upper[h]
return max(l, 1 - u)
bel_sum = 0
for h in m.all():
bel = m.bel(h)
bel_sum += bel
self.assertLessEqual(bel, p_lower_set(h)) # constraint (24)
self.assertEqual(1, sum(m.values())) # constraint (25)
self.assertGreaterEqual(min(m.values()), 0) # constraint (26)
self.assertGreaterEqual(bel_sum, 6.23) # optimization criterion
# maxbel-ordered
m = MassFunction.from_samples(precipitation_data,
method='maxbel-ordered',
alpha=0.05)
self.assertAlmostEqual(0.32, m[(1, )], 2)
self.assertAlmostEqual(0.085, m[(2, )], 3)
self.assertAlmostEqual(0.098, m[(3, )], 3)
self.assertAlmostEqual(0.047, m[(4, )], 3)
self.assertAlmostEqual(0.020, m[(5, )], 3)
self.assertAlmostEqual(0.035, m[(6, )], 3)
self.assertAlmostEqual(0.13, m[range(1, 5)], 2)
self.assertAlmostEqual(0.11, m[range(1, 6)], 2)
self.assertAlmostEqual(0.012, m[range(2, 6)], 2)
self.assertAlmostEqual(0.14, m[range(2, 7)], 2)
# mcd
poss = {
1: 0.171,
2: 0.258,
3: 0.353,
4: 0.462,
5: 0.688,
6: 0.735,
7: 0.804,
8: 0.867,
9: 0.935,
10: 1.0
} # 8: 0.873
m = MassFunction.from_samples(failure_mode_data,
method='mcd',
alpha=0.1)
self._assert_equal_belief(MassFunction.from_possibility(poss), m, 1)
# mcd-approximate
m = MassFunction.from_samples(failure_mode_data,
method='mcd-approximate',
alpha=0.1)
poss = {
1: 0.171,
2: 0.258,
3: 0.353,
4: 0.462,
5: 0.688,
6: 0.747,
7: 0.875,
8: 0.973,
9: 1.0,
10: 1.0
}
self._assert_equal_belief(MassFunction.from_possibility(poss), m, 2)
# bayesian
m = MassFunction.from_samples(precipitation_data,
method='bayesian',
s=0)
for e, n in precipitation_data.items():
self.assertEqual(n / float(sum(precipitation_data.values())),
m[(e, )])
# idm
m = MassFunction.from_samples(precipitation_data, method='idm', s=1)
self.assertAlmostEqual(
1. / float(sum(precipitation_data.values()) + 1),
m[MassFunction._convert(precipitation_data.keys())])
for e, n in precipitation_data.items():
self.assertAlmostEqual(
n / float(sum(precipitation_data.values()) + 1), m[(e, )])
def test_powerset(self):
s = range(2)
p = set(powerset(s))
self.assertEqual(4, len(p))
self.assertTrue(set() in p)
self.assertTrue({0} in p)
self.assertTrue({1} in p)
self.assertTrue({0, 1} in p)
self.assertEqual(2**6, len(list(powerset(range(6)))))
def test_gbt_m(self):
likelihoods = [('a', 0.3), ('b', 0.8), ('c', 0.0),
('d', 0.5)] # likelihoods as a list
m = MassFunction.gbt(likelihoods)
for h, v in m.items():
self.assertAlmostEqual(v, gbt_m(h, likelihoods), 8)
def test_gbt_bel(self):
likelihoods = {'a': 0.3, 'b': 0.8, 'c': 0.0, 'd': 0.5}
m = MassFunction.gbt(likelihoods)
for h in m:
self.assertAlmostEqual(m.bel(h), gbt_bel(h, likelihoods), 8)
def test_gbt_pl(self):
likelihoods = {'a': 0.3, 'b': 0.8, 'c': 0.0, 'd': 0.5}
m = MassFunction.gbt(likelihoods)
for h in m:
self.assertAlmostEqual(m.pl(h), gbt_pl(h, likelihoods), 8)
def test_gbt_q(self):
likelihoods = {'a': 0.3, 'b': 0.8, 'c': 0.0, 'd': 0.5}
m = MassFunction.gbt(likelihoods)
for h in m:
self.assertAlmostEqual(m.q(h), gbt_q(h, likelihoods), 8)
def test_gbt_pignistic(self):
likelihoods = {'a': 0.3, 'b': 0.8, 'c': 0.0, 'd': 0.5, 'e': 1.0}
p = MassFunction.gbt(likelihoods).pignistic()
for s in p:
self.assertAlmostEqual(p[s],
gbt_pignistic(tuple(s)[0], likelihoods), 8)
def test_multiplication(self):
product = 0.5 * self.m1
for (h, v) in self.m1.items():
self.assertEqual(0.5 * v, product[h])
self._assert_equal_belief(0.5 * self.m1, self.m1 * 0.5)
def test_addition(self):
m_sum = self.m2 + self.m3
self.assertEqual(0.4, m_sum['c'])
self.assertEqual(0.6, m_sum['a', 'c'])
self.assertEqual(0.5, m_sum['b'])
self.assertEqual(0.4, m_sum[()])
self.assertEqual(0.1, m_sum['a', 'b'])
self.assertEqual(0.0, m_sum['a'])
def time_markov_1000():
samples = MassFunction.gbt(random_likelihoods(4)).sample(1000)
return measure_time(MassFunction.gbt(random_likelihoods(4)).markov, lambda s, n: samples[:n], sample_count=1000)
def test_gbt_m(self):
likelihoods = [('a', 0.3), ('b', 0.8), ('c', 0.0),
('d', 0.5)] # likelihoods as a list
m = MassFunction.gbt(likelihoods)
for h, v in m.items():
self.assertAlmostEqual(v, gbt_m(h, likelihoods), 8)
def error_combine_conjunctive_1000_dir():
m1 = MassFunction.gbt(random_likelihoods(6))
m2 = MassFunction.gbt(random_likelihoods(6))
return measure_error(m1 & m2, m1.combine_conjunctive, m2, sample_count=1000, importance_sampling=False)
def test_from_samples(self):
"""
Example 1 (maxbel) and example 7 (ordered) from:
T. Denoeux (2006), "Constructing belief functions from sample data using multinomial confidence regions",
International Journal of Approximate Reasoning 42, 228-252.
Example 6 (mcd) from:
A. Aregui, T. Denoeux (2008), "Constructing consonant belief functions from sample data using confidence sets of pignistic probabilities",
International Journal of Approximate Reasoning 49, 575-594.
"""
precipitation_data = {1: 48, 2: 17, 3: 19, 4: 11, 5: 6, 6: 9}
failure_mode_data = {
1: 5,
2: 11,
3: 19,
4: 30,
5: 58,
6: 67,
7: 92,
8: 118,
9: 173,
10: 297
}
psych_data = {1: 91, 2: 49, 3: 37, 4: 43}
# maxbel
m = MassFunction.from_samples(psych_data, method='maxbel', alpha=0.05)
p_lower, p_upper = MassFunction._confidence_intervals(psych_data, 0.05)
def p_lower_set(hs):
l = u = 0
for h in psych_data.keys():
if h in hs:
l += p_lower[h]
else:
u += p_upper[h]
return max(l, 1 - u)
bel_sum = 0
for h in m.all():
bel = m.bel(h)
bel_sum += bel
self.assertLessEqual(bel, p_lower_set(h)) # constraint (24)
self.assertEqual(1, sum(m.values())) # constraint (25)
self.assertGreaterEqual(min(m.values()), 0) # constraint (26)
self.assertGreaterEqual(bel_sum, 6.23) # optimization criterion
# maxbel-ordered
m = MassFunction.from_samples(precipitation_data,
method='maxbel-ordered',
alpha=0.05)
self.assertAlmostEqual(0.32, m[(1, )], 2)
self.assertAlmostEqual(0.085, m[(2, )], 3)
self.assertAlmostEqual(0.098, m[(3, )], 3)
self.assertAlmostEqual(0.047, m[(4, )], 3)
self.assertAlmostEqual(0.020, m[(5, )], 3)
self.assertAlmostEqual(0.035, m[(6, )], 3)
self.assertAlmostEqual(0.13, m[range(1, 5)], 2)
self.assertAlmostEqual(0.11, m[range(1, 6)], 2)
self.assertAlmostEqual(0.012, m[range(2, 6)], 2)
self.assertAlmostEqual(0.14, m[range(2, 7)], 2)
# mcd
poss = {
1: 0.171,
2: 0.258,
3: 0.353,
4: 0.462,
5: 0.688,
6: 0.735,
7: 0.804,
8: 0.867,
9: 0.935,
10: 1.0
} # 8: 0.873
m = MassFunction.from_samples(failure_mode_data,
method='mcd',
alpha=0.1)
self._assert_equal_belief(MassFunction.from_possibility(poss), m, 1)
# mcd-approximate
m = MassFunction.from_samples(failure_mode_data,
method='mcd-approximate',
alpha=0.1)
poss = {
1: 0.171,
2: 0.258,
3: 0.353,
4: 0.462,
5: 0.688,
6: 0.747,
7: 0.875,
8: 0.973,
9: 1.0,
10: 1.0
}
self._assert_equal_belief(MassFunction.from_possibility(poss), m, 2)
# bayesian
m = MassFunction.from_samples(precipitation_data,
method='bayesian',
s=0)
for e, n in precipitation_data.items():
self.assertEqual(n / float(sum(precipitation_data.values())),
m[(e, )])
# idm
m = MassFunction.from_samples(precipitation_data, method='idm', s=1)
self.assertAlmostEqual(
1. / float(sum(precipitation_data.values()) + 1),
m[MassFunction._convert(precipitation_data.keys())])
for e, n in precipitation_data.items():
self.assertAlmostEqual(
n / float(sum(precipitation_data.values()) + 1), m[(e, )])
def time_bel_h():
return measure_time(MassFunction.gbt(random_likelihoods(12)).bel, hypothesis=frozenset(range(10)))
def setUp(self):
self.m1 = MassFunction({'a':0.4, 'b':0.2, 'ad':0.1, 'abcd':0.3})
self.m2 = MassFunction({'b':0.5, 'c':0.2, 'ac':0.3, 'a':0.0})
self.m3 = MassFunction({():0.4, 'c':0.2, 'ac':0.3, 'ab':0.1}) # unnormalized mass function
random.seed(0) # make tests deterministic
def time_combine_conjunctive_1000_imp():
m1 = MassFunction.gbt(random_likelihoods(6))
m2 = MassFunction.gbt(random_likelihoods(6))
return measure_time(m1.combine_conjunctive, m2, sample_count=1000, importance_sampling=True)
def test_gbt_q(self):
likelihoods = {'a': 0.3, 'b': 0.8, 'c': 0.0, 'd': 0.5}
m = MassFunction.gbt(likelihoods)
for h in m:
self.assertAlmostEqual(m.q(h), gbt_q(h, likelihoods), 8)
def time_combine_disjunctive_1000():
m1 = MassFunction.gbt(random_likelihoods(6))
m2 = MassFunction.gbt(random_likelihoods(6))
return measure_time(m1.combine_disjunctive, m2, sample_count=1000)
def test_from_q(self):
self._assert_equal_belief(self.m1, MassFunction.from_q(self.m1.q()), 8)
self._assert_equal_belief(self.m2, MassFunction.from_q(self.m2.q()), 8)
self._assert_equal_belief(self.m3, MassFunction.from_q(self.m3.q()), 8)
