def test_extract_conditional_random_variable(self): cond_prob = Bayesian.ConditionalProbability(rv_a, [rv_b], { 'b': 0.4, '~b': 0.3 }) parsed_rv, parsed_probability = Parser.extract_conditional_random_variable( 'myRV(a, [b], [b: 0.4, ~b: 0.3]).') self.assertEqual(Semantics.Sentence('a', random_variable=True), parsed_rv) self.assertTrue(cond_prob == parsed_probability) cond_prob = Bayesian.ConditionalProbability(rv_a, [rv_b, rv_c], { 'bc': 0.2, 'b~c': 0.4, '~bc': 0.1, '~b~c': 0.7 }) parsed_rv, parsed_probability = Parser.extract_conditional_random_variable( 'myRV(a, [b, c], [bc: 0.2, b~c: 0.4, ~bc: 0.1, ~b~c: 0.7]).') self.assertEqual(Semantics.Sentence('a', random_variable=True), parsed_rv) self.assertTrue(cond_prob == parsed_probability) cond_prob = Bayesian.ConditionalProbability(rv_a, [rv_c], { 'c': 0.2, '~c': 0.3 }) parsed_rv, parsed_probability = Parser.extract_conditional_random_variable( 'myRV( a , [ c ] , [~c : 0.3, c: 0.2]).') self.assertEqual(Semantics.Sentence('a', random_variable=True), parsed_rv) self.assertTrue(cond_prob == parsed_probability)
def extract_rule(rule, random_variables): if not matches_rule_declaration(rule): raise ProgramParseException( "Provided rule does not match required format") extracted = extract_from_parentheses(rule).split(',', 1) head = Semantics.Sentence(extracted[0].strip()) body = [] for elem in extract_from_square_brackets(extracted[1].strip()).split(','): if len(elem) == 0: continue rv = Semantics.Sentence(elem.strip(), random_variable=True) is_negation = elem.strip().startswith(NEGATION_CHAR) if is_negation: rv = Semantics.Sentence(elem.strip()[1:], random_variable=True) if rv in random_variables: body.append( Semantics.Sentence(rv.symbol, random_variable=True, negation=is_negation)) else: body.append(Semantics.Sentence(elem.strip())) return Semantics.Rule(head, body)
def cow_framework(): JN = Semantics.Sentence('JN') not_JN = Semantics.Sentence('not_JN') language = [ HP, not_HP, HOC, not_HOC, CCA, not_CCA, FM, not_FM, JN, not_JN, JF, CM ] rules = [ Semantics.Rule(HP, [HOC, CCA, not_FM]), Semantics.Rule(HOC, []), Semantics.Rule(FM, [CM]), Semantics.Rule(CCA, [not_JN]), Semantics.Rule(JN, [JF]) ] assumptions = [not_HP, not_HOC, not_CCA, not_FM, not_JN] contraries = { not_HP: Semantics.Contrary(not_HP, HP), not_HOC: Semantics.Contrary(not_HOC, HOC), not_CCA: Semantics.Contrary(not_CCA, CCA), not_FM: Semantics.Contrary(not_FM, FM), not_JN: Semantics.Contrary(not_JN, JN), HP: Semantics.Contrary(HP, not_HP), HOC: Semantics.Contrary(HOC, not_HOC), CCA: Semantics.Contrary(CCA, not_CCA), FM: Semantics.Contrary(FM, not_FM), JN: Semantics.Contrary(JN, not_JN) } random_variables = [JF, CM] BN = Bayesian.BayesianNetwork({CM.symbol: 0.1, JF.symbol: 0.8}) return Semantics.BABA(language, rules, assumptions, contraries, random_variables, BN)
def test_Random_Variables_equality(self): rv1 = Semantics.Sentence('a', random_variable=True) rv2 = Semantics.Sentence('a', random_variable=True) rv3 = Semantics.Sentence('b', random_variable=True) self.assertEqual(rv1, rv2) self.assertNotEqual(rv1, rv3) self.assertNotEqual(rv2, rv3)
def extract_contrary(contrary): if not matches_contrary_declaration(contrary): raise ProgramParseException( "Provided contrary does not match required format") extracted = extract_from_parentheses(contrary).split(',') assumption = Semantics.Sentence(extracted[0].strip()) contrary = Semantics.Sentence(extracted[1].strip()) return Semantics.Contrary(assumption, contrary)
def test_extract_assumption(self): self.assertEqual(Parser.extract_assumption('myAsm(a).'), Semantics.Sentence('a')) self.assertEqual(Parser.extract_assumption('myAsm(myAsm).'), Semantics.Sentence('myAsm')) self.assertEqual(Parser.extract_assumption('myAsm(As09).'), Semantics.Sentence('As09')) self.assertEqual(Parser.extract_assumption('myAsm(abcde).'), Semantics.Sentence('abcde'))
def test_RandomVariable_str_function(self): self.assertEqual( str(Semantics.Sentence('a', random_variable=True, negation=True)), "~a") self.assertEqual( str(Semantics.Sentence('b', random_variable=True, negation=False)), "b") self.assertEqual( str(Semantics.Sentence('c', random_variable=True, negation=True)), "~c")
def test_extract_random_variable(self): self.assertEqual((Semantics.Sentence('a', random_variable=True), 0.5), Parser.extract_random_variable('myRV(a, 0.5).')) self.assertEqual( (Semantics.Sentence('abc', random_variable=True), 0.00001), Parser.extract_random_variable('myRV(abc, 0.00001).')) self.assertEqual((Semantics.Sentence('t', random_variable=True), 1), Parser.extract_random_variable('myRV(t, 1).')) self.assertEqual((Semantics.Sentence('a', random_variable=True), 0.1), Parser.extract_random_variable('myRV(a,0.1).')) self.assertEqual((Semantics.Sentence( 'a', random_variable=True, negation=True), 0.9), Parser.extract_random_variable('myRV( ~a, 0.1).'))
def test_r_grounded_semantics_with_negated_random_variable(self): baba = ExampleFrameworks.r_framework() baba.rv_world = [ Semantics.Sentence('s', random_variable=True, negation=True), Semantics.Sentence('t', random_variable=True, negation=False) ] grounded = Semantics.grounded(baba) self.assertEqual(1, len(grounded)) grounded_set = grounded.pop() self.assertEqual(2, len(grounded_set.elements)) self.assertTrue(all([elem in grounded_set.elements for elem in [a, c]]))
def test_generate_worlds(self): a = Semantics.Sentence('a', random_variable=True) a_neg = Semantics.Sentence('a', random_variable=True, negation=True) b = Semantics.Sentence('b', random_variable=True) b_neg = Semantics.Sentence('b', random_variable=True, negation=True) c = Semantics.Sentence('c', random_variable=True) four_worlds = Utils.generate_worlds([a, b]) self.assertEqual(4, len(four_worlds)) for world in four_worlds: self.assertEqual(2, len(world)) self.assertFalse(a in world and a_neg in world) self.assertFalse(b in world and b_neg in world) eight_worlds = Utils.generate_worlds([a, b, c]) self.assertEqual(8, len(eight_worlds))
def generate_worlds(random_variables): worlds = [] for rv in random_variables: pos = Semantics.Sentence(rv.symbol, random_variable=True) neg = Semantics.Sentence(rv.symbol, random_variable=True, negation=True)\ possible_world = [pos, neg] if len(worlds) == 0: worlds = [[pos], [neg]] continue worlds = list(itertools.product(worlds, possible_world)) worlds = [flatten(list(world)) for world in worlds] return worlds
def conditional_probability_key(self, cond_variables): required_variables = [ rv for rv in cond_variables if Semantics.Sentence( rv.symbol, random_variable=True) in self.conditional_variables ] sorted_variables = sorted(required_variables, key=lambda rv: rv.symbol) return ''.join([str(rv) for rv in sorted_variables])
def extract_random_variable(random_variable): if not matches_random_variable_declaration(random_variable): raise ProgramParseException( "Provided random variable does not match required format") extracted = extract_from_parentheses(random_variable).split(',') is_negation = extracted[0].strip().startswith(NEGATION_CHAR) probability = float(extracted[1].strip()) if is_negation: rv = Semantics.Sentence(extracted[0].strip()[1:], random_variable=True, negation=True) return rv, (1 - probability) else: rv = Semantics.Sentence(extracted[0].strip(), random_variable=True) return rv, probability
def valid_BABA_framework(): f = Semantics.Sentence('f', random_variable=True) language = [a, b, c, d, e, f] rules = [Semantics.Rule(a, [b, c])] assumptions = [b, c] contraries = {b: Semantics.Contrary(b, d), c: Semantics.Contrary(c, e)} random_variables = [f] return Semantics.BABA(language, rules, assumptions, contraries, random_variables, None)
def test_extract_conditional_variables(self): variables = '[a, b]' extracted_variables = Parser.extract_conditional_variables(variables) self.assertEqual(2, len(extracted_variables)) self.assertTrue( all([ elem in [ Semantics.Sentence('a', random_variable=True), Semantics.Sentence('b', random_variable=True) ] for elem in extracted_variables ])) variables = '[a , c, b ]' extracted_variables = Parser.extract_conditional_variables(variables) self.assertEqual(3, len(extracted_variables)) self.assertTrue( all([ elem in [ Semantics.Sentence('a', random_variable=True), Semantics.Sentence('b', random_variable=True), Semantics.Sentence('c', random_variable=True) ] for elem in extracted_variables ])) variables = '[c , a ]' extracted_variables = Parser.extract_conditional_variables(variables) self.assertEqual(2, len(extracted_variables)) self.assertTrue( all([ elem in [ Semantics.Sentence('a', random_variable=True), Semantics.Sentence('c', random_variable=True) ] for elem in extracted_variables ])) rv_a = Semantics.Sentence('a', random_variable=True) rv_b = Semantics.Sentence('b', random_variable=True) rv_c = Semantics.Sentence('c', random_variable=True) self.assertTrue(rv_a in Parser.extract_conditional_variables("[ a]")) self.assertTrue( all(elem in [rv_a, rv_b, rv_c] for elem in Parser.extract_conditional_variables("[b, c , a]")))
def extract_conditional_random_variable(text): if not matches_conditional_random_variable_declaration(text): raise ProgramParseException( "Provided conditional random variable does not match required format" ) rv_definition = extract_from_parentheses(text) arguments = rv_definition.split('[') sentence = Semantics.Sentence(arguments.pop(0).split(',')[0].strip(), random_variable=True) conditional_variables = extract_conditional_variables('[' + arguments.pop(0)) conditional_probabilities = extract_conditional_probabilities( '[' + ''.join(arguments)) conditional_probability = Bayesian.ConditionalProbability( sentence, conditional_variables, conditional_probabilities) return sentence, conditional_probability
def test_parse_program_from_file(self): parser = Parser.BABAProgramParser(filename='BABA_program_1') baba = parser.parse() self.assertTrue( all([ elem in baba.language for elem in [a, _a, b, _b, c, _c, d, _d, e, _e] ])) self.assertEqual(11, len(baba.language)) self.assertTrue( all([elem in baba.assumptions for elem in [a, b, c, d, e]])) self.assertEqual(5, len(baba.assumptions)) self.assertTrue( all([elem in baba.contraries for elem in [a, b, c, d, e]])) self.assertEqual(5, len(baba.contraries)) self.assertIn(Semantics.Sentence('t', random_variable=True), baba.random_variables) self.assertEqual(1, len(baba.random_variables)) self.assertEqual(5, len(baba.rules))
import unittest from PythonSemantics import Semantics, Bayesian bn = Bayesian.BayesianNetwork({'a': 0.5, 'b': 0.8, 'c': 0.3}) a = Semantics.Sentence('a', random_variable=True) a_neg = Semantics.Sentence('a', random_variable=True, negation=True) b = Semantics.Sentence('b', random_variable=True) b_neg = Semantics.Sentence('b', random_variable=True, negation=True) c = Semantics.Sentence('c', random_variable=True) c_neg = Semantics.Sentence('c', random_variable=True, negation=True) d = Semantics.Sentence('d', random_variable=True) class TestBayesianNetwork(unittest.TestCase): def test_validates_valid_network(self): bn.validate() def test_validates_invalid_network(self): def invalid_network_instantiation(): Bayesian.BayesianNetwork({'a': 0.4, 'b': 1.0001, 'c': -0.4}) self.assertRaises(Bayesian.InvalidRandomVariableException, invalid_network_instantiation) def test_p(self): baba = Bayesian.BayesianNetwork({'a': 0.5, 'b': 0.8, 'c': 0.3}) self.assertAlmostEqual(0.5, baba.p(a)) self.assertAlmostEqual(0.5, baba.p(a_neg)) self.assertAlmostEqual(0.8, baba.p(b)) self.assertAlmostEqual(0.2, baba.p(b_neg))
import unittest from PythonSemantics import SemanticsUtils as Utils, Semantics list_a = ['a', 'b'] list_b = ['c', 'd'] list_c = ['e', 'f'] list_d = ['g', 'h'] a = Semantics.Sentence('a') b = Semantics.Sentence('b') c = Semantics.Sentence('c') d = Semantics.Sentence('d') e = Semantics.Sentence('e') f = Semantics.Sentence('f') class TestSemantics(unittest.TestCase): def test_list_combinations_empty(self): self.assertEqual([], Utils.list_combinations([], [])) def test_list_combinations_one_empty(self): self.assertEqual(list_a, Utils.list_combinations(list_a, [])) def test_list_combinations_both_non_empty(self): combinations = Utils.list_combinations(list_a, list_b) self.assertIn(['a', 'c'], combinations) self.assertIn(['a', 'd'], combinations) self.assertIn(['b', 'c'], combinations) self.assertIn(['b', 'd'], combinations) self.assertEqual(4, len(combinations))
def test_random_variable_initialises_with_probability(self): rv = Semantics.Sentence('a', random_variable=True, negation=True) self.assertEqual('a', rv.symbol) self.assertEqual(True, rv.random_variable) self.assertEqual(True, rv.negation)
from PythonSemantics import Semantics, Bayesian a = Semantics.Sentence('a') b = Semantics.Sentence('b') c = Semantics.Sentence('c') d = Semantics.Sentence('d') e = Semantics.Sentence('e') f = Semantics.Sentence('f') g = Semantics.Sentence('g') h = Semantics.Sentence('h') i = Semantics.Sentence('i') j = Semantics.Sentence('j') s = Semantics.Sentence('s', random_variable=True) t = Semantics.Sentence('t', random_variable=True) _a = Semantics.Sentence('_a') _b = Semantics.Sentence('_b') _c = Semantics.Sentence('_c') _d = Semantics.Sentence('_d') _e = Semantics.Sentence('_e') _f = Semantics.Sentence('_f') HP = Semantics.Sentence('HP') not_HP = Semantics.Sentence('not_HP') HOC = Semantics.Sentence('HOC') not_HOC = Semantics.Sentence('not_HOC') CCA = Semantics.Sentence('CCA') not_CCA = Semantics.Sentence('not_CCA') FM = Semantics.Sentence('FM') not_FM = Semantics.Sentence('not_FM')
import unittest from PythonSemantics import ExampleFrameworks, Semantics a = Semantics.Sentence('a') b = Semantics.Sentence('b') c = Semantics.Sentence('c') d = Semantics.Sentence('d') e = Semantics.Sentence('e') f = Semantics.Sentence('f') g = Semantics.Sentence('g') h = Semantics.Sentence('h') i = Semantics.Sentence('i') j = Semantics.Sentence('j') larger_baba = ExampleFrameworks.larger_framework() venice_baba = ExampleFrameworks.venice_framework() s_baba = ExampleFrameworks.s_framework() class TestSemantics(unittest.TestCase): def test_rule_initialises_with_no_body(self): head = 0 rule = Semantics.Rule(head) self.assertEqual(head, rule.head) self.assertEqual([], rule.body, []) def test_rule_initialises_with_body(self): head = 0 body = [1, 2, 3]
import unittest from PythonSemantics import Semantics, Bayesian from PythonSemantics.Parsing import BABAProgramParser as Parser program_1_string = "myAsm(a).\nmyAsm(b).\nmyAsm(c).\nmyAsm(d).\nmyAsm(e).\n" \ "contrary(a, _a).\ncontrary(b, _b).\ncontrary(c, _c).\ncontrary(d, _d)." \ "\ncontrary(e, _e).\nmyRule(_b, [c]).\nmyRule(_a, [b])." \ "\nmyRule(_c, [d]).\nmyRule(_d, [e]).\nmyRule(_e, [d]).\nmyRV(t, 0.5)." a = Semantics.Sentence('a') b = Semantics.Sentence('b') c = Semantics.Sentence('c') d = Semantics.Sentence('d') e = Semantics.Sentence('e') _a = Semantics.Sentence('_a') _b = Semantics.Sentence('_b') _c = Semantics.Sentence('_c') _d = Semantics.Sentence('_d') _e = Semantics.Sentence('_e') t = Semantics.Sentence('t') abc = Semantics.Sentence('abc') ab = Semantics.Sentence('ab') bc = Semantics.Sentence('bc') bd = Semantics.Sentence('bd') sentence = Semantics.Sentence('sentence') _sentence = Semantics.Sentence('_sentence') rv_a = Semantics.Sentence('a', random_variable=True) rv_b = Semantics.Sentence('b', random_variable=True) rv_c = Semantics.Sentence('c', random_variable=True) rv_c_neg = Semantics.Sentence('c', random_variable=True, negation=True)
def extract_conditional_variables(text): variables = extract_from_square_brackets(text) return [ Semantics.Sentence(v.strip(), random_variable=True) for v in variables.split(',') ]
def extract_assumption(assumption): if not matches_assumption_declaration(assumption): raise ProgramParseException( "Provided assumption does not match required format") return Semantics.Sentence(extract_from_parentheses(assumption))